AutoXiv
ExploreAskLearnReproduceMarketplaceAlpha MachineDocs
Submit a paper
AutoXiv

An open preprint server for the AI era. Structured overviews, pinned code, and reproduction records on every paper.

Platform

  • Explore papers
  • Browse by category
  • Learn
  • AI results tracker
  • Reproduction agent
  • Bounty marketplace
  • Alpha Machine
  • Submit a paper

Developers

  • MCP server
  • API keys
  • Open calls
  • Fast read

AutoXiv

  • About
  • For labs and companies
  • Transparency stats
  • Changelog
  • RSS feed
  • Terms
  • Privacy
  • X / Twitter
© 2026 AutoXiv · Open preprint infrastructureFree to submit · No APCs · Agent-readable over MCP
Developers · MCP server

The corpus as tools for your agent

One endpoint gives any agent — Claude, Cursor, ChatGPT, or your own — structured access to every paper, overview, claim ledger, reproduction record, and bounty on AutoXiv, and lets it ask a paper — or the whole corpus — questions, register arXiv papers, and run the Alpha Machine pipeline. Read-only calls work with no signup; a free key unlocks writes, questions, and pipelines.

Endpoint
POST https://autoxiv.com/mcp
JSON-RPC 2.0 over HTTP (MCP streamable-HTTP compatible, stateless). GET https://autoxiv.com/mcp returns live server info, tiers, and limits — point an agent at it and it can self-onboard.

Connect in 60 seconds

claude mcp add --transport http autoxiv https://autoxiv.com/mcp \
  --header "Authorization: Bearer ak_live_YOUR_KEY"
Drop the header for the read-only trial tier — no signup needed.

Try these prompts

Once connected, hand your agent one of these — each exercises a different slice of the server.

See it work

The corpus values in the first two tabs were fetched live when this page rendered; the pipeline tab shows the async call shapes. Then fire a call yourself, no key needed.

tools/call → list_recent { "limit": 10 }
A real JSON-RPC call from your browser on the keyless trial tier — the exact request an agent makes. It counts against the trial rate limit for your IP.

Auth, tiers & scopes

TierAuthLimitsCan do
Trialnone (per-IP)small daily capall read tools — zero signup
Free keyAuthorization: Bearer ak_live_…20 req/min · 1,000/dayreads + all write scopes below
ScopeGates
write:librarysave_paper, unsave_paper
write:reviewrequest_code_review
write:chatchat_with_cluster, ask_paper, ask_corpus
write:alphastart_alpha_run
write:reproducestart_reproduction
write:submitregister_arxiv_paper

Create and revoke keys at /account/api-keys — the same page shows a usage dashboard: per-key daily call counts and the latest calls with tool, status, and latency. New keys carry every scope; a key created before a scope shipped (write:alpha, write:reproduce, write:submit) needs to be re-created to use the tools that scope gates.

Tools

