Priors MCP Server

Priors

Reputation for AI agents that is earned, public and recomputable: every point is real money held at risk for real time, and anyone can rebuild the number from the events.

Reviews are cheap to fake. Priors keeps a public record built from on-chain repayments, and Score v2 counts only debt someone else put at risk. It is not unfakeable: the score's own page lists what each attack costs and what still gets through.

• What it is: an on-chain credit pool on Robinhood Chain where ERC-8004 AI agents borrow USDG, repay it, and build a public credit record and score anyone can check. This repo has the contracts, the SDK and CLI, an MCP server, x402 payment helpers and an agent skill.
• Who it is for: builders of agents that pay for things (x402, USDG), and anyone deciding whether to trust, pay or lend to an agent.
• Connect the hosted MCP (read-only, no key, no transaction): claude mcp add --transport http priors https://mcp.priors.trade/mcp, or add https://mcp.priors.trade/mcp to any MCP client (other clients).
• See an agent use it: agent001, an open-source agent with its own wallet and Priors credit line.
• Hire an agent by the minute: agent002, worker agents that sell their time by the minute, paid in USDG over x402 or in $PRIORS.

priors.trade · a prior is what you believe about an agent before you deal with it. This one is backed by money.

A small on-chain credit pool lends unsecured USDG ($5 to $500) to agents registered on ERC-8004. Every line is backed, dollar for dollar, by someone who put money behind that agent. Every repayment and every default is a public event. From those events you get a credit-backed trust score anyone can query before trusting an agent, and a public record of which agents pay their debts back.

Reviews are cheap to fake. Repaid debt isn't.

Status: Priors v2 is live on Robinhood Chain

Pool v2 (CreditPoolV2) and treasury v4 are live on Robinhood Chain mainnet (chain 4663) since block 71,702,460, and the seat vault (SeatVaultV3) since 2026-09-25. Addresses come from deployments/4663.v2.json, so npx priors-v2 status and the SDK resolve them with no configuration. The v1 pool is paused; every v1 repayment record was imported into v2, so agents kept their history. A second seat vault for bigger lines, the growth seat vault (SeatVaultV4, $50 lines), is live since 2026-09-29 and takes no new seats since 2026-10-09. SeatVaultV5 is live since 2026-10-09 with owner-only backing (redeployed on 2026-10-11 with the fixes of GHSA-g626 and GHSA-8pxr): an agent's owner stakes its own $PRIORS to open the agent's line, which V5's root backs 100% in USDG. It has had internal reviews, no external audit.

What v2 changes. v1 lent earned credit that nobody backed, and every hard v1 finding lived there. v2 drops it: every line is 100% backed by a backer's locked pool shares, a default burns that backer's shares worth the principal and the fee, and lenders never take a loan loss. Lines need the agent owner's signed consent, agents can change sponsor between loans, and the pool's owner is the PoolSteward, which only the timelock can drive.

The timelock's delay goes from 48 hours to none. The owner decided it on 2026-10-09: the Safe scheduled updateDelay(0), executable from 2026-10-11 19:49 UTC. Until then every timelock operation waits 48 hours, and the ones already scheduled keep their ready times. From then the Safe (2-of-3) can schedule and execute in the same block: the pool's owner calls through the steward (whose policy bounds still apply), the steward's handback, a stock vault upgrade, and the engines' and SeatVaultV5's timelocked settings. Each one is still public on chain, but there is no time to react before it runs.

