A lot of the early AI discussion was about capability. Can it write this, summarise that, produce code, build a page?

We know by now that it often can.

What interests me more is what happens when AI starts touching the process around that output. It selects information, classifies it, updates files, configures systems, deploys things and monitors what happens afterwards. In more advanced workflows it also keeps context: earlier decisions, project history, constraints, assumptions, things it has learned along the way.

Useful, obviously. But it changes where the risk sits.

If AI writes a bad paragraph, the mistake is in the paragraph. Someone may catch it, someone may not, but at least you know roughly where to look.

If it stores a wrong assumption as project context, things get more interesting. The next analysis may use it. So may the next draft. Another agent may retrieve it two weeks later and treat it as something already established.

The error has moved upstream.

A mistake no longer lives in one output. It can live in everything produced after it.

Keeping context is not the same as keeping it true

Storing context itself is getting rather easy.

Keeping it current is not.

Projects change in very ordinary ways. A budget limit that was firm in March gets renegotiated in June. A supplier limitation disappears. Something said during an exploratory call turns out not to have been a decision at all. And sometimes yesterday’s confirmed decision is simply no longer today’s decision.

The document may not have changed. Reality has.

An AI system working from that document will happily continue from there.

That is one of the reasons I am wary of treating “memory” as a feature in itself. Memory is only useful if you know what exactly has been remembered.

Take a fairly innocent sentence:

The client wants X.

Fine. Except: who said that? Was it the client? Was it my interpretation? Was it a suggestion that survived three meetings without ever actually being approved? When was it recorded, and is it still current?

A context system can preserve all of that. But only if we bother to preserve status and provenance with the statement. Otherwise a hypothesis and an approved decision may look almost identical when they are retrieved later.

That gets more important once several agents work from the same context. Shared memory also means shared mistakes.

Neatly synchronised, even.

I want to know what status something has

For practical work, I find four levels useful:

• Raw output — generated, not validated.

• Working hypothesis — credible enough to investigate or work with, but not confirmed.

• Confirmed decision — explicitly approved by whoever has the authority to decide.

• Current project truth — confirmed, traceable and still valid now.

The difference between the last two looks small. It isn’t.

A decision can have been completely real and still have expired since.

That means context cannot only accumulate. Things need to be superseded, corrected, demoted or simply marked as no longer current. Otherwise you eventually have an excellent memory of several versions of reality at once.

I would also want any important item to carry at least a source, an owner and some indication of validity.

Nothing exotic. Just enough to answer three basic questions: where did this come from, who gets to decide whether it is right, and do we still believe it today?

Then there is a second question

Even that is only half of it.

An unconfirmed hypothesis is not automatically useless. I use hypotheses all the time. You can analyse one, model a scenario around it or use it to prepare a draft.

The problem starts when the system forgets that it was a hypothesis.

There is a difference between allowing uncertain information to drive an analysis and allowing it to change something outside the analysis.

A possible budget figure can be perfectly useful for scenario planning. I would rather not have an agent publish it on a website.

An interpretation of a contract clause may be worth investigating. That does not make it a suitable basis for sending a binding response.

A probable technical cause can drive a test. It should not necessarily drive a production change.

So there are really two questions in the workflow:

How certain are we about this information?

And what are we allowing it to do?

For me, that is closer to the real model:

information status × action risk → required gate

The more consequential the action, the more the status of the information underneath it matters.

Websites are becoming part of that same problem

This also changes how I look at websites.

They remain interfaces for people, obviously. But they are increasingly read by systems as well: search engines, AI assistants and agents that extract information and reuse it somewhere else.

So a website is gaining another function. It becomes, at least partly, a machine-readable source of record.

That makes stale information more than an untidy content problem.

A service page nobody has looked at for two years may still be crawled today and treated as the company’s current position. The machine does not know that everyone internally stopped believing that page eighteen months ago.

There is no clever GEO trick that solves that.

The source simply has to be right.

Which brings us back to the same fairly unglamorous questions: what is current, what is authoritative, what replaced what, and who owns that information?

Someone still has to decide

I do not think every company suddenly needs an “AI governance framework”.

Especially not a forty-page one.

But once systems start maintaining their own context and taking actions from it, somebody does need to decide what they are allowed to treat as true.

May an agent add something to memory? Probably.

May it decide by itself that its own interpretation has now become project truth? Different question.

May it work autonomously from a hypothesis? Sometimes.

May that same hypothesis trigger a publication, deployment, contractual commitment or another external action? Again: different question.

That distinction is becoming more important as the models improve, not less.

Because better execution does not solve bad context.

It simply executes it better.

The more AI can do, the more carefully we have to define what it is allowed to believe — and what it is allowed to do with that belief.