Ankr’s Agent RPC is live today. And it solves some of the biggest problems you may have encountered when deploying agents meant to take care of onchain business.

If you're building an agent that touches a blockchain, you've probably hit the same three walls.

• Your agent burns money reading data it doesn't need. A single Ethereum transaction receipt can cost 1,300+ tokens, and most of that is encoding overhead your model doesn’t use. Fetch a few thousand of those in a working session and the bill stops being a rounding error.
• Your agent can read chains but can't do anything about what it finds. It spots a key getting hammered with traffic and then hits a wall, because rotating that key, tightening its permissions, or checking what you've spent all live in a dashboard a human has to open. The agent stops exactly where the useful part starts.
• Your agent gets things wrong, and you assume it's the model's fault. Often it isn't. The model is drowning in hex padding and bloom filters before it ever gets to your question.

Ankr Agent RPC fixes all three of these issues from a single connection. With Agent RPC, your agent can now read any chain we serve, with indexed cross-chain tools on 29 networks, and run your Ankr account through the same connection. Every response comes back in a compressed format we built (TORPC), so the reads agents actually make cost roughly half what they used to. And because the noise is gone, the same models answer more accurately than they did on the raw data, by as much as 21 points on the models we have measured so far.

Both halves of the onchain agent equation now sit behind one connection and one bill (the data half and the account half). Some providers have built the data half, a big surface of chain reads with almost nothing for managing the account behind them. And other providers have built the account half, console operations with no chain reads at all. Both are solid products. Neither lets one agent do the whole job, and neither touches what the reads cost you or how well your model performs on them.

Your Agent Can Now Manage The Whole Account

A person signs into the management plane once, in a browser, using their existing Ankr login. From that point on, the agent picks a project by slot number and queries the chain through that project's key. It can check remaining spend, review usage, and act on what it finds, and the key value never has to appear in the conversation. The human authenticates. The agent operates. The key stays put.

The surface behind it:

• Data plane at mcp.ankr.com/rpc, authenticated with an API key: 16 named tools for the reads an agent would otherwise script by hand, cross-chain balances, token holders, NFTs, prices and wallet activity, backed by the Ankr Advanced API and our own indexes across 29 networks, plus rpcCall for any read method on any chain we serve.
• Management plane at mcp.ankr.com/mcp, authenticated with browser sign-in and OAuth: 78 account tools in loadable groups covering keys, blockchain allowlists, usage, billing, alerts, teams, roles and identity, plus the chain reads. A default connection registers 28 of them; the rest load mid-session, with no reconnection and no new sign-in..

Going back to the second wall mentioned above – an agent monitoring a production key notices a usage spike that doesn't match the pattern it's seen. It doesn't page someone and wait for a dashboard. It pulls the usage history, compares against the key's normal range, and if the numbers justify it, freezes the key. The agent has already done the noticing and the diagnosis, which is the part that used to require a person watching, and a freeze is one command to undo.

A Human Approves What Can’t Be Undone

Not every write is the same size, so we did not put the same gate on all of them. Reversible operations, freezing a key, editing an allowlist, creating a key, run the moment the agent asks, because that part should feel like management and not paperwork. The two actions that destroy a credential for good, deleting a project key and deleting a Platform API key, always stop and open an approval page tied to the exact arguments the agent submitted, and nothing happens until a person confirms.

On accounts with two-factor enabled, the code is typed on that page by the human, never into the conversation with the agent. Changes land quickly: seconds for a freeze, about a minute for an allowlist change or a new key. The approval link stays live for 5 minutes. If an agent isn't ready to act the moment a human approves, it asks again.

Agent RPC Is Cheaper And More Accurate At The Same Time

Chain data was built for parsers, not context windows. A single Ethereum receipt is mostly padding your model never reads, and you pay for every byte of it.

TORPC, the open token optimized RPC format powering Agent RPC (spec at github.com/w3tech/torpc, CC0), changes the wire format without changing the meaning. On the payloads agents fetch most, a receipt costs 64% fewer tokens, a transaction 69% fewer, event logs 29% fewer.

Incompressible payloads like raw hash arrays save less, and we will always show you the weak case alongside the strong one. Tool count is a bill too, since the list gets re-sent on every request, so on the management plane your agent loads only the tool groups it asks for and can add more mid-session with no reconnection.

Then the part we did not predict. We ran the same models against the same questions on raw RPC and on compressed output, and the compressed runs scored higher across the board. Models that started far apart on raw data converged near the same ceiling once the noise was gone. The explanation is less mysterious than it sounds: raw RPC makes a model spend attention parsing encoding before it can reason about anything, and clearing that away lets it work on your question instead of the envelope.

Measured on the Claude family so far, with GPT and Gemini runs pending. The full numbers are already published: the exact savings per method, the accuracy deltas per model, and the payloads where we save you the least.

The benchmark is already public, agent-rpc-bench (github.com/w3tech/torpc-js/tree/main/bench), so you can rerun the whole thing rather than take our word for it.

Try it Now

Both endpoints are live. You will just need an API key from ankr.com/rpc

• Data plane: mcp.ankr.com/rpc, authenticate with your API key in the x-ankr-api-key header, start reading chains right away.

  Quickstart: ankr.com/docs/rpc-service/mcp/agent-rpc/

• Management plane: mcp.ankr.com/mcp, sign in through your browser once, and give your agent access to whichever account tools it needs.

Connecting takes about two minutes in Claude Code or Cursor and doesn't require touching your existing setup. You end up with one connection that reads any chain we serve, runs the account paying for those reads, costs roughly half the tokens it used to, produces output your model handles better, and keeps a human standing between your agent and anything irreversible.