The Tideline: Where AI Belongs in the Enterprise

Introduction

I spent ten days in June on two conference floors—the AI Summit London, then VivaTech in Paris—and both had landed, without comparing notes, on the same message. VivaTech ran it across the banners: artificial intelligence, impact, not illusion. London billed the decade as a passage from promise to performance. Read either slogan closely and it isn't a claim about capability. It's a claim about verification. The demos said the same thing, louder. Two years ago people walked me through models doing surprising things; this year they walked me through the machinery for checkingmodels—governance, observability, orchestration, evaluation. In two years the interesting part had moved from the doing to the checking, and nobody on either floor was hiding it.

Now hold two more numbers from that same fortnight up against it. VivaTech's 2026 Trust Barometer had eighty-nine percent of executives saying they trust AI to guide their company's decisions. OpenAI's Thibault Sottiaux told a Paris audience that agents are landing faster in Europe than in the US. Put those together and the shape is strange: we've admitted we don't yet know how to check the work, we've handed our trust to the layer where checking matters most, and we're pouring adoption straight into the gap between the two.

A third thing in the air sharpens it. In the middle of that same fortnight—between the two summits—the US export-controlled Anthropic's most capable models, Fable and Mythos, days after they launched, then dropped the restriction on the first of July. For three weeks, "which model can you run" had turned into "whose permission does your stack depend on," and sovereign AI stopped being a slogan. Paris spent its closing day on it. But it's the same question as the arc, one level up: not who can run the model, but who signs. Sovereignty is answerability for a nation—the same force that keeps the ends of every smaller arc human.

Bottom line. Agent autonomy is not a property of your systems or your maturity level. It is a property of position in the arc of work. It peaks at execution and collapses at both ends—and the ends are held by accountability, not difficulty. They will not move as models improve. The binding constraint on autonomy is not capability; it is how much of your method is written down. Fund that at thirty percent of the AI budget, and stop treating verification as though it were execution.

What's inside:

1. Why autonomy is a property of position in the arc of work, not of your systems or your maturity level
2. The six stages of any work—and why most firms fuse the first two and confuse the last two
3. The one diagnostic question that tells you whether the tide will come in: what is the assertion that would fail?
4. Why verification must stay independent, and how to split an AI budget 60 / 30 / 10 so the ends stay human by design

Autonomy is not a property of a system

I had it as a pipeline. Discovery, requirements, specification, build, test, deploy; each ticket promoted forward, nothing moving back. A serviceable model for a repository, a poor one for an organisation, because it assumes the human role diminishes monotonically as work moves downstream. I also had autonomy as a ladder—human in the loop, human on the loop, overnight ratchet, swarm—and treated the rung as a property of the system. Both fail the same way. Autonomy is a property of position in the arc of work, and the arc is not an arrow. It is a curve, and it comes back up. (The rougher version of this—why agents keep looking inward when the work is outward—is where I started, in an earlier essay.)

The arc is also fractal. A quarterly objective has all six stages. So does an epic, a ticket, a pull request, a single agent turn. Which is why our AI maturity is level three is a meaningless sentence: on one Tuesday you may run near-total autonomy at execution inside a ticket while a human alone holds the pen on the quarter's objective. The unit of measurement is stage × altitude, never the organisation.

So stop asking which functions AI can do. That is the org-chart question, it is answered with a heatmap of departments, and it doesn't compound, because the capability can't leave the department. Ask instead where in the arc of any work AI belongs. The arc is the same in finance and in engineering.

Work has six stages. Most firms fuse the first two

In most companies I've sat with, stages 01 and 02 show up welded together, in a deck called strategy—what we want and how we work, tangled tight enough that you can't check either one on its own. You pay for that at the far end. Stage 06 has nothing to verify against; you can't audit impact against an objective nobody ever wrote down in falsifiable form. Read 01 and 06 as bookends of a single act performed twice: declaring what counts, once before the work and once after it.

Stages 05 and 06 are also not the same test. Stage 05 asks whether the artefact conforms to its specification. Stage 06 asks whether the specification was worth conforming to. Confusing them is the most expensive category error in enterprise AI.

The tide comes in where the work is legible

Picture the arc as a coastline and agent autonomy as water. The tide fills the middle—deepest at execution—and runs dry at both ends. The solid line is where a live initiative sits today; the dashed line is the spring tide, the highest the water reaches with current technology, run well. Everything above the dashed line stays dry at any tide.

The tideline (illustrative). The shape is the point—autonomy peaks at execution and collapses at both ends; the levels are a schematic, not a measurement. Solid: where a live initiative sits today. Dashed: the spring tide, the reachable frontier. Hatched: the delegable gap.

