Agent skill

Hypothesis Gen

by gaasher in gaasher/Agent-Loop-Skills

A skill your agent uses when the user wants to generate and literature-vet a pool of novel, testable research hypotheses for a question or domain.

MITAuto-check passedResearch & Science

Install Hypothesis Gen

skills CLI
$ npx skills add gaasher/Agent-Loop-Skills --skill hypothesis-gen -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install gaasher/Agent-Loop-Skills hypothesis-gen --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/gaasher/Agent-Loop-Skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/loops/hypothesis-gen .claude/skills/hypothesis-gen && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
hypothesis-gen
GitHub stars
174
Token cost
~2.6k tokens
SKILL.md length
1,095 words
Files
7
Skills in repo
21
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when the user wants to generate and literature-vet a pool of novel, testable research hypotheses for a question or domain.

  • The user wants to generate and literature-vet a pool of novel
  • SKILL.md covers When to use, Setup, The loop and Ledger, plus 2 more sections
  • Needs S2_API_KEY
  • Testable research hypotheses for a question

What it does

Hypothesis Gen is an agent skill from gaasher/Agent-Loop-Skills. Use when the user wants to generate and literature-vet a pool of novel, testable research hypotheses for a question or domain. A multi-agent loop: a Generator proposes candidate hypotheses, a LiteratureScout grounds each in real retrieved literature (already known? closest prior work? what gap does it fill?), and a Judge scores them against a fixed rubric and keeps the strong, non-duplicate ones; rounds repeat — mutating toward the open gaps — until fresh rounds stop adding keepers. Not for sharpening or…

Its SKILL.md is about 2.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 9 other files (for example `examples/run.example.yaml`, `roles/Generator.md` and `roles/Judge.md`). Compatibility notes: Requires Python 3.9+

It sits in Research & Science, covering Hypothesis generation, Quizzes and assessments and Creative writing and fiction. The repository describes itself as: Loop until it's better — drop-in agentic loops (autoresearch, scientific writing, data analysis, code/SQL/prompt optimization, red-teaming) as open-standard Agent Skills… The licence is MIT.

When your agent uses it

  • The user wants to generate and literature-vet a pool of novel
  • Testable research hypotheses for a question

Example prompts

  • “/hypothesis-gen”

Requirements

  • Python 3
  • A credential in S2_API_KEY
  • Compatibility (from SKILL.md): Requires Python 3.9+

What it can do on your machine

Read from SKILL.md and the folder at commit f1169e6. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are json).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • S2_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Requires Python 3.9+

    From compatibility in the SKILL.md frontmatter.

Context cost

Hypothesis Gen loads about 2.6k tokens when it runs. Until then it costs about 165 tokens; SKILL.md has 1,095 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~165
When it runs · the whole SKILL.md, loaded when a task matches
~2.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from gaasher/Agent-Loop-Skills at commit f1169e6, republished under its MIT licence (© gaasher). 1,095 words, ~2,645 tokens.

Download SKILL.mdSave it as .claude/skills/hypothesis-gen/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
hypothesis-gen
description
Use when the user wants to generate and literature-vet a pool of novel, testable research hypotheses for a question or domain. A multi-agent loop: a Generator proposes candidate hypotheses, a LiteratureScout grounds each in real retrieved literature (already known? closest prior work? what gap does it fill?), and a Judge scores them against a fixed rubric and keeps the strong, non-duplicate ones; rounds repeat — mutating toward the open gaps — until fresh rounds stop adding keepers. Not for sharpening or decomposing a research question (no grounding/scoring there), and not for grading an existing written proposal against the literature.
compatibility
Requires Python 3.9+
metadata.version
0.1.0

Hypothesis Generation Loop

A multi-agent, literature-grounded generation loop. The artifact is a growing pool of hypotheses; the feedback signal is the count of strong, distinct hypotheses that clear the bar — where "strong" is decided against real retrieved literature, not assertion. Each round: generate → ground → judge → keep → mutate toward the gaps, until the pool stops growing (saturation).

