The agent said done. The next system still shouldn’t trust it yet.

Agents are already doing real things.

Personal assistants like Instinct book flights, reserve tables, buy groceries, and cancel subscriptions. OpenAI documents that its agent can find, contact, and buy from businesses. Claude can act inside a browser. Coding agents like Devin run long sessions, delegate to worker agents, open pull requests, and hand back a result.

Not every agent is fully autonomous, and the vendors are careful to say so. But booking, cancelling, buying, sending, coding, deploying, delegating: these are consequential actions, they happen today, and more of them happen every month.

The first response is vertical guardrails

Watch what builders do about this, because I think they're doing the right thing.

• Coding platforms add tests, review, and CI. Teams put required status checks in front of agent-authored merges. Devin playbooks carry a specifications section and forbidden actions.
• Personal agents add confirmation prompts, takeover modes for sensitive input, per-site allowlists, and safety classifiers that screen each action.
• Agent frameworks add human-in-the-loop interrupts, permission modes, and guardrail layers that trip before a tool call proceeds.
• Payment protocols add signed mandates with budget caps before an agent can spend.
• Marketplaces keep their own evaluators for submitted work.

I expect this to continue. Every serious vertical system will build some form of judgment internally, tuned to its own domain, and it should. A coding platform knows what a good pull request looks like better than any outside service ever will.

Why that still leaves a gap

Here's the question those guardrails don't answer: what happens when the result of that judgment needs to leave the system and be trusted somewhere else?

Two examples, both boring on purpose.

A coding agent finishes a database migration. CI says pass. But the buyer's own billing telemetry says one agreed condition failed. Now three different systems need the same answer: the deploy pipeline needs to know whether to proceed, the billing system needs to know what this work is worth, and a remediation agent needs to know exactly which condition to retry. CI's green check answers none of that on its own, and the agent's self-report answers it least of all.

A marketplace evaluator decides 8 of 10 delivered units passed. Billing needs "$8 earned." The workflow needs "retry units 9 and 10." An audit trail needs "who judged this, against what agreement." The marketplace shouldn't have to invent three different result formats and convince three different systems to trust each one.

The judgment happened. The judgment was probably even good. It just has no form that travels.

The portable-result idea

The chain I keep coming back to is short:

agreement → evidence → judge → Outcome → next system

The important part is not who the judge is. The important part is what the result looks like after the judge is done:

• the judge is named, so a consumer knows whose call this was
• the evidence is bound, so the result points at what it was based on
• the result is explicit, including partial and uncertain, not flattened to a boolean
• earned value is preserved, so 8 of 10 means $8, not "failed"
• the whole thing is signed, so another system can verify it without asking anyone

None of the systems I surveyed for this piece produce that object today. The signed artifacts that do exist in agent land, like payment mandates, authorize an action before it happens. They don't attest to whether the promised outcome actually happened after. Those are different objects.

What Spoolis does and doesn't do here

Spoolis standardizes the result. It records which evaluator produced it, binds the agreement and evidence it was based on, preserves partial, uncertain, and earned value, signs the whole thing, and lets any number of downstream systems verify and consume it independently.

Spoolis does not replace your evaluator. It doesn't prove every real-world fact. It isn't a universal policy engine or an agent runtime. If your CI, your reviewer, or your marketplace evaluator is good, keep it. That's the point of the bring-your-own-judge interface: your judge stays vertical, the result becomes portable.

Keep your judge. Standardize the Outcome.

Why this gets more important

Everything trending in agent systems pushes on this seam. Jobs get bigger, so a single boolean describes them worse. Delegation chains get deeper, so more results cross more system boundaries. Counterparties get more novel, so past trust carries less. Actions get more consequential, and on some machine-payment rails settlement is final with weak recourse, so the check before the action is the whole game.

Every one of those trends makes an unportable judgment more expensive.

Where I land

I don't think the interesting future is one universal judge for agents. I think the interesting future is lots of specialized judges, inside coding platforms, marketplaces, runtimes, and buyer's own systems, producing results that other systems can trust.

That's the layer Spoolis is trying to make explicit.

Notes

Vendor behaviors above come from public documentation: OpenAI's agent help pages, Anthropic's Claude in Chrome announcement, Cognition's Devin docs, LangChain's human-in-the-loop docs, and GitHub's protected-branch docs. Instinct's actions are drawn from press coverage of its private beta rather than first-party docs, and I treat them accordingly. Where an incident has been reported around a personal agent acting before its user expected, I've deliberately not built the argument on it: the pattern matters, not any one story, and I don't claim Spoolis would have prevented any specific incident.