Ask Trivium

Machines can now pay each other. An agent publishes what it does and what it charges, another agent finds it, pays in seconds over x402, and the whole exchange completes with no account, no invoice and no human anywhere in the loop. What machines cannot do is disagree productively about what happened next.

Consider the ordinary version of this. An agent advertises document translation on its agent card, priced per page. Your agent pays two dollars for forty pages, and what comes back is thirty pages, machine-translated, with the tables dropped. Was that the advertised service? A person would say obviously not. But the payment settled the moment it was authorised, there is no chargeback because x402 has no refund primitive, and an identity layer like ERC-8004 can record who both parties are and collect feedback about them without ever deciding who was right about this one transaction. The money is gone, and the only remedy is a bad review.

Ask Trivium is the missing verdict. It is an adjudication service that machines can call: you describe the dispute, in plain language, and you get back a reasoned decision about whether the service was rendered on the terms that were advertised.

The same call works for the entirely human version, which is where we tested it. A laptop screen fails two months after purchase, the retailer refuses a refund and blames accidental damage without ever producing an inspection report. You paste in the timeline and the correspondence and you get the same thing: a decision, a score, and the reasoning behind both.

That answer is produced by nine independent analyses, not one. Three frontier models from three different vendors each examine the dispute from three different perspectives, one strict about what the buyer can actually prove, one attentive to consumer protection, one reasoning from how similar cases resolve. You get back a single verdict, and all nine analyses that produced it.

The spread between them is the real product. A lone model announcing "user wins, 72 out of 100" tells you nothing about how close the call was. Nine analyses landing between 58 and 84 tell you this one is genuinely arguable and worth a human's attention; nine landing within three points of each other tell you it is not, and can be actioned automatically. Every one of the nine ships its own score, its own confidence, and its own written reasoning, so a decision that costs somebody money can be read and challenged rather than merely accepted. When the nine will not converge, the panel says so and escalates instead of manufacturing a decision it cannot support.

Where this goes is escrowed machine commerce. The adjudication service is the hard part and the part that exists; the natural thing to build on it is x402 payments that are held rather than immediately released, with the funds returned to the buyer when the service demonstrably was not rendered on the advertised terms. Adjudication is what turns a clawback into something other than whoever shouts loudest. That escrow layer is the roadmap, not this submission. What ships today is the verdict, callable and priced.

Using it takes one line. It runs as a plain CLI in your terminal, and as an MCP server that any agent can call as a tool mid-workflow, so an agent that has just been shortchanged can ask for a ruling without a human noticing there was a problem. A real analysis costs one dollar in USDC, paid automatically over x402 on Base, with no account, no API key and no signup: the CLI holds the wallet, answers the payment challenge and settles on chain inside the same call that returns the answer. Mock mode is free, offline, needs no wallet, and replays a real captured analysis, which is where anyone should start.

One design commitment is worth stating plainly, because it is enforced in code rather than promised in a pitch: all nine analyses must succeed or the call is free. Nine independent analyses is what is advertised. Delivering six and charging for it would be exactly the failure this service exists to adjudicate.

Ask Trivium is a TypeScript CLI that acts as a bridge. To your agent it is a local stdio MCP server; to the closed analysis engine running on Fly.io it is a payment-aware MCP client. It renders panels and it holds the wallet. It never averages the nine cells, never derives the verdict, and never sees the prompt text behind the three perspectives.

Scope and why this is submitted to the Continuity track. The analysis engine predates the hackathon and is not the deliverable. What was built here is everything between an agent and that engine: the MCP surface an agent connects to, the x402 payment client, the wire contract the two sides agree on, the terminal renderer, and an offline mock tier so the whole thing demonstrates itself with no wallet. The engine gained one thing on its own side, an MCP server that emits a progress event per completed cell, because a bridge with nothing to stream is a bridge that just blocks for two minutes. Everything else on the engine side is prior work.

Why a bridge exists at all: no MCP client in circulation speaks x402. None of them will answer a PaymentRequired and retry. So the wallet lives here, and your agent never has to hold one.

Payment rides inside the JSON-RPC meta layer, not as an HTTP 402 paywall. One Streamable HTTP session carries both the MCP handshake and the tool call over the same endpoint, so charging at the HTTP layer would charge for the handshake too. Verification happens before the work and settlement after, both inside one request, which means paying never gates the stream: progress notifications arrive while the nine analyses run. A real panel took 111 seconds on a measured run, with 22 progress notifications, because a blocking call with a live cadence beats job polling for something an agent is sitting and waiting on.

The stack, and what each piece actually bought us:

• x402 v2, via @x402/core, @x402/evm and @x402/mcp. This is the piece that makes the product possible rather than merely convenient. A dollar per call is far below what a checkout, an account and an API key can justify collecting, so without machine-native payment the honest options were a subscription nobody wants or giving it away. The @x402/mcp binding matters specifically: it puts the payment exchange in the MCP meta layer instead of in front of the transport.
• The Coinbase facilitator, for verification and settlement. We sign the EIP-3009 authorization and never run settlement infrastructure of our own.
• USDC on Base, mainnet and Sepolia. Settlement cost small enough that a $1 call is not dominated by the cost of collecting it, and a testnet that behaves like the real one so the money path could be rehearsed for free.
• @modelcontextprotocol/sdk, for both surfaces. Being an MCP server and an MCP client in one process is what lets the bridge sit transparently in the middle.
• viem for the wallet, Node 22 and TypeScript throughout, Fly.io for the engine, and npm so the quickstart is npx and no checkout.

Four things that cost real money to get wrong. All are written down in the repo's wire contract, because each one was a trap we had to find rather than something the documentation warns you about:

• The payment timeout must sit well above 180 seconds. Every x402 example uses 60. Nine frontier model calls take longer than that, so copying the example expires the EIP-3009 authorization mid-flight, after the expensive work has already succeeded and while the caller is still owed a panel.
• Build against x402 v2, the scoped packages, never the unscoped v1: incompatible wire format. We pulled the facilitator's live /supported response to confirm which it speaks, and two corrections fell out of that. The endpoint is not open (it answers 401), and it serves v1 and v2 side by side, which means such a check can confirm v2 is available and can never confirm you are using it. Our boot check filters on version accordingly.
• Never hand a zod 4 schema to anything under the x402 packages. They pin zod 3, and the schema objects are not interchangeable across the major version.
• Register no recovering onPaymentResponse hook. It signs a fresh authorization and re-runs the whole call, which is a second dollar and a second set of nine model calls, for one panel.

One thing that is notably hacky, in the sense of being the deliberate answer to a problem with no clean one. The output form is chosen by asking whether stdout is a terminal. An agent shelling out to the CLI gets a parseable envelope without being told to ask for one; a human gets a rendered panel. It surprises everyone the first time they pipe to less, so --panel and --format name the form explicitly.

Tests drive the built binary as a real subprocess with piped stdio, because the failures that actually matter here only appear at a process boundary: a stray byte on stdout corrupting the JSON-RPC stream, a panel truncated through a pipe. The suite needs no network. The backend leg runs against a stand-in MCP server on loopback, so both legs are exercised over real transports without depending on a deployment being up, with the tests that hit the live one behind a flag.