The discipline: a hypothesis enters the pool only if the literature says it is not already established (novelty), prior work makes it plausible (grounding), and a feasible test exists. Generating is not confirming — the output is a ranked set of strong candidates to test, each stated with how to test it.

The cast (all in roles/):

  • roles/Generator.md — proposes a batch of candidate hypotheses aimed at the open gaps.
  • roles/LiteratureScout.md — grounds each candidate in real literature (novelty · support · gap); emits litscout.json (validates schemas/litscout.schema.json).
  • roles/Judge.md — scores each against the fixed rubric and decides keep/kill/dedupe; emits verdict.json (validates schemas/verdict.schema.json).

Spawn-or-degrade. On Claude Code, spawn Generator / LiteratureScout / Judge as real Agent subagents each round; otherwise adopt each role inline in this context. You are the orchestrator.

When to use

Use when the user wants candidate hypotheses generated and vetted for a question or domain. Default: run the full generate→ground→judge loop below until saturation. Escape hatch: if the user only wants a single batch (no looping), run one round and report the kept hypotheses. Not for sharpening or decomposing a question, and not for grading an existing written proposal.

Setup

Resolve bindings interactively. If loop.run.yaml exists in the working dir, load it, confirm the values in one line, and skip to the loop. Otherwise: on Claude Code (the AskUserQuestion tool is available) infer a likely value for each binding and present it as the recommended option; on other hosts ask each as a quoted plain-text prompt. Then write loop.run.yaml (format: examples/run.example.yaml) and confirm every value plus the live/degraded literature tier before creating any other files.

bindingmeaningdefaulthow to infer
<question>the research question / domain, plus any scope (field, population, constraints)—ask the user
<gen_n>candidate hypotheses the Generator proposes per round6—
<keep_threshold>rubric score (0-100) a hypothesis must clear to enter the pool65—
<eval_scale>LiteratureScout grounding depth (low/medium/high, see below)medium—
<sandbox_root>where rounds, ledger, and lit cache live./sandbox—
<budget>max rounds6—
<patience>stop after this many rounds with no new kept hypothesis2—
<report>final ranked hypothesis set<sandbox_root>/hypotheses.md—

Grounding depth dial (<eval_scale> caps per round — candidates examined deeply · queries each · papers read full-text):

presetcandidates deepqueries eachfulltext reads
low210 (snippet/abstract only)
medium (recommended)all21
highall33