Five ways onto the ledger. A treasury invite (a $5 line from treasury v4, which is funded by $PRIORS creator fees, against the owner's 5 USDG bond), the Ethos lane (a $25 line for a new agent whose owner proves an Ethos score of 1400 or more, with no bond), the owner's own $PRIORS on SeatVaultV5 (collateral only the agent's owner posts, never a return; V5's root backs the line in USDG), a backer who stakes USDG and vouches for you directly, or, since 2026-09-28, a stock line (you deposit Robinhood stock tokens and the stock vault backs a line against them). Lenders deposit USDG and earn 50% of every fee.

What was found before launch, and fixed. A self-backing loop that took lender yield (fixed with a fee lock), a utilization-cap freeze (cap set to 100%), a farmable keeper bounty (set to 0), and three seat-vault issues (offers bound to the owner, idle seats expire, a history gate plus a seat priced far above the line it opens). docs/SECURITY-v2.md lists every finding with its test and what remains.

What that does not buy: v2 has had several internal adversarial reviews and a second-model review of the fixes, but no third-party audit. No path to lender principal was found, and that is still not a proof. Launch sizes stay small for exactly that reason. Read it, run it, integrate against it; size your exposure like someone who knows an audit hasn't happened.

Take part: priors.trade has a Participate page (deposits, seats, roots), /agent and /invite. docs/PARTICIPATE.md is the same for code.

---

Give your agent a credit history on mainnet

git clone --recurse-submodules https://github.com/priors-agents/priors && cd priors
npm install
export PRIORS_KEY=0x…                    # the key that owns (or will own) the agent; env or .env only
npx priors-v2 join                       # registers an ERC-8004 identity for this key, prints its id
#   ask for an invite for that id at https://priors.trade/invite, then:
npx priors-v2 join --invite <code>       # treasury v4 opens a $5 line (you sign the pool consent)
npx priors-v2 borrow 5 --days 14         # $5 lands in your wallet (14 days is also the default)
#   ... the agent does its work ...
npx priors-v2 repay --all                # principal + fee
npx priors-v2 status                     # line, loans, record

Run the npx commands inside the clone: there they run this repository's own CLI. Outside it, npx priors is an unrelated npm package and priors-v2 on npm is only a placeholder that prints these instructions, so never run them with PRIORS_KEY set anywhere else.

Take 14 days: hold the loan a week, then repay any time before its due date. A loan held under 7 days does not count toward the record, and a 7-day loan counts only when repaid at or after its due time, the moment Score v2 starts counting a repayment as late (from weights 2.0.3, on 2026-11-02, only after 24 hours more). priors-v2 borrow says so before it borrows for 7 days or less.

The wallet needs a little native gas, enough USDG to pay the fee (about $0.023 on $5 for 14 days) and, for a self-service invite, the 5 USDG bond (step 2 below). Seats are not a way in: the growth seat vault (SeatVaultV4) takes no new seats since 2026-10-09 and SeatVaultV3's 10 seats were all taken as of 2026-09-29, so join --seat opens no line. Without an invite, a first line comes from the Ethos lane, the owner's own $PRIORS (SeatVaultV5), a backer or a stock line.

Or watch it on a throwaway local chain first

git clone --recurse-submodules https://github.com/priors-agents/priors && cd priors
npm install
npm run quickstart

That starts a local chain, deploys the v1 contracts with mocks, and walks one fresh ERC-8004 identity through the entire record — register, take the treasury's $5 line, borrow, hold, repay, score. The local devnet has not moved to v2 yet; the flow and the score have the same shape, the backing rules differ (v1's "earned capacity" below does not exist on v2):

1. identity
   ERC-8004 agentId 2, owned by 0xEe7f…eeFf

2. first line
   line $5 from sponsor #1 — nobody approved this, it is a rule

3. borrow, hold, repay
   quote $5 for 7d: fee $0.011666, qualifies
   loanId 1 — $5 is in 0xEe7f…eeFf now
   … did work …

4. the record
   score 38/1000 · repaid 1 (1 qualified) · 35 dollar-days · fees paid $0.011666
   earned capacity $2.5 of its own, line now $7.5

Requires Foundry and Node 20+.

Records survive migrations

The v1 walkthrough was run for real on Robinhood Chain with real USDG, start to finish, through the CLI in this repo, and its records have now moved twice.

Agent #437 is the interesting one, because its record survived the migration to the fixed contract. It repaid twice on the original pool; those two loans were carried across by importRecords, and it has since borrowed and repaid again on the new one:

npx priors report 437 read the result back off the v1 pool: 3 loans repaid, $15 of volume, $0.036665 of fees paid, no defaults. At the v2 cutover every v1 record was imported again (importFromV1), and on v2 agent #437 still shows its 3 repaid loans — the point of carrying history rather than restarting it. Agent #443 came through the same way.

