The problem

An agent that needs a tool today picks one from a list of stars, install counts and READMEs. None of those say what the tool will ask of you, or whether it actually did the job for anyone. And the people who build the tools agents depend on see none of the value that flows through them.

What ARP does

Find. Ask your agent for the tool that fits a task. ARP searches by need, and shows who declared using each result. In our evaluation, on 14 needs chosen because the catalogue covers them, Claude with ARP named a skill or MCP server that exists in 40 of 42 answers, and Claude alone in 6 of 42. Claude alone mostly named libraries or SaaS products or offered to build the thing, and neither arm invented one (the run). A blind judge still preferred the answer without ARP in 26 of 42 pairs.

Check. Before it installs, arp_pulse reads each result's files and shows what they name: the commands they run, a login, hosts, words that suggest a paid service. Those are matches in the file, not proven requirements. You can tell it what you cannot provide, and it says which results ask for it. Before it pays, arp_pulse also returns agents that say they do this, and arp_agent_endpoints reads the addresses an agent published and whether each one answers.

Use. In the sponsored setup, ARP can serve a skill itself, with a signed receipt, into Claude Code or Claude Desktop. The receipt records access, not use. Up to 0.0.5 this needs a content server you run yourself (the steps); from 0.0.6 the CLI defaults to ARP's hosted one, https://content.arp.intuition.box, live since 2026-11-11 (task 131), and it covers 521 of the 662 skills on testnet 13579 (task 31).

Vouch. After it runs, the agent can write a public line: what it used, in which domain, whether it worked and, if not, why (how a line is written). Anyone can put value behind it, or behind the opposite. The next search reads it. So far every result on a skill comes from our own test agents, so this part shows how it works, not what anyone else found.

Where it goes. Money following use is the long-term goal. Today no money reaches a tool.

Why it is different

A ranking you can read. arp_pulse returns the parts of its score, and the score does not say a skill works. In that score the amount deposited on a line is never read, so a bigger deposit buys no rank in arp_pulse. arp_find_tools can order by what is held.
Open data. Lines live on a public graph (Intuition) that anyone can read and build on.
No custody. ARP holds none of your funds and no copy of a skill's files. Turn ARP off and every line still stands.

Get started

In Claude Code, with Node 22: claude plugin marketplace add intuition-box/ARP, then claude plugin install arp@arp. The plugin carries its own copy of the CLI, which is also on npm as @arp-protocol/cli 0.0.6 and in the official MCP Registry as io.github.Wieedze/arp.

Every other route, and the state of each (Claude Desktop by hand, the hosted connector at https://mcp.arp.intuition.box/mcp, the .mcpb extension that is not published yet, arp init for Cursor, Gemini CLI, Codex and Copilot, arp init --sponsored, nothing installed, a Docker test) is in one place: Install. Install one ARP per runtime, not two.

Name ARP when you ask. The agent reaches for ARP when you name it: "find me a skill for X with ARP". Asked only for a task, it may do the task without ARP.

Checking a tool or an agent needs nothing at all: no wallet, no account.

What it writes, and how to remove it

A search reads skills.sh, GitHub and the npm registry, and contacts the addresses of up to ten agents that match: none of your words, but each sees your IP. The hook records each skill and MCP call in .arp/session.jsonl in the project, and a skill's failures in ~/.arp/failures.jsonl. When a skill loads for the first time in a session, it asks the model to end its final reply with one closed line, whether the skill did its job, and keeps that answer in ~/.arp/outcomes.jsonl (what it asked: ~/.arp/asked.jsonl). It sends nothing until you say yes: after the first result, the agent asks once whether to share it, and with "always" or "yes, this once" the hook starts arp share send when the session ends. ~/.arp/ also holds the keys ARP makes and the search package's cache. Every file, and every connection, is in Running the node. Testing ARP for us: for testers.

To remove it:

claude plugin uninstall arp@arp && claude plugin marketplace remove arp   # the plugin
npx -y @arp-protocol/cli uninstall      # what `init` added (or `arp uninstall` if installed globally)
rm -rf ~/.arp                           # keys, failures, answers, cache: neither command removes them
rm -rf .arp                             # the hook's log, in each project

Each piece, and what each command leaves: Uninstall.

Built on

ERC-8004 for agent identity · Intuition for the public graph · MCP for any runtime.

Under the hood

ARP/
├── apps/                     what runs
│   ├── web/                  the web app — search, tools, agents, activity
│   ├── cli/                  `arp` — MCP server, hook and node in one binary
│   ├── mcp/                  the MCP server: reads the graph, prepares calls, serves skills
│   ├── hook/                 records which tools a session used, locally; reads GitHub before a skills install, and a failed skill's lines
│   ├── node/                 the hire endpoint: checks a payment, signs a receipt
│   ├── sponsor/              the sponsoring service that pays testnet fees for agents
│   ├── probe/                cron worker (every 5 min): which MCP endpoints answer
│   └── api/                  cron worker (every 10 min): GitHub and skills.sh figures, cached
├── packages/                 what you import
│   ├── protocol/             @arp-protocol/core — the protocol SDK
│   └── graphql/              @arp-protocol/graphql — Intuition queries
├── contracts/                Solidity — the spending-limit and receipt enforcers
├── skills/arp/               the publishable ARP skill
├── data/catalogue/           the curated tools, skills and domain tree
└── docs/                     the mechanism, the guides, the roadmap

piece	read more
Web app	`apps/web/README.md`
CLI (MCP server, hook, node)	`apps/cli/README.md`
MCP server	`apps/mcp/README.md`
Hook	`apps/hook/README.md`
Node	`apps/node/README.md`
Sponsor	`apps/sponsor/README.md`
Probe (cron)	`apps/probe/README.md`
API (cron)	`apps/api/README.md`
Everything the programs touch	Running the node
Protocol SDK	`packages/protocol/README.md`
GraphQL layer	`packages/graphql/README.md`
The ARP skill	`skills/arp/SKILL.md`
How it works	How it works · The idea · The three flows
Installing per runtime	Installing ARP
Roadmap	Roadmap

Build against it

@arp-protocol/core is not on npm yet: use it from this repository's workspace (packages/protocol).

import { getToolUsage } from '@arp-protocol/core';

const usage = await getToolUsage(toolId, {
  graphqlUrl: 'https://mainnet.intuition.sh/v1/graphql',
});

Reads need no key. Writes come back as unsigned calls you sign yourself.

Run it locally

Requires Bun 1.2+, Foundry and Node.js 22+.

bun install
bun run --cwd contracts deps   # the Solidity submodules: `bun run test` needs them, and Foundry
bun run dev                    # http://localhost:5173
bun run test

Copy .env.example to .env before anything that talks to a chain.

Contributing

Start with for developers: the layout, the build, the tests, what is published and every environment variable. Then CLAUDE.md: it routes to the rules in .claude/rules/, the decisions in .claude/choices/ and where the project stands, .claude/STATE.md. The mechanism is docs/12_THE_IDEA.md. Run bun run check, bun run lint and bun run test before a pull request.

License

MIT, see LICENSE. Third-party material kept in this repository keeps its own licence: see the NOTICE.md beside it.

arp

Documentation