Literature toolchain. Paper search goes through the sibling literature-search skill — resolve <lit_skill_dir> (it installs as a sibling, e.g. ~/.claude/skills/literature-search/), <lit_py> = python3, and <lit> = <lit_skill_dir>/tools/lit_search.py (note the tools/ segment); append --cache-dir <sandbox_root>/literature/.cache after a subcommand to reuse the cache. Confirm <lit> --help works at setup; if the skill is absent, tell the user and either install it (copy the repo's loops/literature-search folder into ~/.claude/skills/) or degrade all retrieval to WebSearch/WebFetch (tag that evidence source:"web"). The keyless S2 + arXiv core needs no setup; a free S2_API_KEY makes snippet/cite reliable.

API key (optional, never block). The literature-search skill owns the key convention: run <lit> keys --init, then have the user fill the printed keys.env themselves and never paste secrets into chat. Re-run <lit> keys to record the tier in loop.run.yaml (literature_tiers, presence only). A missing key just degrades to the keyless pool → WebSearch.

Initialise the sandbox once bindings are confirmed:

<sandbox_root>/
├── loop.run.yaml        ← resolved bindings + literature_tiers
├── ledger.tsv           ← header only (see Ledger)
└── literature/.cache/   ← lit_search on-disk cache

Start with an empty pool and gaps seeded from <question>; create no round files until the loop runs.

Show full SKILL.md (496 more words)Show less

The loop

pool = the kept hypotheses (starts empty). gaps = open questions the LiteratureScout has surfaced (starts empty; seed from <question>). dry = consecutive rounds with no new keep (starts 0). <N> starts at 1.

Copy this checklist and tick items off:

  • Generate — run roles/Generator.md (spawn-or-degrade) with <question>, the current pool, gaps, and <gen_n>; it writes round<N>/candidates.json (<gen_n> specific, testable, plausibly-novel candidates aimed at the gaps, none duplicating the pool).
  • Ground — run roles/LiteratureScout.md (spawn-or-degrade) on candidates.json with <lit> and the <eval_scale> caps; it writes round<N>/litscout.json (validates schemas/litscout.schema.json) — per candidate: novelty + closest prior work, support, gap, testability, each citing real evidence.
  • Judge — as roles/Judge.md, apply the fixed rubric + evidence gate to litscout.json, checking each candidate against the pool for duplicates; write round<N>/verdict.json (validates schemas/verdict.schema.json): scores, total, keep, duplicate_of.
  • Update — add every keep:true non-duplicate to pool (with scores + grounding + how-to-test); add this round's gap points to gaps. If ≥1 new keep, dry = 0; else dry += 1.
  • Log one ledger row (see Ledger); N = N + 1.
  • Stop check — dry == <patience> (saturation) or N > <budget> → stop (see Stops).

Re-ground every round — novelty is judged from a fresh literature check each round, never carried over, so "the literature already covers this" reliably kills a crowded idea. Every cited snippet comes from a real retrieval that round; on {"error","fallback"} fall back to WebSearch/WebFetch — never invent a paper.

schemas/litscout.schema.json gates the LiteratureScout output — a generic instance:

json
{"round": 2,
 "evaluations": [{"hid": "r2h1", "novelty_assessment": "novel",
   "closest_prior_work": [{"claim": "X tested for facts, not skills", "cites": ["E1"]}],
   "support": [{"claim": "spacing aids motor consolidation", "cites": ["E2"]}],
   "gap": [{"claim": "long-term procedural retention untested at scale", "cites": ["E1"]}],
   "testability_note": "RCT: spaced vs massed schedule, 1-month retention."}],
 "evidence": [{"key": "E1", "title": "...", "source": "s2", "id": "a1b2", "snippet": "...verbatim..."}]}

schemas/verdict.schema.json gates the Judge output — a generic instance:

json
{"round": 2,
 "verdicts": [{"hid": "r2h1",
   "scores": {"novelty": 4, "grounding": 4, "testability": 5, "specificity": 4, "significance": 4},
   "total": 82.0, "keep": true, "gate_failures": [], "duplicate_of": null,
   "rationale": "Closest work shows X untested for skills -> novel; supported; clean RCT named."}]}

Ledger

<sandbox_root>/ledger.tsv, tab-separated, never commas in free text. Header:

round	generated	kept_new	pool_size	top_kept

Example:

round	generated	kept_new	pool_size	top_kept
1	6	3	3	spaced practice aids procedural (not just declarative) retention [82]
2	6	2	5	sleep-timed review beats time-of-day-matched review [78]
3	6	0	5	-

Per-round candidates.json / litscout.json / verdict.json live in round<N>/. Report the best state of the pool when stopping, not just the last round. Leave ledger.tsv, round*/, and literature/ untracked.

Constraints

  • Never fabricate citations or snippets — every evidence entry is a real <lit>/WebFetch retrieval from that round, verbatim; the evidence gate exists to catch fabrication.
  • Novelty is decided by the literature, not assertion — a hypothesis the search shows is already established is killed, however appealing; "I think it's novel" with no closest-work search caps novelty.
  • Generate ≠ confirm — kept hypotheses are strong candidates to test, each stated with its test; never report them as established findings.
  • The rubric is fixed and the keep-bar is stable across rounds, so saturation is a meaningful stop.
  • Reward distinct hypotheses, not volume — duplicates and rewordings are cut.
  • No installs — the sibling literature-search skill is stdlib-only; never print or commit API keys (keys.env stays gitignored at the project root). The sandbox is self-contained — no ../ escapes.
  • Do not pause the loop to ask whether to continue; run until saturation or budget.

Stops

The loop stops on the first of:

  • Saturation — dry == <patience> consecutive rounds add no new kept hypothesis.
  • Budget — <budget> rounds reached.

End with the ranked hypothesis set (<report> path) — each hypothesis with its statement, novelty assessment + closest prior work (cited), supporting evidence (cited), the gap it fills, and how to test it — plus the pool-size trajectory from ledger.tsv and the strongest unexplored gaps, so the user sees both the vetted hypotheses and where a deeper run would look next.

© gaasher, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 6 other files in loops/hypothesis-gen of gaasher/Agent-Loop-Skills.

  • SKILL.md
  • examples/run.example.yaml
  • roles/Generator.md
  • roles/Judge.md
  • roles/LiteratureScout.md
  • schemas/litscout.schema.json
  • schemas/verdict.schema.json

Open the folder on GitHubat commit f1169e6

Compare with similar skills

Hypothesis Gen next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Hypothesis Gen compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Hypothesis Gen this skillgaasher/Agent-Loop-Skills174—~2.6kAutomated safety check: PassMIT
Idea Discovery PipelineGRIND-Lab-Core/night_owl_research_agent106—~4.4kAutomated safety check: WarnNone
Paper NavigatorEvoScientist/EvoSkills475—~6.3kAutomated safety check: NotesApache-2.0
Novelty CheckAI4Scientist/nano-scientist1285 repos~823Automated safety check: PassNone
Ccf Idea Optimizermikubaka88/CCFA-Skills3k—~1.9kAutomated safety check: PassMIT
Novelty Assessmentlingzhi227/agent-research-skills384—~716Automated safety check: PassNone

Similar skills

  • Idea Discovery Pipeline

    GRIND-Lab-Core/night_owl_research_agent

    The full pipeline for idea generation. An agent skill from GRIND-Lab-Core/night_owl_research_agent.

    106 GitHub stars~4.4k tokensUpdated 5 mo ago
    Research & ScienceAuto-check: warnings
  • Paper Navigator

    EvoScientist/EvoSkills

    Find and read academic papers (S2 + arXiv). An agent skill from EvoScientist/EvoSkills.

    475 GitHub stars~6.3k tokensUpdated 8 days ago
    Research & ScienceAuto-check: notes
  • Novelty Check

    AI4Scientist/nano-scientist

    Verify research idea novelty against recent literature. An agent skill from AI4Scientist/nano-scientist.

    128 GitHub starsUsed in 5 repos~823 tokens
    Research & ScienceAuto-check passed
  • Ccf Idea Optimizer

    mikubaka88/CCFA-Skills

    Develop and optimize rough CCF research ideas into problems, insights, mechanisms, and evidence plans.

    3k GitHub stars~1.9k tokensUpdated 22 days ago
    Research & ScienceAuto-check passed
  • Novelty Assessment

    lingzhi227/agent-research-skills

    Assess research idea novelty through systematic literature search.

    384 GitHub stars~716 tokensUpdated 7 mo ago
    Research & ScienceAuto-check passed
  • Novelty Check

    GRIND-Lab-Core/night_owl_research_agent

    Validates that a research idea is genuinely novel vs. An agent skill from GRIND-Lab-Core/night_owl_research_agent.

    106 GitHub stars~1k tokensUpdated 5 mo ago
    Research & ScienceAuto-check passed

More from gaasher/Agent-Loop-Skills

All 21 skills in this repo
  • Alpha Evolve

    gaasher/Agent-Loop-Skills

    A skill your agent uses when the user wants to evolve an ML model/program through population-based search rather than a single sequential refine loop — a generational evolution where parallel…

    174 GitHub starsUsed in 1 repo~3.4k tokens
    Auto-check passed
  • Karpathy

    gaasher/Agent-Loop-Skills

    A skill your agent uses when the user wants the LLM to do its own ML research: a fully-autonomous loop that hacks the training code, runs it, and keeps changes that lower a single scalar metric (e.g.

    174 GitHub starsUsed in 1 repo~2.6k tokens
    Auto-check passed
  • Tournament Autoresearch

    gaasher/Agent-Loop-Skills

    A skill your agent uses when the user wants an autonomous ML research loop that pressure-tests competing ideas before spending compute — several research subagents each propose one architecture…

    174 GitHub starsUsed in 1 repo~3k tokens
    Auto-check passed
  • Dueling Autoresearch

    gaasher/Agent-Loop-Skills

    A skill your agent uses when the user wants two approaches raced head-to-head on a single shared metric — e.g.

    174 GitHub starsUsed in 1 repo~2.6k tokens
    Auto-check: warnings
  • Anomaly Investigation

    gaasher/Agent-Loop-Skills

    A skill your agent uses when the user has a known, already-observed anomaly in their data — a metric spike or drop, an outlier, an unexpected number — and wants its root cause diagnosed, not guessed.

    174 GitHub stars~2.1k tokensUpdated 3 mo ago
    Auto-check passed
  • Blue Team

    gaasher/Agent-Loop-Skills

    A skill your agent uses when the user has concrete failing cases in code or a guardrail/classifier/filter/prompt/API they own — a red-team failure catalogue OR a CI/CD test-failure report (failing…

    174 GitHub stars~3.6k tokensUpdated 3 mo ago
    Auto-check passed

Questions about Hypothesis Gen

What does Hypothesis Gen do?

A skill your agent uses when the user wants to generate and literature-vet a pool of novel, testable research hypotheses for a question or domain. Hypothesis Gen is an agent skill from gaasher/Agent-Loop-Skills. Use when the user wants to generate and literature-vet a pool of novel, testable research hypotheses for a question or domain.

When should I use Hypothesis Gen?

Hypothesis Gen fits situations like: the user wants to generate and literature-vet a pool of novel; testable research hypotheses for a question.

How do I install Hypothesis Gen in Claude Code?

Run `npx skills add gaasher/Agent-Loop-Skills --skill hypothesis-gen -a claude-code`. Or copy the skill folder (loops/hypothesis-gen in gaasher/Agent-Loop-Skills) into .claude/skills/hypothesis-gen in your project. Claude Code loads it when a task matches its description.

How do I install Hypothesis Gen in Codex?

Run `npx skills add gaasher/Agent-Loop-Skills --skill hypothesis-gen -a codex`. Or copy the skill folder (loops/hypothesis-gen in gaasher/Agent-Loop-Skills) into .agents/skills/hypothesis-gen in your project. Codex loads it when a task matches its description.

Can I use Hypothesis Gen in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add gaasher/Agent-Loop-Skills --skill hypothesis-gen -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/hypothesis-gen, .gemini/skills/hypothesis-gen, .github/skills/hypothesis-gen and .opencode/skills/hypothesis-gen in your project.

What does Hypothesis Gen need to run?

Going by SKILL.md and its folder, Hypothesis Gen needs credentials named S2_API_KEY. Our summary lists: Python 3; A credential in S2_API_KEY. Compatibility (from SKILL.md): Requires Python 3.9+.

Does Hypothesis Gen access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Hypothesis Gen safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Hypothesis Gen use?

Hypothesis Gen is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Hypothesis Gen use?

About 2.6k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Hypothesis Gen?

Skills that share tags, products or a category with Hypothesis Gen: Idea Discovery Pipeline (GRIND-Lab-Core/night_owl_research_agent, 106 stars), Paper Navigator (EvoScientist/EvoSkills, 475 stars), Novelty Check (AI4Scientist/nano-scientist, 128 stars) and Ccf Idea Optimizer (mikubaka88/CCFA-Skills, 3k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Hypothesis Gen?

gaasher (a GitHub user) maintains it in gaasher/Agent-Loop-Skills, which has 174 GitHub stars. The repository holds 21 skills in this directory. The repository was last updated on June 30, 2026.

Source: gaasher/Agent-Loop-Skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.