# IRP (pypi · irp-agents)

Turn a research paper into working code and prove, claim by claim, how close it gets.

- Trust score: 0/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-23

> **Recent critical change**: CVE-2026-96639 affects this package (2026-10-23). See the changelog below before you install this server.

## Components

- pypi · `irp-agents`: 0/100 (this document), [markdown](https://verifymcp.io/servers/noshadi-sec-irp/irp-agents.md), [page](https://verifymcp.io/servers/noshadi-sec-irp/irp-agents)

## Channel facts

- Registry: `pypi`
- Package: `irp-agents`
- Version: `0.6.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-23.

- **Supply Chain Security**: 25/100
  - Malware scan not yet available for this package.
  - CVE check failed: an unpatched critical CVE affects this package; the score is capped at 0.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 4 of 43 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to Noshadi-sec/irp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 1 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 76/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3397 tokens (~199/item across 17 items; 17 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 7/100
  - Stability observed for 2 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 17 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 18 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the IRP MCP server?

IRP runs locally as a PyPI package, launched with uvx irp-agents. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add noshadi-sec-irp -- uvx irp-agents
```

### Cursor

```json
{
  "mcpServers": {
    "noshadi-sec-irp": {
      "command": "uvx",
      "args": [
        "irp-agents"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "noshadi-sec-irp": {
      "command": "uvx",
      "args": [
        "irp-agents"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add noshadi-sec-irp -- uvx irp-agents
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "noshadi-sec-irp": {
      "type": "local",
      "command": [
        "uvx",
        "irp-agents"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add noshadi-sec-irp --command uvx --arg irp-agents
```

### Hermes

```yaml
mcp_servers:
  noshadi-sec-irp:
    command: "uvx"
    args: ["irp-agents"]
```

### Netclaw

```json
{
  "McpServers": {
    "noshadi-sec-irp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "irp-agents"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add noshadi-sec-irp -t stdio -c uvx -a irp-agents
```

### Other

```json
{
  "mcpServers": {
    "noshadi-sec-irp": {
      "command": "uvx",
      "args": [
        "irp-agents"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-23 (score 0, 0)

- [critical regression] CVE-2026-96639 affects this package: high

### 2026-10-22 (score 0, 0)

- [security regression] Malware scan: pass → unverified

### 2026-10-21 (score 0)

First indexed and scored.

## MCP tools (17)

### `fetch_paper` (~245 tokens)

Fetch paper

Create the study directory and fetch the paper into it: arXiv LaTeX source first (exact equations), the PDF as fallback and for page images. Records arXiv ID and version, file hashes and an outline of sections, tables, figures, equations and algorithms. Call this first; a study holds one paper.

Input parameters:

- `paper` (string, required): arXiv ID or URL (e.g. '2501.12345' or '2501.12345v2'), a direct PDF URL, or a local path to a PDF, a LaTeX source directory, or a .tar.gz/.zip source archive.
- `parser` (string): PDF text parser when no LaTeX is used. 'auto' uses Docling when installed, else pypdf.
- `prefer` (string): Read LaTeX source when it exists (exact equations), else the PDF.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.
- `with_pdf` (boolean): Also download the PDF so get_page_image can show figures, tables and equations.

### `get_section` (~227 tokens)

Read a section

Read part of the paper with its original file and line numbers: a section, a table, figure, equation or algorithm, a LaTeX label, the abstract, a PDF page, a line range, or 'index' for the full outline. Use the shown file:line when recording claims and method map entries.

Input parameters:

- `id` (string, required): What to read: a section id ('sec:3', 'sec:3.2'), an item id ('tab:2', 'fig:1', 'eq:4', 'alg:1'), a LaTeX label ('eq:loss'), a section title, 'abstract', 'index' for the outline, 'page:5' for one PDF…
- `max_lines` (integer): Return at most this many lines.
- `offset` (integer): Skip this many lines of the selection (paging).
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.

### `get_page_image` (~99 tokens)

Look at a page

Render one page of the paper PDF as a PNG image, for equations, figures and tables that text extraction loses. Saved under paper/pages/.

Input parameters:

- `dpi` (integer): Rendering resolution; raise it for small math.
- `page` (integer, required): 1-based page number of the paper PDF.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.

### `add_claim` (~440 tokens)

Record a claim

Record one number the paper claims, before writing any code (rule 5): the metric, the value as printed, where it appears and the success bar. The value is checked against the paper text. Claims recorded after code exists are flagged in the report.

Input parameters:

- `close_abs`: Close if within this absolute difference.
- `close_rel`: Close if within this fraction.
- `comparator` (string): 'approx' for 'about this value', 'at_least' for lower bounds such as speed-ups, 'at_most' for upper bounds such as error rates.
- `metric` (string, required): Metric name, e.g. 'test_accuracy'.
- `notes`: Anything a reader should know about this claim.
- `page`: PDF page where the claim appears, if known.
- `seeds_in_paper`: Runs or seeds the paper averaged over, if stated.
- `source_file`: Paper file of the printed value, as get_section shows it (e.g. 'main.tex' or 'paper.pdf#page=7'). With source_line, the value is checked at that line.
- `source_line`: Line of the printed value in source_file.
- `statement` (string, required): Short name of the claim, e.g. 'Test accuracy on CIFAR-10'.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.
- `tolerance_abs`: Reproduced if within this absolute difference.
- `tolerance_rel`: Reproduced if within this fraction of the paper's value (0.01 = 1%).
- `value` (string, required): The paper's number exactly as printed, e.g. '94.1%', '0.31' or '2.0x'. Only the paper's own number belongs here, never a result.
- `where` (string, required): Where the claim appears, as a reader would say it: 'Table 2, row 3', 'Figure 4', 'Section 5.2'.
- `where_kind` (string): Kind of place the claim appears.

### `list_claims` (~52 tokens)

List claims

List every recorded claim with its success bar and current verdict.

Input parameters:

- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.

### `add_guess` (~172 tokens)

Record a guess

Record a detail the paper left out, the choice made and why (rule 2: never change the method to make a run succeed; record a guess instead). Every guess appears in the report.

Input parameters:

- `choice` (string, required): What was chosen, e.g. '5 epochs'.
- `claims` (array): Claim ids this guess can affect.
- `missing` (string, required): The detail the paper left out, e.g. 'Warmup length not stated'.
- `source`: Where the choice comes from: a citation, a URL or 'common default'.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.
- `why` (string, required): Why, e.g. 'as in cited paper [12]'.

### `map_method` (~211 tokens)

Map method to code

Link an equation or algorithm step in the paper to the file and line in code/ that implements it. The file's hash is recorded so the report flags mappings whose code changed later.

Input parameters:

- `code_file` (string, required): File inside the study's code/ directory, e.g. 'src/loss.py'.
- `code_line` (integer, required): First line that implements the element.
- `end_line`: Last line, when the implementation spans several.
- `note`: Why this line implements the element, if not obvious.
- `paper_element` (string, required): The paper element, e.g. 'Eq. 3 (loss)' or 'Algorithm 1, line 4'.
- `paper_ref`: Index id or LaTeX label of that element, e.g. 'eq:3' or 'eq:loss'; checked against the paper.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.

### `create_env` (~231 tokens)

Create environment

Build a pinned environment for the study's code: a uv virtual environment (fast, not a sandbox) or a Docker image (isolated). Writes the lock file and records its hash. Requires recorded claims (rule 5).

Input parameters:

- `backend` (string): 'uv' builds a virtual environment (not a sandbox); 'docker' builds an image runs are isolated in.
- `base_image`: Docker base image; default python:<python>-slim.
- `gpu` (boolean): Docker runs request all GPUs (--gpus all).
- `name` (string): Environment name; never reused.
- `packages` (array): Extra packages, e.g. ['numpy==2.1.0'].
- `python` (string): Python version, e.g. '3.11'.
- `requirements`: Requirements file inside code/. Defaults to code/requirements.txt when it exists.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.
- `system_packages` (array): Debian packages for the Docker image.

### `run` (~333 tokens)

Run a command

Run one command in code/ with the named environment. Saves stdout and stderr, exit code, time, peak memory, seed, the code commit and the hash of every file the run writes. Only scope 'full' can count toward a verdict (rule 4). Use wait=false and run_status for long runs.

Input parameters:

- `command` (string, required): Shell command to run inside the environment, e.g. 'python train.py --epochs 30'.
- `commit` (boolean): Commit code/ to git before the run so the report names the exact code.
- `cwd` (string): Working directory inside code/.
- `env`: Environment from create_env; null uses the host environment (no lock file).
- `memory_limit`: Docker only: memory cap such as '8g'.
- `network` (boolean): Docker only: allow network access during the run.
- `note`: What this run is for, shown in the report.
- `scope` (string): 'full' is the faithful configuration and is the only scope that can count; 'shortened' (fewer steps or data) and 'smoke' never count.
- `seed`: Seed, passed as IRP_SEED and PYTHONHASHSEED and recorded.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.
- `timeout_s` (integer): Stop the run after this many seconds.
- `wait` (boolean): Wait for the run to finish. For runs longer than your client's tool timeout, pass false and poll run_status.

### `run_status` (~113 tokens)

Run status

Report a run's status, exit code and the last lines of its output; optionally wait for it to finish.

Input parameters:

- `run_id` (string, required): Run id, e.g. 'r3'.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.
- `tail_lines` (integer): Lines of stdout and stderr to return.
- `wait_s` (integer): Wait up to this many seconds for the run to finish.

### `run_remote` (~305 tokens)

Run on a GPU cloud

Run one command on a paid GPU provider (Modal today; RunPod and Hugging Face Jobs planned). Returns a cost estimate and refuses until the person approves it (rule 6) and the estimate fits the budget a person set with `irp budget`. The time limit equals the estimated hours.

Input parameters:

- `approved` (boolean): Set true only after showing the person the cost estimate and receiving their approval.
- `command` (string, required): Shell command to run in the remote sandbox.
- `env` (string): Environment whose requirements and Python version the sandbox uses.
- `gpu` (string, required): GPU type, e.g. 'A10G', 'A100', 'H100'.
- `gpu_count` (integer): Number of GPUs; multiplies the estimate.
- `hours` (number, required): Time limit in hours; also the basis of the cost estimate.
- `note`: What this run is for, shown in the report.
- `outputs` (array): Files under code/ to copy back after the run.
- `provider` (string): Compute provider.
- `scope` (string): 'full' is the only scope that can count; see run.
- `seed`: Seed, passed as IRP_SEED and recorded.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.
- `wait` (boolean): Wait for completion; remote runs usually outlast tool timeouts.

### `extract_metrics` (~121 tokens)

Extract metrics

Pull numbers from a completed run's stdout, stderr or the files it wrote, by key, regex, JSON pointer or CSV column. Each measurement keeps its file, line and file hash. Numbers from any other source are refused (rule 1).

Input parameters:

- `run_id` (string, required): Completed run to read, e.g. 'r3'.
- `specs` (array, required): One spec per number to extract.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.

### `compare` (~285 tokens)

Compare and judge

Put a claim beside its measurements and record one of four verdicts: reproduced, close, not reproduced, or could not run. Measurements must come from full-scope runs that exited 0; 'could not run' needs the blocking error (rule 3).

Input parameters:

- `blocking_error`: Could not run: the exact blocking error or constraint.
- `claim_id` (string, required): Claim to judge, e.g. 'c1'.
- `context_measurement_ids` (array): Measurements shown for context that do not count, e.g. from a shortened run.
- `could_not_run` (boolean): Record 'could not run' instead of a measured verdict.
- `failed_run_id`: Could not run: the run that failed, if any.
- `measurement_ids` (array): Measurements from extract_metrics, one per seed or run; their mean is compared.
- `note`: Context for the verdict, shown in the report.
- `reason`: Could not run: short reason, e.g. 'needs 8 GPUs for 2 days'.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.
- `unit_scale` (number): Power of ten to convert units, e.g. 100 when the log prints 0.938 and the paper 93.8%.

### `add_note` (~110 tokens)

Record a note

Record a limitation, a forced deviation from the paper, something not checked, or an author contact.

Input parameters:

- `claims` (array): Claim ids the note concerns.
- `kind` (string, required): limitation, deviation (a forced change from the paper), not_checked, author_contact or other.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.
- `text` (string, required): The note itself, in plain words.

### `report` (~137 tokens)

Write the report

Write report.md and report.json from the evidence log only: claim table, verdicts, guesses, method map and provenance. Refuses until every claim has a verdict with evidence (the completion gate) unless draft=true.

Input parameters:

- `bundle`: Absolute path of a new directory to receive a shareable bundle (report, evidence, code, locks, logs; never the paper PDF or source).
- `draft` (boolean): Write report.draft.md/json even if the completion gate has not passed.
- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.

### `verify` (~58 tokens)

Verify the evidence

Recheck the evidence log's hash chain and the hash of every recorded file; reports each problem.

Input parameters:

- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.

### `study_status` (~73 tokens)

Study status

Show the study at a glance: paper, claims and verdicts, guesses, environments, runs, and what still blocks a final report. Use it to resume work.

Input parameters:

- `study` (string, required): Absolute path of the study directory. fetch_paper creates it; every other tool reads and appends to its evidence log.

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/noshadi-sec-irp/irp-agents#diagnostics

## Score history

- 2026-10-23: 0
- 2026-10-22: 0
- 2026-10-21: 0

## Common questions

### What is the IRP MCP server?

IRP is an MCP server listed in the public MCP registry as io.github.Noshadi-sec/irp. Turn a research paper into working code and prove, claim by claim, how close it gets. This page covers its PyPI package (irp-agents).

### What tools does the IRP MCP server expose?

IRP exposes 17 tools: fetch_paper, get_section, get_page_image, add_claim, list_claims, and 12 more. Their descriptions and schemas cost roughly 3,212 tokens of context every time the server is loaded.

### Is the IRP MCP server still maintained?

IRP is still listed as active in the MCP registry. We last reached this channel on 23 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the IRP MCP server under?

IRP declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/irp-agents/
- Socket report: https://socket.dev/pypi/package/irp-agents
- Repository: https://github.com/Noshadi-sec/irp
- Changelog RSS feed: https://verifymcp.io/servers/noshadi-sec-irp/irp-agents.xml
- Changelog JSON feed: https://verifymcp.io/servers/noshadi-sec-irp/irp-agents.json
- HTML version of this page: https://verifymcp.io/servers/noshadi-sec-irp/irp-agents