irp-agents

English · 简体中文 · 日本語 · 한국어 · Español · Italiano

IRP: Build any paper. Prove every claim.

One MCP server and CLI that lets your coding agent turn a research paper into working code, run it, and prove claim by claim how close it gets.

Give it a paper. Get back working code and a report you can check without trusting the agent.

Quick start · How IRP works · The report · What you can reproduce · FAQ · Documentation

uvx irp-agents setup

[!IMPORTANT] Get IRP from Noshadi-sec/irp or the irp-agents package on PyPI. Follow the installation and release links from these official sources. A similar repository name or copied README does not establish that a download is official.

Found a paper with no code, or code you cannot trust? Ask your agent to build it with IRP. The agent reads the paper, records every number it claims, writes the implementation, runs it and compares the results. IRP does the fetching, running and record keeping, and refuses the shortcuts: a number typed by hand never counts, a shortened run never counts, and the report is written only from the evidence log.

IRP connects your agent (Claude Code, Codex or Cursor) to tools for paper intake, environments, runs, measurements and verdicts. You can use the same tools from your terminal. Everything runs locally; IRP never calls a model, and data goes only where you send it.

Quick start

Set up your agent

With uv installed, run:

uvx irp-agents setup

Choose your agents, review the proposed changes, and approve them. Setup adds IRP's MCP server and its workflow skill, with backups of existing configuration. Restart your agent afterward.

Setup supports Claude Code, Codex and Cursor. Other MCP clients can use manual registration.

Ask your agent

Build arXiv 2501.12345 and check Table 2.

You get back a working code folder plus a report: every claim, the paper's number, your number, and a verdict.

Use the terminal

Every tool is also a command. Fetch a paper into a new study and read its outline:

irp fetch 2501.12345 --study ~/studies/example
irp section index --study ~/studies/example

To install the irp command for regular use:

uv tool install irp-agents
irp --help

See the CLI guide for the full workflow from the terminal.

Check readiness

irp doctor

Doctor checks Python, uv, git, Docker, GPUs, disk space and your agents' registrations, and changes nothing.

Update IRP

IRP changes quickly. For an installed command:

irp update

With uvx, refresh your agent setup with uvx irp-agents@latest setup, review the plan, and restart your agent.

How IRP works

Your agent thinks; IRP acts and keeps the receipts. The agent reads the paper, writes code and decides what to run. Every action goes through one core, so the CLI and the MCP server behave the same, and every step lands in an append-only, hash-chained evidence log. The report is built from that log alone.

Stage	Tool	What it does
Intake	fetch_paper	Downloads the arXiv LaTeX source or the PDF, hashes it, splits it into sections
Intake	get_section, get_page_image	Returns one section's text with file and line numbers, or one page as an image for equations and figures
Claims	add_claim, list_claims	Records each claim: metric, value, where it appears, and the success bar
Plan	add_guess	Records a missing detail, the choice made, and why
Plan	map_method	Links an equation or algorithm step to a file and line
Build	create_env	Makes a uv environment or Docker image and writes the lock file
Run	run, run_status	Runs one command; saves output, exit code, time, memory, seed, commit and files
Run	run_remote	Same on a paid GPU provider, after a cost estimate and approval
Measure	extract_metrics	Pulls numbers from logs and result files, with file and line
Judge	compare, add_note	Puts claim and measurement side by side and gives one of four verdicts
Report	report, verify, study_status	Writes report.md and report.json from the log; rechecks the hash chain

The workflow skill gives the agent six hard rules, and the tools enforce them wherever they can:

• Never type, estimate or copy a number as a result.
• Never change the paper's method to make a run succeed; record a guess instead.
• Report "could not run" with the blocking error instead of pushing through.
• Run the smallest faithful version first; shortened runs never count.
• Record every claim before writing any code.
• Ask before any paid compute.

The report

The report is the product: a person must be able to check every verdict without trusting the agent. It has five parts: the claim table, four verdicts (reproduced, close, not reproduced, could not run), the guess list, the method map from equations to code lines, and provenance (arXiv ID and version, file hashes, git commit, lock files, GPU, seeds, every command with its exit code, and a verify command that rechecks the hash chain).

The agent cannot finish until every claim has a verdict with evidence.

Example report.md (made-up numbers):

# Reproduction report: Example Paper (arXiv 2501.12345v2)

Result: 2 reproduced, 1 close, 1 could not run (of 4 claims)