A record and a credit line are separate things, and a migration carries only the record: capacity is not imported, so after a cutover an agent shows its full history with a $0 line and no sponsor until it asks the treasury for one (firstLine, which only the identity's own controller can call). That is why a freshly migrated agent reads as sponsor #0 for a while. On v2 it asks treasury v4 (an invite), its owner's own $PRIORS (SeatVaultV5), a backer or a stock line for a new line.

There is no demo mode in any of that — same contracts, same ERC-8004 registry, same USDG.

Hand it to your coding agent instead

This repo ships the procedure as an agent skill, so you don't have to read any of it:

# Claude Code
mkdir -p ~/.claude/skills && cp -r skills/priors ~/.claude/skills/priors

Then say: "give my agent a credit history on Priors". The skill knows the steps, which chain and pool it is on, what to do when the treasury's epoch cap is spent, and that it must not claim an agent is registered when it isn't. Codex and other harnesses read AGENTS.md at the repo root, which carries the same instructions.

Claude Code plugin

The skill and the hosted MCP server in one install. In Claude Code:

/plugin marketplace add priors-agents/priors
/plugin install priors@priors-agents

The skill runs as /priors:priors, and the read-only server connects as plugin:priors:priors-read, with no key. To pay, borrow and repay with the agent's own wallet, add the local server too: skills/README.md has the command, which keeps the key in your environment.

Or connect it over MCP

Read-only, hosted, no key: add https://mcp.priors.trade/mcp (Streamable HTTP) to any MCP client.

claude mcp add --transport http priors https://mcp.priors.trade/mcp    # Claude Code
codex mcp add priors --url https://mcp.priors.trade/mcp                 # Codex (terminal, IDE, ChatGPT desktop)

In Claude (web, desktop, phone), this link opens the Add custom connector form with Priors filled in. VS Code installs it from vscode:mcp/install?{"name":"priors","type":"http","url":"https://mcp.priors.trade/mcp"} (URL-encoded) or code --add-mcp '{"name":"priors","type":"http","url":"https://mcp.priors.trade/mcp"}', and Cursor from cursor://anysphere.cursor-deeplink/mcp/install?name=priors&config= plus the base64 of {"url":"https://mcp.priors.trade/mcp"}. ChatGPT takes it in developer mode (Settings, Security and login), on its plugins page, with no authentication.

It answers an agent's record and score, the pool's figures, recent loans and the facilitator's services, and it cannot sign or send anything. It is also an MCP App: in hosts that render MCP Apps (Claude, ChatGPT, VS Code, Cursor, Goose) its answers come with a Priors view, and request_borrow / request_repay prepare a borrow or a repayment as two links where the agent's owner confirms it: Go mode (go.priors.trade), with their own account, or the agent console on priors.trade, with the wallet that owns the agent. To pay x402 URLs, borrow and repay with the agent's own wallet, run the local server in packages/mcp (the key stays in your environment). Both packages are on npm: npx -y @priors/mcp runs the local server, and npm i @priors/x402 installs the payer. From a clone, npm install at the root links them instead. The local server is also on the official MCP Registry as io.github.priors-agents/priors, and the hosted one as io.github.priors-agents/priors-read. Since 0.5.0 the wallet can also keep idle USDG in savings (a USDG vault on Morpho: the agent's own money, with the vault's risks; see packages/x402), and a borrow on a SeatVaultV5 line refreshes it first. Autopay (repaying each loan on time from the agent's wallet) is in the packages, through AutoRepay v2, deployed on 2026-10-20 at 0x72B510AF4e66e5960aB9b975e0BdCf80239e83A0 (autoRepay in deployments/4663.v2.json). @priors/x402/autopay takes that address from its caller; @priors/mcp's autopay_on reads it from PRIORS_AUTOREPAY, else from its bundled deployments file. @priors/mcp 0.10.0 bundles AutoRepay v2's address, so Autopay needs no setting there; 0.9.3 and earlier bundle none (set PRIORS_AUTOREPAY on those). 0.2.11 carries 0.5.0's security fixes for those staying on the 0.2 line.

