The Radar tells you what is worth replicating. This page is the how: the end-to-end loop that turns a target into an independent, signed, citable replication — and how a research software engineer can run it with an AI agent using the open replication-radar MCP together with the FORRT replication template.
The replication loop
Five steps. Each replication you publish becomes a public, author-attributed nanopublication — and shows back up here as an independently-checked result, so the next person sees it.
-
Find a target Radar
Search a topic and pick a high-priority paper that is still OPEN (not yet checked). The priority score and the claim tell you what would be worth re-testing.
-
Scaffold with the FORRT replication template template
Start from the FORRT replication template. It scaffolds the repository and the signed nanopublication chain — Claim · Study · Outcome — so your work is structured and verifiable from the start.
-
Run the replication you
Re-test the same claim with different data or methods (replication, not just re-running the original code). Record your materials, code and — where relevant — the geographic coverage, following the good-practice checks the Radar looks for.
-
Publish the signed chain Science Live
Publish the nanopublication chain to the Science Live network. It is cryptographically signed, attributed to you, and citable — your replication counts as a first-class research output.
-
It reappears on the Radar Radar
Because verdicts are read live from the network, your replication now surfaces here as independently checked, with its verdict — and its code gets a FAIR-software score plus the RSE good-practice signals. The gap you filled is visible to everyone.
Do it with an AI agent — the MCP
The same engine behind this site is an MCP server, so an agent (Claude Desktop, Claude Code, or any MCP client) can discover targets and check verdicts for you — the first half of the loop, hands-free. It uses only public, grounded sources; no keys.
# install the open-source MCP server
pip install replication-radar
Then register it with your MCP client. For Claude Desktop, add to claude_desktop_config.json:
{
"mcpServers": {
"replication-radar": { "command": "replication-radar" }
}
}
It exposes four tools, all grounded in the OpenAIRE Graph and the nanopublication network:
radar(topic)Impact-ranked replication targets for a research topic — the ranked queue you see here.
replication_status(doi)Whether a specific paper has been independently replicated, and with what verdict.
find_independent_software(topic / doi)Independent software implementations related to a paper or topic.
verified_claims()The set of claims that have been independently checked on the network.
Example prompts once it's connected:
- "What high-impact work on species distribution models is worth replicating and hasn't been checked yet?"
- "Has 10.xxxx/... been independently replicated? What was the verdict?"
- "Find independent software implementations I could reuse for this replication."
The agent handles discovery and status; the actual replication and signing stay with you and the FORRT template — which is itself agent-ready (it ships an .mcp.json and agent instructions), so you can drive the second half of the loop with an agent too.
For research software engineers
Replication is software work. For every replication with a repository, the Radar assesses — live from GitHub, Software Heritage and Zenodo — both the recognised FAIR-software recommendations and a set of RSE good-practice signals:
FAIR software (public repository · open licence · in a registry · citable · quality artefacts), and — separately — documented · tests · CI · contributing · code of conduct, with the repository's own CI status as a grounded reproducibility signal. Each check links to the actual artefact so you can inspect it, and every check is explained with links to go deeper (The Turing Way, goodpractice, NumFOCUS, Imperial's Essential Software Engineering course) on the methodology page.
These are signals, not grades — presence read from the repository, never guessed. The aim is to make the software behind a replication as visible and reusable as the result itself.