| Claim | Where | Paper | Ours | Verdict |
| --- | --- | --- | --- | --- |
| c1 Test accuracy | Table 2, row 3 | 94.1% | 93.8% (3 seeds, std 0.2) | close |
| c2 Training loss | Figure 4 | 0.31 | 0.31 (3 seeds) | reproduced |
| c3 Speed-up | Section 5.2 | 2.0x | 2.1x | reproduced |
| c4 ImageNet top-1 | Table 3 | 81.2% | not run: needs 8 GPUs for 2 days | could not run |

## Guesses
- g1 Warmup length not stated: used 5 epochs. Why: as in cited paper [12].

## Method map
- Eq. 3 (loss) -> code/src/loss.py:41
- Algorithm 1, line 4 -> code/src/train.py:88

## Provenance
- Paper: arXiv 2501.12345v2, source and PDF hashes
- Code: git commit 3f2a9c1 (clean)
- Commands logged: 37, 37 with an exit code
- Evidence log: 112 records, head sha256:…, verified
- Verify: `irp verify --study ~/studies/example`

See evidence and report for every field.

What you can reproduce

IRP requires Python 3.11+ on macOS or Linux. Additional tools depend on the paper:

Need	What IRP uses	Requirements and guide
Paper intake	arXiv LaTeX source first, the PDF as fallback, page images for math and figures	Network access to arXiv; paper intake
Better PDF structure	Docling for text and tables	Optional irp-agents[docling]; paper intake
Environments	uv virtual environments with lock files, or Docker images for isolation	uv, or Docker; environments
Compute	Your CPU or GPU; Modal GPU sandboxes after a cost estimate and approval (experimental)	Optional irp-agents[modal]; compute
Agents	Claude Code, Codex, Cursor; any MCP client by hand	installation

IRP supports computational papers: machine learning, algorithms and simulations. It does not support wet-lab work or anything weapons-related.

Showcases

Example reproductions — a paper built end to end with the evidence to check it — will be published here.

If you build a paper with IRP, share the report in an issue with the paper, your question, and what you found.

FAQ

Which agents can use IRP?

Any agent that supports local MCP servers. Setup configures Claude Code, Codex and Cursor; other clients can use manual registration.

Does IRP call an AI model or upload my paper?

No. Your agent is the brain; IRP never calls a model and has no API key. It downloads papers from arXiv, installs packages through uv or Docker, and runs code on your machine. Your agent receives the tool results, and its model provider has its own data policy.

Is running a paper's code safe?

Running code is running code. A uv virtual environment is not a sandbox: the code runs with your permissions. Use create_env with backend: "docker" for code you did not write or do not trust, and runs mount only the study's code directory. See security.

What does "not reproduced" mean?

That this run, with the recorded guesses, did not reach the paper's number within the stated bar. The report says "not reproduced by this run" and lists every guess. It is evidence about one attempt, not a verdict on the paper; contact the authors before publishing it.

The paper has official code. Should I use IRP?

IRP builds missing code from the paper. To check that existing code reproduces its README's numbers, a tool such as paper-repro fits better. IRP is still useful for testing a paper by hiding its code and comparing your rebuild with it afterwards.

Can IRP spend money?

Only on paid GPU providers, only after you record a price and a budget at a terminal with irp budget, and only after you approve the estimate the agent shows you. The run's time limit equals the estimated hours.

What should I do if I hit a bug?

Update first; a recent release may already fix it (irp update, or uvx irp-agents@latest setup). If the problem persists, open an issue with your IRP version, the irp doctor --json output, the steps to reproduce and the error.

Documentation

• Installation and setup: agent registration, updates and uninstall.
• CLI: every command, output and exit status.
• MCP contracts and agent prompts: tool results, errors and the generated tool catalog.
• Evidence and report: the log, the gate, verification.
• Paper intake, environments and compute.
• Benchmarks: how IRP is measured.
• Roadmap: v0.1 to v1.0 and the gates between them.

Report vulnerabilities through SECURITY.md.

Disclaimer

See DISCLAIMER.md for responsible-use guidance. IRP is for lawful research, education and the verification of published computational work. A "not reproduced" verdict is evidence about one run, not a judgment of the paper or its authors.

Contributing

Contributions are welcome. Open an issue to report a bug or suggest a feature, or send a pull request.

See CONTRIBUTING.md for development setup and checks, testing for verification lanes, and the architecture map for the project structure.

License

MIT

IRP-authored code is licensed under MIT. Third-party material retains its own licenses and notices; see Third-party notices. Papers and datasets keep their authors' licenses; IRP never redistributes them.