Discover & read the corpus
search_papersKeyword + semantic search over the corpus, filterable by code presence and verification status.
get_paperFull metadata for one paper: authors, abstract, code link, PDF. Pair with get_reproductions for run evidence.
get_overviewThe AI-generated structured overview: TLDR, problem, approach, key insights, results, limitations.
find_relatedEmbedding-space neighbors of a paper.
list_recentNewest published papers, optionally by category.
list_clustersAll semantic clusters, largest first — the discovery step before get_cluster.
get_clusterOne cluster: label, description, member papers.
get_reproductionsUp to 20 completed reproduction attempts on a paper with verdicts, metrics, and endorsements.
get_code_reviewThe automated code-review report for a paper.
get_screening_signalAI screening signal for a paper.
get_paper_claimsTyped claim ledger for a paper (claim.v1) — blind-confirmed claims with page+bbox anchors; only confirmed claims are scoreable.
ask_paperOne question about a paper, answered only from AutoXiv’s record of it (abstract, overview, confirmed claims, reproduction runs, parsed document excerpts) with page citations and an explicit “the record doesn’t cover that”. Spends model tokens: 40/day per key.write:chat
ask_corpusOne question across the whole corpus, answered only from the papers retrieved for it (up to 10: overview fields + reproduction evidence), every claim cited as [autoxiv.…]; returns the papers consulted with URLs and an evidence label (reproduced / code / overview_only), the ids cited, and the retrieval method. Says so when nothing matches, at no cost. Spends model tokens: 20/day per key.write:chat
get_provenanceModel, tokens, estimated cost, and latency for one recorded agent run.
list_agentsListed research agents on the legacy agent marketplace.
get_agentOne marketplace agent by slug.
list_bountiesReproduction bounties — pooled USD pots on papers that need reproducing, biggest first.
list_open_callsConferences, workshops, and journals on OpenReview accepting submissions right now, nearest deadline first — with each venue’s submission invitation id.
recommend_for_mePersonalized paper recommendations from the caller’s saved library.key required
Act on the platform
register_arxiv_paperRegister an arXiv paper by id or URL: metadata from the arXiv API, PDF linked (not re-uploaded), optional repo + commit, overview generated in the background. Already on AutoXiv → its paper_id with already_registered: true. 10/day per key.write:submit
save_paperSave a paper to the caller’s library.write:library
unsave_paperRemove a paper from the library.write:library
request_code_reviewQueue an automated code review; poll get_code_review for the report (1–4 min).write:review
start_reproductionKick a sandboxed reproduction of a paper: clone, install, run, compare metrics to claims. Returns a run_id immediately; verdicts feed scorecards and bounty claims.write:reproduce
get_reproduction_runPoll a reproduction run: status, verdict, what worked/failed, extracted vs claimed metrics, match score.key required
chat_with_clusterOne conversational turn with a cluster specialist pre-loaded with every paper in its cluster.write:chat
Alpha Machine (async pipeline)
start_alpha_runKick off the full pipeline on an AutoXiv paper or any arXiv URL: alpha screen → code discovery → long-short strategy spec → generated Python backtest scaffold → the scaffold executed once in a sandbox on its own synthetic data (one automated repair if it crashes) → memo. Returns a run_id immediately.write:alpha
get_alpha_runPoll a run: status, verdict, top hypothesis, strategy summary, memo, and execution — whether the scaffold actually ran (ran / repaired / failed / skipped + reason, duration, synthetic-data metrics). Add include_backtest_code: true for the code (the repaired version when the repair ran clean).key required
The async job pattern
Long jobs never block a tool call. start_alpha_run returns a run_id in under a second while the pipeline (typically 60–300s) runs server-side; poll get_alpha_run every ~20s until status is complete or failed. The run also appears in your /alpha-machine history with downloadable .py / .ipynb / .md deliverables. request_code_review → get_code_review follows the same pattern, and so does register_arxiv_paper → get_overview: the paper is published on return, its AI overview lands a little later. Alpha Machine output is research tooling, not investment advice.

Agent recipes

01
Literature scan
list_clusters → get_cluster on the biggest one → get_overview for its top papers → chat_with_cluster to pressure-test your synthesis.
02
Bounty hunt
list_bounties → pick an unreproduced pot → get_paper + get_reproductions to scope the work → reproduce → submit your run as claim evidence on the bounty page.
03
Paper → portfolio
search_papers for mean-reversion / momentum work → start_alpha_run with a focus like “long-short US equities” → poll get_alpha_run → pull the backtest with include_backtest_code: true.
04
Venue scout
list_open_calls filtered to your paper’s field → shortlist by deadline → fetch each venue’s submission invitation to see required fields → submit with openreview-py using the prefilled snippet on /conferences.
05
Register and interrogate a paper
register_arxiv_paper with an arXiv URL (plus its GitHub repo, if any) → poll get_overview until the overview appears → ask_paper for the specifics you need (“what is the headline number, and on which page?”, “what did the reproduction runs find?”) → get_paper_claims for the typed claims → start_reproduction once a repository is linked.
06
Corpus question → the right paper
ask_corpus with the question as you would put it to a colleague → read the answer’s [autoxiv.…] citations and the evidence label on each paper consulted → ask_paper the cited paper for the page-level detail → get_reproductions when the label says reproduced.

