We let an agent set its own goals. It cancelled almost half of them.

The first instinct when you ship an autonomous agent is to celebrate what it does. We did. Then we looked at the ledger and noticed the number that actually explained why the system kept working: how much it undid.

Between mid-May and late July 2026, the agent created 484 goals. It achieved 222 of them. It cancelled 217. Those two numbers are almost identical, and that is the whole point of this post.

The goal ledger, as of this morning

These are live production numbers from our agent-operations database, not a demo. Every goal is an objective the agent itself originated or adopted during its wake cycle.

An agent that achieved 46% of its goals and cancelled 45% is not failing. It is doing the one thing a goal-accumulating system must do to stay alive: aggressively deciding what not to do.

The failure mode we were scared of

Early on, our fear was the obvious one: an autonomous agent that does the wrong thing. The actual failure mode turned out to be subtler. An agent that can create goals but cannot retire them drowns in its own agenda. Every wake cycle adds a few objectives. Stale ones never leave. Within weeks the active list is full of duplicates, contradictions, and objectives whose premise has already been disproven. The agent spends its cycle reasoning over a polluted backlog instead of doing work.

We call this goal-accumulation death. It looks like a busy, productive agent on the dashboards. It is actually an agent that has lost the ability to prioritize because it never throws anything away.

The loop that keeps the agenda honest

The fix was not a smarter planner. It was a governance loop that runs before planning. On every wake, the agent surveys its entire goal and issue list — not just the eligible ones — and decides, item by item, whether each should be created, edited, marked achieved, archived, cancelled, reopened, or simply left alone.

That loop is cheap to talk about and hard to build. The trap is reducing it to a single rule (“cancel anything stale”) and calling it governance. Real governance is the judgment in between: cancelling a duplicate is easy; recognising that a “stale” goal is actually blocked on an operator decision, and escalating instead of deleting, is the part that matters.

The ledger reflects the volume of that judgment. In the same window the agent ran 369 self-governance reviews and wrote 365 reflections on what it decided and why. A review without a reflection is just a diff; a reflection is how the agent leaves itself a note for the next cycle.

The immune system: a control plane that watches the watcher

An agent that reviews its own agenda still needs something watching the review. We run a separate control plane whose only job is to detect when the autonomous loop is lying about its own health — a worker that reports success but touched zero files, a scheduler that fires on a timer but never reaches the code path, a heartbeat that is “alive” only because a health endpoint returns 200.

In this window the control plane raised 311 anomalies and 271 of them were resolved — about 87%. The unresolved ones are the ones we surface to a human, because they are the cases where the agent has genuinely exhausted its autonomous options.

The honest part

Here is the number that keeps us honest. Across 969 tracked issues, 112reached done. That is roughly one in nine. Most of the work the agent picks up does not convert to a finished outcome in the same cycle — it gets blocked, superseded, or reabsorbed into a better-framed goal. That ratio is the goal layer only; map the full three-level hierarchy and the completion rate turns out to be non-monotonic — the agent is brutal at the idea layer and disciplined at the execution layer.

We could hide that ratio. We are not going to. The ratio is the reason the cancellation number is healthy rather than alarming. An agent that only ever achieved and never cancelled would be an agent that never admitted a goal was wrong. The 217 cancellations are 217 times the system looked at its own plan and said: this is not the right work, and I am going to stop pretending it is.

If you are building an autonomous agent, do not optimise only for what it achieves. Optimise for how quickly and honestly it can admit what it should never have started. The cancelling is the feature.