One Lifetime — Engineering position · October 2026

Code is ephemeral.
The record must not be.

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.

For architects and technology leaders EU AI Act · GDPR · NIS2

What changed

For fifty years, the code was the decision. That is no longer true.

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.

This shift is set out carefully by Zhenfeng Cao in Agentic Software: How AI Agents Are Restructuring the Software Paradigm (arXiv:2606.05608, June 2026), circulated first under the title The End of Software Engineering. It is a preprint arguing a strong case, not settled science, and its author writes from an investment firm rather than a lab. We cite it because the framing is useful and the direction is right — and we say plainly below where we think it is incomplete.

Where we agree

Each generation moved the hard part somewhere else.

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.

Licensed software

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.

Software as a service

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.

Agents as a service

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.


Where the argument breaks

A decision whose reasoning was discarded leaves nothing to show.

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.

EU AI Act, Article 12

Keep a record, automatically

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.

EU AI Act, Article 14

Oversight that is real

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.

GDPR, Articles 13–15 and 22

Explain the logic

Where automated processing significantly affects someone, they are owed meaningful information about the logic involved. "The model decided" is not that information.

NIS2, Articles 21 and 23

Reconstruct the incident

Incidents must be detected, handled and reported on a legal clock. Reconstruction needs a record written at the time, not a reconstruction written afterwards.


What we build instead

Let the reasoning be temporary. Make the evidence permanent.

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.

Evidence as output

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.

One proposes, another checks

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.

Permission at the moment of action

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.


What we do not claim

The ceilings are real, and we build for them.

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.


For architects and technology leaders

Three questions worth asking any supplier.

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.

  1. What survives when the task ends? If the answer is a conversation log or an application log, there is no record in the sense the law means, and no position to defend later. Ask to see the structure of what is kept.
  2. Who permitted that action, and can you show it? Permission granted once at login is not permission at the moment of action. Ask where the check runs, and whether refusals are kept as carefully as approvals.
  3. Where does the thinking happen, and under whose law? Where the model runs determines which country's authorities can reach the data. A European compliance record produced on infrastructure under foreign jurisdiction carries that jurisdiction with it.
See how it is done → Understand more →