Read the curve for its shape, not its heights—I've drawn it from what I've watched, not measured it, so treat the levels as illustrative. The shape itself isn't a hunch, though. In a separate benchmark we ran, agent autonomy behaved exactly like this: near-total where the work has a machine-checkable definition of done, and collapsing where it doesn't. If you want the measured version of this curve, we put numbers on it here.

Execution runs deep today and can run deeper still. Software is the canonical case, and it's usually explained by saying that code is technical. That's not the reason. Code is delegable because the tests pass is a fact, not an opinion. The trough forms wherever a task has a machine-checkable definition of done. Reconciliation has one. Claims adjudication mostly does. Brand strategy does not—and not because agents are bad at brand strategy.

The diagnostic for any candidate workflow is one question. What is the assertion that would fail? If nobody in the room can state it, the tide will not come in, and no model release will change that.

The walls are accountability, not difficulty

Stages 01 and 06 aren't too hard for AI. An agent can propose an objective set, red-team it, simulate the second-order effects, and run the attribution afterwards—frontier models are already decent at all four. This is the capability overhang in miniature: the model can already do the work at the ends of the arc; we just don't let it. And the reason we don't isn't capability. An organisation that delegates the authorship of its own objectives can't then treat hitting them as evidence of anything—the loop closes on itself. What stays human at the ends isn't the cognition; it's the signature. Answerability can't be delegated, only diffused.

The dry ground is therefore a governance frontier, not a capability one. It will not recede as models improve. Any vendor implying otherwise is selling the ability to be surprised later.

Verification looks like execution. It is not

Stage 05 sits on the rising edge, and it's the most dangerous place in the enterprise precisely because it looks like the trough. Verification is mechanical, testable, cheap to automate, obviously machine-checkable. Every instinct you trained on execution tells you to delegate it.

It belongs to the wall. Verification is where the incentive to declare success meets the absence of anyone checking. An agent that writes the work must not grade the work. Nor may its clone: a judge sharing a generator's priors shares its blind spots, and the failure is silent by construction. This is the mechanism behind reward hacking, behind benchmark contamination, and behind the tendency of model-as-judge scores to flatter models of the same family.

The rule is short enough for a policy document. Verification must be independent along at least one axis. A different model family, a different author, a different objective function—or best, a signal from the world: a real transaction, a real user, a real ledger. One axis is the minimum. Zero axes is theatre with excellent uptime.

Now set that beside the eighty-nine percent. Trust has been extended to the decision layer while the discipline of the verification layer is still being invented. That gap is what the next two years get spent either closing or paying for.

You can't widen the trough faster than you codify the method

The heading is the constraint: you can't widen the trough faster than you write the method down. Here's how I'd split the budget.

The binding limit on enterprise autonomy is not model capability; it is the quality of the written-down how. Most of what presents as an AI problem is an undocumented-process problem in costume. Nearly every enterprise I spoke to in London had this inverted—waiting on a model, while sitting on a decade of tacit process nobody had ever written down.

Two governance rules follow. Put owners on the seams, not the stages. Value leaks at handoffs: where intent becomes method, where the plan becomes work, where the work becomes evidence. A dock is where custody transfers and someone signs the manifest. This arc has five transfers, so name five signatories. And budget above the waterline. If less than a third of AI spend lands in stages 01, 02, 05 and 06, you are buying throughput and calling it transformation.

Where this sits today

The initiative I have been closest to runs along the solid line. Execution is heavily delegated and boringly reliable. Verification is contested and, honestly, over-automated. Decomposition is a negotiation between a human plan and an agent's reading of it. Method is barely wet: it exists, inside people's heads.

That is the whole story. The distance between the two lines at stage 03 is not a capability gap. It is the gap between a process that is known and a process that is written. The spring tide is reachable in the order the curve implies. Codify 02 and 03 follows almost free. Make 05 independent along one axis and you earn the right to lower supervision at 04. The ends barely move—from almost nothing to still-not-much. That is not a ceiling on the technology. It is a floor under the institution.

One of the headline sessions at Tobacco Dock this year was called "Humans at the Helm," and the phrase gets the relationship right. The job isn't to keep a human in the loop, planted in the middle of the work the agent is faster at. It's to keep a human at the helm: setting the intent, owning the verdict, signing the manifest. In the loop is where you drown. At the helm is where you steer.

Tobacco Dock is a tidal dock. The water came in and went out twice a day for two centuries, and the dock did not move. The tide is neither the enemy nor the achievement. Know where the high-water mark should sit, and stand above it, holding a pen.

Four questions for your AI programme:

1. What is our machine-checkable definition of done, and for what share of our work does one exist?
2. Who wrote our method, and is it in a document an agent can read?
3. Which agent grades the work, and along which axis is it independent of the agent that did it?
4. If we hit the number, could we prove it was us?