AI agents have made code temporary: written for one task, then thrown away. The obligation to show how a decision was made did not disappear with it. Technology changes. Models change. The record has to outlive both.
Software engineering rested on one premise: a person works out how a decision should be made, writes that reasoning into code, and revises the code by hand when the world moves. The code was the durable record of the thinking. You could read it years later and see why the system did what it did.
Agentic systems turn this around. The model does the reasoning. Code becomes a tool it writes when it needs one and discards when the task is finished. Nothing is wrong with that — it is genuinely faster, and it handles situations no one wrote a rule for. But the durable record went with the code.
The most durable idea in that paper is not about agents at all. It is that software has never reduced complexity — it has only moved who carries it. Seen that way, the question to ask a supplier in 2026 is not whether their agents are clever. It is who is holding the problem when something goes wrong.
You bought a program and carried everything around it: the servers, the updates, the integrations, the nights when it stopped. The supplier delivered and left.
The supplier took back the servers and the updates. You kept the harder half: deciding how it should be configured, and what the software should be told to do.
The supplier now takes back much of the deciding too. What cannot be handed over is responsibility. In European law the organisation using the system still answers for the outcome.
Here is the problem the new paradigm creates, stated plainly. If the reasoning lives in a model and the code it wrote is thrown away when the task ends, then the decision happened and nothing durable remains of it. The system worked. Ask it in three years why it worked, and the best you have is a conversation log.
For a consumer product, that is a fair trade. For a carbon border declaration, a sustainability disclosure, a security incident, or any system European law treats as high-risk, it is not a trade you are allowed to make. The obligation does not soften because the architecture changed. The shift is real. The duty to show your reasoning did not disappear — it moved.
A high-risk system must be built so that events are recorded across its whole working life. A reasoning loop that leaves no structured trace has nothing to record.
A person cannot meaningfully oversee a decision whose basis was discarded before anyone looked at it. Oversight is something you build, not something you declare.
Where automated processing significantly affects someone, they are owed meaningful information about the logic involved. "The model decided" is not that information.
Incidents must be detected, handled and reported on a legal clock. Reconstruction needs a record written at the time, not a reconstruction written afterwards.
The answer is not to refuse agents. It is to require that every action an agent takes produces its own evidence as a result in its own right — not a log written beside it, but part of what the work returns. The thinking can be temporary. What it leaves behind is built to last.
Every agent returns the same three things alongside its answer: what it did, in an entry that cannot be edited afterwards; the result in a form a regulator's system can read; and where each piece of information came from.
Work runs as a cycle. One agent proposes, a second one checks, and the cycle repeats until the result is right or a limit stops it. Two limits always apply: what it may spend, and how far it is trusted to act.
Authority is checked where the action actually happens, not once at the start of a session. An agent that has not earned the right to do something does not do it — and the refusal is kept as carefully as the approvals.
The same measurements that show how far agents have come also show where they stop. On the benchmarks the field takes seriously, the best systems still fail a meaningful share of ordinary engineering tasks that a person has verified. Groups of agents working together degrade in ways that testing a single agent never reveals. Any supplier who tells you otherwise is showing you a demonstration, not a system.
We would rather build for that than around it. The checks, the limits and the kept refusals exist because the ceiling is real. A human bearing responsibility is part of how the system is built, not a sentence in the contract. Our products give people back time and judgement. They are not there to replace the person answering for the decision.
If this shift is real — and we think it is — then choosing a supplier stops being a comparison of features. These three questions separate a system that will hold up from one that demonstrates well. They work on us as readily as on anyone else, which is why we publish them.