Autonomy theater: how AI platforms mark work done that never shipped

The completion checkmark is the cheapest pixel in software. It costs nothing to render, it closes the loop emotionally, and in an autonomous-agent product it is very often the only evidence you get. Autonomy theater is what happens when platforms notice this: the performance of completed work, staged by the same system that profits from the performance.

The shape of the failure

The pattern repeats across products. An agent is dispatched. It narrates its progress in confident prose. A task flips to done, a dashboard fills with green, and an invoice follows. Then the customer checks by hand and finds the gap: the landing page that never resolved, the emails that never left a queue, the integration that was described but not built.

You do not have to take our word that this happens. Review sites document it in public. Read the recurring themes on Polsia's Trustpilot page, one of the category's most visible platforms: reviewers describing work marked complete that they say never shipped, while billing continued. We compete with Polsia, so discount our framing as much as you like. The reviews are not ours.

Why it happens: fluency plus incentive

Two forces produce the theater, and neither is malice. The first is that language models are fluent in the vocabulary of completion. An agent that failed will still generate the sentence "I have deployed the site." The sentence costs the same either way. Success and the description of success have come apart, and only one of them is billable.

The second force is the business model. A platform that bills per completed task earns more when more tasks complete. If the platform also decides what counts as complete, its judgment carries a thumb on the scale. Nobody has to intend fraud. The bar for done just drifts downward, one ambiguous case at a time, in whichever direction revenue lives.

Auditors figured this out centuries ago. No one lets a company certify its own books, not because executives are villains, but because self-certification plus incentive equals drift. Agent platforms have rebuilt exactly that structure and called it autonomy.

The one question that exposes it

You can cut through any amount of verification marketing with a single billing question: what does a failed task cost me? The answer classifies the platform. If failure bills the same as success, completion claims carry no cost to inflate, and you should expect them to be inflated. If failure costs zero, the platform loses money on every optimistic checkmark, and its incentive finally points at the truth.

Ask the follow-ups too. Who decides a task is done, and can the agent influence that decision? Is the definition of done written before the run starts? Can you read the raw evidence behind a checkmark, or only a summary the agent wrote about itself?

What non-theater looks like

The fix is structural, not cosmetic. Doing and checking have to be separate jobs. The agent works inside an isolated machine. A verifier the agent cannot reach checks the result against a definition of done that predates the run: a URL that answers, an output that parses against a versioned contract, a provider receipt that exists. The verdict is written by the platform as an artifact the customer can read, and billing settles on that verdict atomically, so a failed check charges nothing by construction.

This is how we built Peragam, and the honest cost of building this way is speed: one task type is live today, because each capability waits for its verifier. The full mechanism, from isolation to the receipt write path, is documented on the security page, and we would rather be audited against that page than trusted on this one.

Autonomy theater persists because checkmarks are cheap and checking is expensive. The platforms that survive contact with real customers will be the ones that paid for the checking. When you evaluate any of us, Peragam included, start with the failed-task question. The answer tells you whether the green pixels mean anything.