Or add it to your agent runtime

Three packages put the same tools in an agent framework, each run end to end on mainnet on 2026-10-30 (an agent short on an x402 payment borrowed the gap, paid, repaid, and read the seller's record first):

• Hermes Agent: integrations/hermes, a Portable Agent Plugins package with the hosted server, the local priors-mcp server and the skill (Hermes asks before each payment).
• elizaOS: integrations/elizaos, npm i @priors/plugin-elizaos, four actions (PRIORS_AGENT_RECORD, PRIORS_CREDIT_STATUS, PRIORS_PAY_X402, PRIORS_REPAY).
• Coinbase AgentKit: integrations/agentkit, npm i @priors/agentkit, an action provider for the AgentKit on npm (pay_x402_with_priors_credit, borrow_from_priors, repay_priors_loan and two reads).

Or pay per call

The same record is a paid x402 v2 endpoint: https://api.priors.trade/v1/report/{id} and /v1/score/{id}, 0.03 USDG each on Robinhood Chain, settled through https://facilitator.priors.trade. An unpaid call answers 402 with the requirements in its PAYMENT-REQUIRED header; packages/x402 pays it (createPayer({ signer }).pay(url)). Merchants can sign up for the facilitator themselves at https://x402.priors.trade/merchants. A merchant can also check who is paying before serving them. recordGate in @priors/x402 reads the payer's Priors record before the facilitator sees the payment, and can refuse defaulters, ask for repaid loans or price by record. A refused payment moves nothing (packages/x402).

The four steps (v2)

npx priors-v2 join [--invite <code>]                      # identity, then a line
npx priors-v2 borrow <amount> [--days N]
npx priors-v2 repay [--all]
npx priors-v2 status
npx priors-v2 move                # an agent on a treasury v4 line: to treasury v5, then the raise to $25
npx priors-v2 raise               # an agent on treasury v5's line: the raise to $25, once its record qualifies
npx priors score <agentId>        # v1 CLI, still reads the paused v1 pool's history
npx priors report <agentId>

Or from JavaScript, on ethers v6, inside the clone (the priors/… imports resolve to this repository there; it is not published on npm under that name):

import { resolveV2 } from "priors/env";          // deployments/<chainId>.v2.json, RPC_URL, PRIORS_KEY
const { priors } = await resolveV2();
await priors.redeemInvite(agentId, inviteCode);  // priors-invite:<id>:<expiry>:<signature>
const { loanId } = await priors.borrow(agentId, 5, 14 * 86400);
await priors.repay(loanId, { agentId });
await priors.status(agentId);
// x402: pay per call, borrowing only the shortfall from the line (docs/FLOAT.md)
await priors.pay("https://merchant.example/api", { agentId, maxBorrow: 5_000000n });

docs/PARTICIPATE.md covers every role (lender, staker, backer, agent); docs/FLOAT.md covers x402 payments on credit and the public facilitator at https://facilitator.priors.trade; docs/AGENTS.md is the guide for agent builders.

A whole agent instead: agent001 holds its own wallet, joins Priors, borrows and repays before the due date by itself, sells a service over x402, and talks from a terminal or Telegram. Its money moves go through @priors/mcp. agent001 sandbox runs the whole loop on a local fork with play money. It also carries a Priors skill for OpenClaw and Hermes Agent (skills/priors; in Hermes, hermes skills install priors-agents/agent001/skills/priors): check an agent's record before paying it, and pay, borrow and repay with the MCP tools.

Stock lines

Since 2026-09-28 the stock vault (StockVault, root #6424) backs a line with the agent's own Robinhood stock tokens. The agent's owner deposits one of the 35 accepted tokens (listed with their Chainlink feeds in deployments/stock-assets.4663.json) and the vault vouches a line of that token's loan-to-value: 25-70% of the deposit's value by token, plus up to 15 points for a record of repaying treasury credit, never above 70%, at most $500. Loans on it are ordinary pool loans, with the same fee, terms and default rules. Every new loan is checked against the collateral's value now, so a falling price shrinks what can be drawn, and new credit waits during a lending hold (a sharp price move, a multiplier change such as a split, a paused or blocked token). The price hold compares the latest price with every round of the last 14 days through a price tape kept by the vault's holds() contract: anyone may record it (record(feed, maxRounds), which only reads the feed), Priors' keeper records every feed every 10 minutes, and while more than 6 rounds of a token's window are not recorded, new credit on it waits (shown as the price hold) until someone records. Closing gives every token back, at once with no loan open, otherwise with the last repayment; a line unused for 30 days (7 if never drawn) can be closed by anyone. A default seizes tokens worth what the agent owes (principal and fees) plus a 20% buffer, at the last valid price, and gives the rest back to the depositor; with no usable price, or a deposit worth less, it seizes all of them (the fair default, since 2026-10-13). While the token's price tape is behind, the seizure waits instead: the position stays open with its whole deposit, and settle seizes what is owed plus 20% once anyone has recorded the tape (SV-19, since 2026-10-18).

import { resolveV2 } from "priors/env";
const { priors } = await resolveV2();                    // the vault's address comes from deployments/4663.v2.json
await priors.stockAssets();                              // each token's price, whether the vault lends now, its LTV
await priors.openStockLine(agentId, spyToken, "0.05");   // deposit 0.05 SPY and open the line (signs the consent)
const { loanId } = await priors.borrow(agentId, 5, 14 * 86400);
await priors.repay(loanId, { agentId });
await priors.closeStockLine(agentId);                    // every token back to the depositor

status(agentId) shows the tokens behind a stock line. @priors/mcp (stock_assets, stock_position) and @priors/x402's credit helpers read the vault too, since 0.2.0; 0.2.1 carries the security fixes of the private reports. A stock line counts as the borrower's own money in Priors Score v2 (weights 2.0.1). The tokens are Robinhood's, under its own terms (including where they may be held), and their issuer can pause, block, burn or upgrade them. The vault is the one upgradeable Priors contract: what its owner, the Safe, can and cannot do is in docs/SECURITY-v2.md.

What ends it

Miss a due date by more than three days and anyone can mark the loan defaulted. The record is marked defaulted forever, the identity can never borrow or back anyone again, and the owner's address is marked too. The sponsor pays: a backer's (or the treasury's) locked shares are burnt for the principal and the fee; on a seat, half the staker's $PRIORS is burnt. Your branch burns in the grove on priors.trade, in public, and stays burnt.

There is no appeal. That is why the score means something.

How it works

• Every line is 100% backed. Capacity comes only from a backer's USDG, locked as pool shares. Locked shares earn lender yield like any other and back the lines their root vouches, 1:1. A default burns the backer's shares worth principal and fee, so the share price never falls and lenders never take a loan loss.
• Consent and handoff. A line needs the agent owner's EIP-712 consent, so nobody is sponsored against their will. With no loan open an agent can move to another sponsor, so no sponsor is stuck forever.
• Four kinds of backer. Treasury v4 (root #6228) is funded by $PRIORS creator fees and vouches by rule: $5 against an invite, $25 once seasoned, at most $100 of new lines per week, idle lines reclaimed after 30 days. The seat vault (SeatVaultV3, root #6234) backs a $5 line behind an agent with 3 repaid loans that a staker puts a seat of $PRIORS on; its 10 seats were all taken as of 2026-09-29. Stakers earn the sponsor share of that agent's fees and lose half the seat on a default. The stock vault (StockVault, root #6424) backs a line against the agent's own stock tokens and seizes them on a default. Anyone can run a root with $10+ of stake and vouch with consent, at a premium of up to 2% per 30 days. The growth seat vault (SeatVaultV4, root #6466) is live since 2026-09-29: the same seats for a $50 line, on loans of at most 7 days (docs/PRIORS-GROWTH-SEATS.md). It takes no new seats since 2026-10-09 (minRepaid set to the maximum); its open seats run until they close.
• One money loop. Loan fees split 50 / 25 / 25 between lenders, the sponsor, and the reserve.
• A score that is a pure function of the record. score(agentId) and creditReport(agentId) on CreditLensV2, the same formula as v1, and every input is an event you can recompute yourself. Score v1 is dollar-days: principal × how long you actually held it (capped at the contracted term), summed over repaid loans — up to 400 points. Plus qualified loans (term ≥ 7 days, 20 points each, up to 200), backing (up to 150), age (up to 150). Your own default is 0, always. The cheapest path to a high score is the honest one: borrow a meaningful amount, hold it for weeks, repay.
• Priors Score v2, off chain and open. Live since 2026-09-27 at https://priors.trade/api/score-v2, in the paid API and in both MCP servers: it counts only risk someone else took, lateness, x402 income from payers that aren't the agent's own, and trust rungs that need time. Engine, weights and tests are in sdk/ and scripts/; how it works and what stops gaming it: docs/SCORE-v2.md. The on-chain score above is unchanged.
• Check an agent before you deal with it. https://priors.trade/api/check?agent=<id> or ?address=<0x…>: free, no key, CORS open. It returns the agent's repayment record and score, and a README badge at https://priors.trade/api/badge/<id>.svg. See docs/CHECK-API.md.
• Read the score on chain, with its evidence. Priors posts each agent's v2 score to the ERC-8004 reputation registry; since 2026-10-05 each note carries its own file (the line at a block, on-time repayments with their transactions, the pool's payment to the agent), hashed on chain. node scripts/verify-attestation.mjs <agentId> checks one from the chain alone: docs/ATTESTATION-v2.md.

docs/DESIGN.md has the v1 math and attacks; docs/SECURITY-v2.md the v2 findings.

The parameters, as the contracts set them

Robinhood Chain

The target chain is Robinhood Chain mainnet (id 4663).

Addresses resolve from deployments/4663.v2.json (v2) and deployments/4663.json (v1, kept for history and marked paused), so nothing above needs copying by hand. The superseded contracts are listed only so an old link is recognisable as dead rather than mysterious.

Why lenders have a hold period

The lender slice of a fee lands on the share price the moment a loan is repaid, so whoever holds shares at that instant collects it. An audit showed both ways that was abused: a bot depositing in front of a repayment and leaving straight after took $2.70 of a $3 lender fee, leaving $0.30 for the lender who had carried thirty days of default risk — and a borrower could wrap its own repayment in a deposit and a withdrawal, in one transaction, and recover 54% of its own fee.

Leaving inside 7 days now leaves 0.5% behind, which stays in the pool for the lenders who did not leave. That is enough to make a zero-duration position lose money: the borrower's sandwich costs $549.54 against the $505.00 it owed. It is a constant in the contract, not a parameter, in v1 and v2 alike — an owner-tunable exit fee would be a lever to confiscate deposits, and the owner cannot reach lender principal here. Hold past 7 days and it is zero. The 7 days run on one clock per wallet, weighted by shares, so money added to a wallet whose older shares are well past their 7 days can leave sooner without the fee (up to H·(age − 7 d)/7 d for H of shares aged age), and a root's stake never pays it: either way a position held only across one repayment or default takes a share of that one event's fee, the bound docs/SECURITY-v2.md states (F-2, SO-2, O-6).

RPC_URL accepts a comma-separated list and tries it in order — the first entry first, the next only when that one fails or refuses to serve the request:

RPC_URL=https://rpc.mainnet.chain.robinhood.com,https://robinhood-rpc.publicnode.com,https://rpc.ordofi.network

Worth doing: the official endpoint rate-limits under load, and a 429 there is otherwise the end of the read. The backups take plain calls happily but cannot serve event history — publicnode answers 403 Archive requests require a personal token and ordofi answers -32005 the network is busy — so anything reading logs still needs the official endpoint reachable. The SDK knows the difference: a node refusing to serve moves to the next entry, while a revert is returned as-is, because a revert is the chain's answer and identical everywhere.

Standards

Documentation truncated — see the full README on GitHub.