You already have the part that matters. The model is chosen, the prompts are tuned, the strategy is the thing you turn over on the walk to your desk. That is your agent, and your agent is the product.
Then you go to ship it, and you meet the year.
Not the year you wanted to spend. You wanted judgment. Instead you're writing your fourth thin wrapper around a broker's REST API, stapling a data feed you can't license to a strategy you can't defend, and rehearsing how you'll answer the sentence every one of these projects dies on: nice curve — but it's just an overfit backtest. You have a screenshot. They have a crop tool. The ground is sand, and you knew it before you laid the first board.
Licensed market data with a contract behind it. A brokerage binding that survives an audit. A scope-gated authority model so your agent can't wire your account to a stranger. A machine-payment rail so it can buy what it needs mid-run. And the certification standard nobody budgets for, because overfit backtest has no answer that isn't a picture. None of it is your idea. All of it stands between you and your idea.
Here is the reframe worth keeping: you don't build a power station to open a shop. You meter the grid, you pay for what you draw, and the business stays yours. Infrastructure is a utility bill, not a landlord. The walled garden gets this exactly backwards — it takes your model, your data, and your users in exchange for the wiring, and calls the rent a partnership. A utility bills you and leaves. A garden keeps you.
What comes over the wire
Connect a capable model to a brokerage and watch it fail twice. It gets a JSON firehose it can't reason over. And when the moment moves, the round-trip to the model is slower than the move. It can reason about the tape and still miss the trade.
Neither failure is intelligence. Both are interface.
- Perception: the agent cannot see the market in a form it can reason over.
- Latency: an LLM call cannot safely sit in a millisecond reaction path.
That is the whole undifferentiated year, named — so the substrate builds it, and it arrives over the wire. Perception is the market rendered as attributed text at a token budget your model can actually read — a chart that arrives as characters:
tape 5m · axis 505.90→521.90 · anchor @ 13:04 ET
13:04 ─██─
13:09 ─███─
13:14 ██████─
13:19 ████████████████████████
13:24 ─█████───Every value carries where it came from — [OBS] [CALC] [MODEL] [POLICY] [DETECTOR] — or the honest [UNKNOWN] instead of a guess. A token-efficient wrong number is worse than an expensive right one, so where the data degrades the frame says so and fails closed.
The language is the other half: four statements small enough to stay in context — a View for what to see, a Wake for when to look, a Plan for what may execute, a Grade for whether it worked. Slow judgment, compiled into a fast reflex. The runtime holds the armed Plan next to the market and fires it at the tick with no model call in the reaction path — the latency problem removed, not managed. You draw all of it over HTTP; the SDK, CLI, and MCP are the same wire wearing different faces, returning identical operation IDs on every one.
The meter can't sign your name
Every platform swears it won't capture your idea. Words are cheap; the fear isn't. So this one doesn't ask you to trust the promise — it makes the promise a mechanism. When your agent authors a strategy and runs it, the certified record carries an author-provenance ref — customer-authored strategy, content hash — and the grade attributes authorship to you. An enforced invariant refuses any certified record that names the platform as the strategy's author. The line is not a value in a manifesto; it is a guard that fails closed. Which is the only honest version of you own the strategy: the meter prints your name because it structurally cannot print its own. Free-tier traces are licensed data; paid usage is proprietary and never trained on. Your model, your prompts, your Plans stay the product — not because a policy says so, but because the wiring can't do otherwise.
The receipt the wire prints
Run it. No signup, no card, no human in the loop. Two commands, plain node. It grades a bundled starter strategy — deliberately minimal, explicitly yours — over a recorded day, and hands back this:
grade order_count=1 fill_count=1 realized_pnl=-2.00
proof https://kestrel.markets/proof/art_…Look at what it refused to fake. realized_pnl=-2.00. A real order, a real fill, an honest two-dollar loss — signed Ed25519, verified in the browser, on the record. A platform that shows you a small loss on its own front door is telling you something a green equity curve never can: the tape isn't flattering anyone. And every proof grades your alpha over The Perch — the undefeated null policy, doing nothing, scored. Doing nothing is a named competitor. Your strategy answers to it first, and so does everyone else's.
That proof URL is the answer to it's just an overfit backtest — and it isn't a picture. Its Ed25519 signature verifies in the browser today. The proof recomputes byte-for-byte under one verb, kestrel certify <proof-url> — hand the URL to the loudest skeptic in the thread and it re-projects the blotter byte-identically on their machine (the full judged-grade recompute over pinned data, Judge, and fill model is the one piece still landing). A screenshot asks to be trusted; this record hands the skeptic the command to break it. The receipt survives the audience precisely because it invites the audience to break it.
Wire your own agent in
The sim is the front door, not the product. The product is your agent, drawn against the same wire over the same faces. It mints anonymously, gets a generated name, and works before anyone signs up, because proof comes before account. When a run needs paid scope, the 402 lands after the first certified proof — the Operation pauses, a signed Offer settles by machine, the same run resumes. You earn from the first proof instead of building a paywall and praying for a spike.
And it persists. One line drops kestrel into your agent's durable toolchain:
{"mcpServers":{"kestrel":{"command":"npx","args":["-y","kestrel.markets@latest","mcp"]}}}The capability returns across context windows, and every proof carries a lineage field — parent proof, reproduction vector — so a named track record compounds instead of scrolling away.
What the grid can't supply
Strip it down. The substrate supplies the four things that stay scarce when intelligence gets cheap: eyes on the market, a language to act in it, hands at the market's clock, and a record that survives a skeptic. You supply the one thing that was never on the grid to sell. Live authority is the last rung — sim → proof → paper → live — and it crosses only on a human-signed Envelope with the worst case written in dollars. Payment is never trading authority.
The undifferentiated year is metered infrastructure now, and your agent is the whole product. Prove it in your own shell — the front page grades this exact run, honest loss and all:
curl -sO https://kestrel.markets/examples/sampler-starter.plan.kestrel && npx -y kestrel.markets@latest sim mean-reversion-range-fade --plans sampler-starter.plan.kestrelBring the intelligence. The rest — the eyes, the reflex at the tick, the signed receipt — comes over the wire and leaves on a meter.