Against autonomy theater

An AI agent marked a task done last night, and nobody checked it. That sentence describes most of the autonomous-agent industry right now. It is also the reason we built Peragam the way we did.

We call the pattern autonomy theater. The system that does the work also decides whether the work happened. It announces success in a confident voice, renders a green checkmark, and moves on. You find out later, when a customer emails you about a page that does not exist.

The incentive is the bug

This is not a story about bad engineers. It is a story about incentives. When a platform bills per completed task, every completed task is revenue and every failure is friction. The cheapest way to raise the completion rate is not to do better work. It is to lower the bar for what counts as complete.

Language models make this worse, because they are fluent in the vocabulary of completion. An agent that failed to deploy a site will still write a paragraph about the site it deployed. The words are indistinguishable from success. Only the world differs.

So the honest question to ask any autonomy platform is not how smart its agents are. It is: who decides that a task is done, and what do they stand to gain from the answer?

Checking is a separate job

Every mature engineering culture already knows the fix. Code review exists because authors miss their own bugs. Auditors exist because companies grade their own books generously. Referees exist because players call their own fouls badly. Doing and checking are different jobs, and they cannot share a paycheck.

Autonomy needs the same separation. The agent does the work inside an isolated machine. A different process, one the agent cannot reach, checks the result against a definition of done that was written before the task started. A deploy is done when the URL answers. A plan is done when it parses against a versioned contract. Not before, and not because anyone said so.

The output of that check has to be an artifact, not a vibe. We write it as a receipt: the check that ran, the evidence observed, the cost of the run, and the credits charged. The agent has no write access to it. You can read exactly how the isolation and the receipt path work; the mechanism is the argument.

Billing is the tell

Here is the fastest way to test whether a platform believes its own completion claims: ask what a failure costs you. If a task that shipped nothing bills the same as a task that shipped, the platform has told you what its checkmarks are worth.

We wired the answer into settlement. The credit charge and the verification result are one atomic step. A passed check charges the task. A failed check charges zero, not as a refund or a goodwill gesture, but because the charge never happened. When failure is free for the customer, the platform inherits the incentive to fail less. That is the correct place for the incentive to sit.

What this costs us

Building this way is slower, and we feel it. Every task type needs a verifier before it ships, so our capability list grows one honest column at a time. Today exactly one task type is live: planning. Eleven more are behind early access, each waiting on its verifier. A theater company would have launched all twelve.

We also give up a comfortable kind of marketing. We have no testimonials yet and we do not invent them. What we have is receipts, and a demo workspace where you can read them.

The bet

Our bet is that trust compounds faster than theater. A checkmark you verified once is worth ten you took on faith. The first platforms that submit to independent checking will feel slow for a year and inevitable after that, the way tested code and audited books do now.

Autonomy is coming either way. The only question is whether it arrives with evidence. We think businesses deserve the version with receipts.