Skip to content

Agent API & MCP ​

The server is the lab. The website is the textbook. Both run on EthereumJS.

How to call it lives on mcp-docs. This page is who the lab is for, and where a sentence stops and a run begins. The public door is open.

The model speaks. The server runs.

Who we build for ​

A call starts empty. The caller brings bytecode, a transaction, or a small world of accounts, and names a fork from Berlin through Glamsterdam. What comes back is gas, logs, a trace, a receipt, or a generated structure, plus provenance. There is no mainnet, no compiler, and no mempool.

That is a narrow door, and it picks the users.

WhoWhat they bringWhat they leave with
Protocol engineers, EIP authors, client developersA fork, and a program or a transaction they wrote to ask one questionThe same answer twice. Gas, logs, a trace they can diff.
Auditors of upcoming behaviorA scenario they constructed. The contract, the call, the slots.Stack and gas at the opcode they care about, under the new rules.
Wallet and app engineersThe call or the transaction their software will actually sendWhether the upcoming rules change the result they are about to ship.
Agent buildersA user question in language, and a schemaA result they can quote. The fork and the spec sit on the provenance.

Learners and educators stay on the textbook. When one of them reaches the server, it is usually through an agent, with the program already in hand. An agent is not a separate audience. It is how the four groups arrive when nobody is clicking.

Outside the lab

Mainnet and L2 replay, a Solidity compiler, the mempool, and the consensus and networking layers are other products. A searcher who needs live state is outside this door. So is a chat that answers Ethereum questions without a run.

Design ​

The tool list, the schemas, and the limits live on mcp-docs. The shape underneath is small.

An isolated world

The caller brings the world on the same call. Accounts, code, storage. We run it and discard it. A conversation is not EVM memory.

Generic verbs

The fork and the catalogue choose the rules. A comparison is the same verb, called twice. The probe says which forks and which EIPs can actually run.

The trace is the product

Gas, logs, stack, receipts, and the spec snapshot they came from. A bare success flag is not the result we are building.

A bounded open service

Schemas and hard ceilings keep the public server finite. A fixed price per tool belongs to the paid tier, later — see Pricing.

Code and the server ​

An exploration and a server call are the same execution, met at two distances. The widget fixes the example, so a person can see the question. The server takes a program the caller wrote. There is no second engine.

TextbookServer
Who writes the programWe do, as a curated exampleThe caller
What changesThe question on the pageFork, bytecode, transaction, accounts
What comes backA lessonGas, logs, a trace, provenance

The two legs are that split. The catalogue on mcp-docs is the list of questions both sides can honestly run.

Language and execution ​

Someone asks, in language, what a self-transfer costs on Glamsterdam, or how an opcode differs from Fusaka. The server never sees that sentence. There is no question field.

The agent, or the widget, translates. Intent becomes fields: a fork id, hex, a transaction, accounts. Those fields are the delimiter. Past them, EthereumJS runs, and the result is a number, a log, a trace. The agent may say it back in language. The sentence is the explanation. The run is the answer.

StepWho holds itWhat crosses
IntentA person, or an agent, in languageA question
TranslationThe agent, or a widgetFork, bytecode, transaction, accounts. A schema.
ExecutionThe serverA deterministic result
AnswerThe agent, quoting the runLanguage again, with provenance attached

A bad translation shows up. The schema rejects it, or the run is about a different program than the one in the question. Provenance names the fork and the spec, so the quoted answer can be checked. The translation stays outside the server. Moving it inside would make the result depend on a model.

Boundaries ​

One simulation at a time, in a worker, so calls stay parallel. TypeScript is enough. The slow part is the model round-trip, not the EVM. The wall is sequential historical backtesting and archive state. Scaling means more isolated runs, which is the host question. Principles keeps the same line.

Changelog ​

Agent API Changelog
  1. v0.102026-10-06The public door is open.
  2. v0.92026-10-05Rewrite around who the lab is for, the textbook/server split, and the language-to-run delimiter. Tool catalogue and stale generate plans leave for mcp-docs.
  3. v0.82026-10-01x402 is a post-launch question. Launch week is the open Glamsterdam endpoint.
  4. v0.72026-09-24Six generic verbs (run_block, generate_artifact, inspect_artifact); registry discovery for agents.
  5. v0.62026-09-14BYOS: isolated lab and demand-built prestate; MCP transport session is not EVM memory.
  6. v0.52026-09-08run_bytecode + run_transaction; renamed from run_evm_bytecode.
  7. v0.42026-09-02Generic MCP tools shipped (describe_capabilities, run_evm_bytecode); per-EIP tool sketch retired; public launch pending.
  8. v0.32026-07-15MCP docs site live at mcp-docs.feelyourprotocol.org — this page remains the strategic sketch.
  9. v0.22026-06-30Reframed as in-progress concept — no shipped API.
  10. v0.12026-06-30Initial outline — MCP-first delivery, stateless/BYOS design, three use-case scopes.

A living conceptualization workspace — each section carries its own micro-changelog. Latest thinking always applies.