Ultra Ml Intern

ultra-ml-intern: paper-grounded ML research for Claude Code

Crawls citation graphs, reads whole papers in parallel subagents, mechanically verifies every quote in the report, and archives a model's real code locally — so Claude answers from published sources instead of training-time recall.

License: MIT Claude Code Built on

Ask Claude "what's the best recipe for X" and you get a confident answer assembled from memory: plausible hyperparameters, a dataset that may not exist, a TRL API that changed two releases ago. This plugin replaces that with two disciplines:

• Read the literature. Find the anchor paper, crawl its citation graph in both directions, read methodology sections, and report every number with the paper and section it came from.
• Read the source. For a named model, find and verify its canonical repo over forks and lookalikes, clone it, and keep the real training and inference code on disk as a permanent reference.

Works in any Claude Code surface: terminal CLI, IDE extensions, and the web app.

Install

# In any Claude Code session:
/plugin marketplace add infiniV/ultra-ml-intern
/plugin install ml-intern@ultra-ml-intern

Restart Claude Code, then verify with /plugin and /agents.

What you get:

• 4 skills: ml-intern (literature research), model-provenance (archive a model's real code + papers locally), grounding (spend that archive in every later session), open-problem (attack a hard unsolved problem in any field)
• 2 slash commands: /ml-research, /ml-research-ultra
• 2 subagents: ml-paper-researcher, ml-paper-reader
• 1 MCP server: Hugging Face (activates when HF_TOKEN is set)

The plugin is named ml-intern for install compatibility; it does research and provenance only. It does not audit datasets, write training scripts, or submit jobs.

Two research depths

	/ml-research	/ml-research-ultra
Shape	one ml-paper-researcher subagent	you orchestrate 4 stages
Discovery	2 lanes (high-cite + recency)	6–10 query angles × 2 lanes
Graph	anchor's citers	2-hop BFS, both directions
Papers read	~5	15–30, in parallel ml-paper-reader waves
Output	≤800-word recipe report	citation-rich report with cross-paper synthesis
Cost	minutes	10–30× the wall-clock
Use when	"give me a recipe so I can start"	survey a field, find a gap, or standard came back shallow

Both write to a file and return a 5–10 line summary to chat. Neither dumps the report inline.

> /ml-research GRPO for math reasoning on small models
> /ml-research-ultra sparse attention for long-context training

How ultra works

Discovery   6–10 angles × 2 lanes      high-cite ∥ recency
            merge + overlap-count      → 15–25 seeds
            citation BFS, 2 hops       --cited-by ∥ --refs, waves of 10
Selection   rank on crawl evidence     overlap, influence, age-discounted
            confirm with user          cites, Hub artifacts → 15–30
Reading     1 subagent per paper       waves of 5–10; each fetches the paper
            paper text stays on disk   to ./papers/ and reads it there
            stop on saturation         when a wave adds nothing new
Synthesis   method × dataset × result  consensus, disagreements, gaps,
                                       open problems, artifact health
Verify      verify_quotes.py           greps every quote against ./papers/
Write       ./ml-research-ultra-<slug>.md

Two things make the output trustworthy rather than merely fluent.

Papers are read, not summarized. paper_text.py writes a paper's real text to disk — native arXiv HTML, else the ar5iv mirror, else the PDF — and the reader subagent reads it there. Fetch-and-summarize tools return a paraphrase, which makes "verbatim quote" and "§4.2" unverifiable by construction; benchmarks of LLM paper-reading find section-specific extraction failing most of the time under exactly that setup.

Quotes are checked mechanically. verify_quotes.py greps every quotation in the finished report against the papers on disk and exits non-zero on any miss. A paraphrase inside quotation marks fails, and so does anything invented. This replaces asking a model to re-read its own writing and judge whether it looks right — the weakest available check, and the one a confident fabrication passes most easily.

Two judgment rules bind the synthesis. SOTA is a timestamped claim — citation counts structurally favor stale work, so consensus is stated as the recipe no later paper in the read set beats, with its as-of date. Cross-paper absolute numbers are only approximately comparable — different harnesses and decoding, so ranking goes by within-paper deltas over a shared baseline.

Report length follows the evidence. A section that must be filled gets filled, and what fills it is invention — so "no contradictions surfaced in the read set" is a valid finding, and a run that converges on one clear recipe produces a short report.

Skills

Skill	What it does
ml-intern	Literature research. Finds the landmark paper for a task, crawls the citation graph for recent SOTA, reads methodology sections, extracts the recipe (dataset, method, hyperparameters, hardware, reported metric) with every claim attributed to a paper and section, and verifies the named datasets and models actually exist on the Hub. Activates on "literature review for X", "best recipe for X", "what's SOTA for X", "find a gap in X".
model-provenance	Given a specific model (DINOv3, SAM 2, Whisper, Qwen2-VL…), finds and verifies the canonical repo over forks and lookalikes, clones it, extracts the real train/model/inference files, downloads the paper PDFs with metadata, captures each official checkpoint's usage contract from the Hub (config, preprocessor/tokenizer + chat template, model card, revision sha, license/gated status — metadata, never weights), writes a synthesis report with a variant table and I/O contract, and archives everything to a global, project-independent ~/.claude/model-provenance/<slug>/ (reusing any existing archive instead of re-fetching). Registers a mandatory-read memory so future coding against that model is grounded in its actual source, not training-time recall. Cloned code is archived, never executed.
open-problem	Sustained multi-agent attack on a hard unsolved problem in any field — maths, physics, biology, ML. Built from the August 2026 run in which Claude raised the Riemann critical-line lower bound from 41.6% to 67.2% with a Lean proof. Learns the problem from primary sources including what's already been ruled out, hunts for the two literatures nobody has combined (that join, not a new technique, is where machine novelty comes from), fans out across dozens of parallel lines expecting most to die, attacks whatever survives with numerical checks, counterexample search, adversarial review and formalization, then states exactly what was proven. No ceiling on the attack, no inflation in the claim. Falsifier required before a hypothesis is registered; artifact required before a verdict.
grounding	Spends that archive. Before writing, reviewing, or debugging code that uses a harvested model, it resolves the archive, reads notes.md and only the cited files the task needs, and then mechanically checks what it wrote: every Hub checkpoint id and model-specific symbol must appear in the archived source, or the check fails. Catches the checkpoint id that looks right and 404s, and the class name borrowed from a neighbouring model. When no archive exists it says so instead of quietly answering from memory.

Harvest once, ground every session after

model-provenance          grounding
──────────────────        ─────────────────────────────────────
"harvest DINOv3"          "load DINOv3 and extract patch features"
        │                             │
        ▼                             ▼
  clone + verify              load_archive.py DINOv3
  extract key_code                    │  resolves the slug, maps the archive
  fetch papers                        ▼
  capture hub metadata        read notes.md → the 1–2 files it cites
  write notes.md                      │  variant table, I/O contract, gotchas
  register memory  ─────┐             ▼
        │               │       write the code
        ▼               │             │
~/.claude/model-        │             ▼
provenance/<slug>/  ◄───┴──── check_grounding.py --model DINOv3 embed.py
   (write-once)         reads         │  every checkpoint id + symbol
                        only          ▼  must exist in the archive
                                UNGROUNDED → fix it, don't ship it

The archive is written once at harvest and never polluted with per-experiment notes — grounding only ever reads it:

~/.claude/model-provenance/<slug>/
├── code/       full git clones, canonical repo first
├── key_code/   extracted train loop, model def, inference + MANIFEST.md
├── papers/     <slug>.pdf + metadata (title/authors/abstract/bibtex)
├── hub/        per-checkpoint config, tokenizer, chat template, card, sha
├── SOURCES.md  every repo/paper/checkpoint with commit pin and why it's canonical
└── notes.md    architecture, recipe, I/O contract, variants, how to run

> "harvest DINOv3"                          # model-provenance
> "load DINOv3 and extract patch features"  # grounding, in any later session

Subagents

Subagent	Role
ml-paper-researcher	Crawls arXiv + the anchor paper's citers, extracts the methodology into a recipe. Returns a ≤800-word report; keeps paper text out of the main thread
ml-paper-reader	Single-paper deep reader. Fetches the paper to disk and reads it there, so every quote is text it copied and every §ref is a heading it saw. Built for parallel fan-out from /ml-research-ultra

Helper scripts

All under skills/ml-intern/scripts/ — bash + curl against the arXiv, Semantic Scholar, and Hugging Face Papers APIs, plus two stdlib Python scripts. No API key needed for basic use; set S2_API_KEY (free at semanticscholar.org/api) for higher rate limits and full-text search.

Script	Purpose
crawl_arxiv.sh "query"	Search HF Papers / S2, with --min-cites, --date-from, --sort
crawl_arxiv.sh --cited-by|--refs <id>	Citation graph in both directions, with influence flags
crawl_arxiv.sh --info <id>	Metadata + S2 tldr
paper_text.py <id> --sections	A paper's full text to disk as sectioned plaintext, plus its heading outline. arXiv HTML → ar5iv → PDF
verify_quotes.py <report>.md	Greps every quotation in a report against the fetched papers; non-zero exit on any miss
recommend_papers.sh <id>	Related papers when the graph is sparse
merge_papers.sh	Dedupe + overlap-count JSONL across query angles
hf_paper_meta.sh <id> --all	Hub models/datasets/collections linked to a paper
snippet_search.sh "<claim>"	Full-text passage search across 12M+ papers, for claim verification
inspect_dataset.sh <org/name>	Confirm a paper's dataset exists on Hub and check its columns
research_slug.sh "<topic>"	Injection-safe filename slug from user input
download_paper.sh <id>	Local PDF/HTML archive of a read list

The grounding skill adds two under skills/grounding/scripts/:

Script	Purpose
load_archive.py <model>	Resolve a model name to its archive and map what's in it — notes outline, captured checkpoint ids, what's missing. --list shows every archive
check_grounding.py --model <m> <files>	Verify every Hub checkpoint id and model-specific symbol in your code appears in the archive; non-zero exit on any miss

Anti-hallucination rules

The plugin's whole value is that the report is checkable:

1. Papers are read from their real text on disk, never from a summarizer's paraphrase
2. Every quotation is grepped back against that text by verify_quotes.py, which fails the run on a miss — a paraphrase in quotation marks does not survive
3. Never invent an arXiv ID — every ID traces to a crawl result or a digest
4. not stated in paper is a finding, not a gap to fill with a plausible value
5. Contradictions between a claim and a paper's own limitations get surfaced, not resolved by picking a side
6. Unreadable papers are reported as unreadable — a read list of 40 with 12 failures is a 28-paper report, and the report says so
7. No silent resource substitution — if a dataset or repo a paper names is gone, that gets said

Requirements

• Claude Code (any surface: terminal, IDE, web)
• Your own Claude access (Max subscription or API key)
• Bash + standard Unix tools; Python 3 (standard library only); git for model-provenance
• Optional: pdftotext (poppler) — the last-resort fallback when a paper has neither arXiv HTML nor an ar5iv render
• Optional: S2_API_KEY for higher Semantic Scholar limits and snippet_search.sh
• Optional: HF_TOKEN for the bundled MCP server

export HF_TOKEN="$(hf auth print-token)"  # or paste from https://huggingface.co/settings/tokens

The MCP server adds Hub doc semantic search and community Gradio Space tools. The plugin works without it, falling back to WebFetch plus the bundled helpers above.

Heritage

The paper-crawling procedure comes from huggingface/ml-intern, HF's standalone Python harness around the Claude API — skills/ml-intern/references/paper-crawl.md reimplements its papers_tool.py operations (citation graph, snippet search, recommend, find datasets/models/collections) with nothing but curl and the public APIs.

Where this diverges: upstream's research tool pushes full paper text into the calling agent's context, which caps how deeply it can read before running out of budget. /ml-research-ultra inverts that with per-paper subagent isolation, and spends the reclaimed context on cross-paper synthesis instead. The upstream also ships the training half of the workflow; this plugin deliberately does not.

Uninstall

/plugin uninstall ml-intern@ultra-ml-intern
/plugin marketplace remove ultra-ml-intern

Contributing

Issues and PRs welcome at https://github.com/infiniV/ultra-ml-intern.

CI runs:

• shellcheck and bash -n on every script in skills/ml-intern/scripts/
• python -m compileall on every bundled Python script
• JSON schema validation on .claude-plugin/plugin.json and .claude-plugin/marketplace.json
• frontmatter presence check on every command, agent, and skill

Credits

• Upstream: huggingface/ml-intern by the Hugging Face team. The paper-tool procedural knowledge is theirs.
• Plugin format reference: obra/superpowers.
• Plugin skeleton mirrors infiniV/claude-code-audio-notify.

License

MIT