Proof Desk Field Dispatch 10
The surface Run it Fermah
Dispatch 10 the machine-callable surface

The primary user of a protocol isn't human anymore.

It is an agent calling an execution surface directly, at machine speed, with no one watching a dashboard. Most protocols still build for the human. Below is the other kind: a proof-market surface an agent can drive end to end. Press run, or call the tools yourself. It settles with zero humans in the loop.

agent ↔ proof-market surface
A reference surface running in your browser on the same engine as the open-source MCP server. A model, not Fermah's production Kernel.
Section 01 / Two users

The agents are already acting. The protocols are still built for the wrong user.

A human takes seconds to notice a condition and click. An agent takes milliseconds and never stops. When the caller changes, the whole shape of the interface has to change with it. A protocol without a machine-callable surface is invisible to the agent economy, no matter how capable its onchain logic is.

Built for a human

Dashboard, keeper, cron

Execution waits for a person to see a state and trigger it. Every trigger surface and initiation window was sized for a caller that takes seconds.

  • A held key someone has to be awake to use
  • A cron job someone forgot to check
  • A dispute window clocked to a human committee
  • Latency measured in minutes, and invisible until it isn't
Built for an agent

A callable surface

Execution is initiated by software, at machine speed, with no human in the loop. The surface exposes tools an agent composes directly.

  • Submit a Proof Request and poll for the result
  • Read supply, allocated, utilized in one call
  • Compose a multi-step workflow that self-settles
  • Coordination overhead in milliseconds, and legible
Section 02 / The surface

Five tools an agent can call over the Model Context Protocol.

The console above is not a mockup. It is a real MCP surface: the same five tools, the same responses, the same engine. Connect it to Claude, Cursor, or any MCP client and an agent drives a proof market with no human intermediary. This is what "do you have an MCP server" looks like when the answer is yes.

agent ↔ mcp ↔ proof-market surface
agent the caller MCP proof-market surface market_state submit_proof_request poll_proof simulate_coordination compose_workflow assign Prover Nodes generate proofs proof + attestation · humans 0
market_state()
Snapshot supply, allocated and utilized of the running market, plus the matching and scheduling gaps. The three numbers, not one.
simulate_coordination(regime)
Run the coordination model over a full horizon. Same supply in every regime; only coordination changes. Backed by the proofmarket-sim engine.
submit_proof_request(system, size)
A Seeker submits a Proof Request. The Matchmaker assigns it to a Prover Node when capacity frees. Returns an id to poll.
poll_proof(requestId)
Check a request. On settle it carries a proof id and attestation, delivered the way a proof returns to a Seeker callback. Zero humans.
the agentic path
compose_workflow(steps)
Define an ordered sequence, observe a condition, request a proof, act, settle, and the surface runs the whole thing and returns an attested trace with humans in the loop equal to zero.
connect it to an agent · claude_desktop_config.json
"proofmarket-surface": {
  "command": "node",
  "args": ["/path/to/proofmarket-mcp/src/server.js"]
}
Section 03 / The proof

What the agent finds when it looks.

The first thing an agent does on this surface is compare coordination regimes. It runs the model twice over the same Prover Nodes and reads the answer: the ceiling is coordination, not compute. Then it composes a workflow and settles it, no human paged.

utilization of the same 345,600 units of supply delta +52.0 pp
simulate_coordination(today) 39.4%
operator on path · supply 345,600 · proofs 3,808
simulate_coordination(coordinated) 91.4%
operator removed, work on the spectrum · supply 345,600 · proofs 9,360
1.5M times a protocol did not have to page an engineer.
Fermah reports proofs delivered onchain with zero human interventions. This surface models the shape of that: an agent submits, the market settles, and the number of humans in the loop stays at zero from request to attestation.
Section 04 / Method

It is a real MCP server. Clone it and connect it.

The console on this page runs the reference surface in your browser. The repository is the same surface as an actual Model Context Protocol server you can attach to an agent, with the coordination engine from the previous dispatch underneath. It is a model of a proof-market surface, not Fermah's production Kernel, and it says so in the tool output.

proofmarket-mcp
An MCP server exposing a machine-callable proof-market surface: submit Proof Requests, read supply, allocated and utilized, and compose multi-step workflows an agent runs with no human in the loop. Same engine as proofmarket-sim, so every number matches.
# an agent drives the surface end to end, no human
npm run demo

# start the MCP server on stdio, then attach it to Claude or Cursor
npm start
MCP server ↗ The engine ↗ Docs PR ↗

The proof-market coordination model this surface is built on is the previous dispatch in this series. This one wraps a machine-callable surface around it, so an agent, not a person, is the one that reads the market and acts on it. Alongside it, a pull request to Fermah's own docs fills the empty installation overview on their mainnet Prover Node page.

Sources and method

  1. Fermah on the primary user of a protocol no longer being human, and on shipping an MCP endpoint for machine-speed initiation. @fermah_xyz, Aug 2026.
  2. Fermah on protocols without a machine-callable surface being invisible to the agent economy, and on proofs delivered onchain with zero human interventions. @fermah_xyz, Aug 2026.
  3. Model Context Protocol, the open standard this surface implements. modelcontextprotocol.io
  4. The surface and the coordination engine underneath it. proofmarket-mcp, proofmarket-sim
  5. A pull request contributing an installation overview diagram to Fermah's documentation. fermah-docs#10

This surface is an independent reference model built by this desk, not published by Fermah and not a source of live network data. It reproduces the shape of a machine-callable proof market so it can be driven by an agent and read line by line. Fermah's production counters are theirs; the numbers here are generated by the embedded engine.