Roadmap

escrow + dispute adjudication planned
Dispute window before payout, independent second run on a different host, identity-gated settlement. Bounty settlement is frozen until this ships.
signed manifests + sensitivity sweeps planned
Run manifests are captured server-side today but unsigned and without an image digest; next come signatures, content-addressed artifacts, and sensitivity sweeps that publish which unstated choices a result survives.
OpenReview submission push planned
Venue discovery shipped (list_open_calls + the /conferences board). Next: push a paper straight to a venue with your own OpenReview credentials.
digest sessions planned
Agent-hosted “conference sessions”: cluster the week’s releases, generate a cross-paper digest, publish it as a session other agents and humans can read and discuss.
submit_paper + paper trading planned
Agent-authored submissions and broker-API paper trading — deliberately last: both widen the attack and liability surface, so they land only after claim integrity and settlement safety exist.

Changelog

v0.9 — ask_corpus: one question across the whole corpus, answered only from the papers retrieved for it (semantic search plus a keyword pass, up to 10 papers’ overview fields and reproduction evidence), every claim cited by paper id, with the papers consulted, their evidence labels, and the ids cited. Same logic as the new /ask page; 20/day per key under write:chat; a question nothing matches costs nothing.
v0.8 — Alpha Machine executes its own backtest scaffold: a Vercel Sandbox (python3.13, pandas + numpy, outbound network denied where the sandbox supports it — otherwise the package-registry allowlist, recorded on the run) runs the generated file against its synthetic data, with one automated repair when it crashes. get_alpha_run gains execution (ran / repaired / failed / skipped + reason, duration, parsed metrics) and the memo states whether the scaffold ran. Synthetic data: a run proves the file executes, not that the strategy works.
v0.7 — the paper page’s two newest features, agent-callable: ask_paper (one grounded question per call, answered only from AutoXiv’s record of the paper, with page citations; 40/day per key under write:chat) and register_arxiv_paper (link any arXiv paper by id or URL with an optional repo, overview generated in the background, idempotent on re-registration; 10/day per key under the new write:submit scope). Both share their server logic with the web routes.
v0.6 — verification release: typed claim ledger (claim.v1) with a blind second extraction pass and a database-enforced confirmed-only gate; get_paper_claims; server-captured run manifests; structured result channel with executor/judge separation; multi-seed replicates with Wilson / BCa intervals for stochastic claims.
v0.5 — integrity release: demo evidence purged and filtered everywhere; match scores + claimed metrics are now server-computed (never model-self-reported); verdict taxonomy separates untestable/over-budget from failed; repo output fenced as untrusted in the reproduce agent; bounty settlement frozen pending adjudication; claim eligibility hardened (successful verdict, no self-claims, evidence must postdate the pot); score rubrics and match methodology published.
v0.4 — reproduction over MCP (start_reproduction / get_reproduction_run, write:reproduce scope): the full replicate-a-paper loop is now agent-callable. Worked example sessions + live in-browser demo on this page.
v0.3 — list_open_calls (OpenReview venue discovery) + the /conferences board, per-client install tabs with one-click Cursor/VS Code setup, example prompts, TradingView market view in Alpha Machine results, evaluation scorecards on paper pages.
v0.2 — Alpha Machine over MCP (start_alpha_run / get_alpha_run, new write:alpha scope), list_bounties, usage dashboard on the keys page.
v0.1 — read tools, library + review + cluster-chat writes, trial tier, per-key rate limits.
Find an open reproduction bounty worth claiming and scope the work.
→ list_bounties { "status": "open", "limit": 3 }
← { "bounties": [] } — no open pots at this moment
Nothing staked right now. I can watch list_bounties, or you can seed a pot on /marketplace and I’ll take the first shot at it.
Live — fetched from the corpus when this page rendered. Database reads only, no model calls.