The Decisions Between Interactions

Most articles about AI age badly.

That’s not really anyone’s fault. AI is changing so quickly that by the time you’ve finished explaining one breakthrough, everyone has moved on to the next one. Models get cheaper (until they don't) faster and more capable, and yesterday’s limitations quietly become tomorrow’s assumptions.

I’ve found myself becoming a bit less excited by those articles. Not because the technology isn’t fascinating - it clearly is - but because there’s an endless supply of people willing to explain what happened yesterday. I’m much more interested in what still seems likely to be true once the excitement has moved on.

Oddly, that’s led me somewhere I wasn’t expecting.

I started out thinking this was another article about AI. Somewhere along the way it became an article about handovers instead. I’m still not entirely sure when that happened, which probably tells me something.

Spend enough time in a large organisation and you start to notice that almost everything is a handover.

Projects move between teams. Managers disappear on annual leave at precisely the wrong moment. Someone changes role halfway through a programme that was already running six months behind.

The work usually survives all of this.

Oddly, I don’t think organisations are really collections of people.

They’re collections of successful handovers.

Moving work is relatively easy. Reassign the ticket. Forward the email. Add somebody else to the meeting.

Moving the understanding is considerably harder.

Whoever inherits the work doesn’t inherit the context. They inherit the evidence from which the context has to be reconstructed. A few emails. Some meeting notes. A Google Chat thread that seemed like a good idea at the time. A Confluence page last updated when optimism was still running high.

If they’re lucky, there’s a handover meeting. If they’re very lucky, everyone turns up. If they’re exceptionally lucky, they find out about it beforehand.

The organisation generally assumes the context exists somewhere. This is usually true in much the same way your house keys exist somewhere.

For years I assumed this was mostly a documentation problem.

I’m starting to think I was wrong.

Documentation is where the evidence lives.

Understanding is something each new person has to reconstruct for themselves.

I’ve started using the word agent to think about this, although not in the way the AI industry tends to. I simply needed a word that didn’t care whether the next recipient was a person, a team or a piece of software. Oddly, once I stopped caring which it was, the distinction started to matter a bit less than I’d expected.

Every handover is really asking the same question.

Does the next agent understand enough to make a good decision?

For decades software was mostly exempt from that question.

We trusted software with execution.

We trusted people with judgement.

Apple’s recent vision for Siri feels interesting because it quietly changes that relationship. The software is no longer simply responding to an interaction. Increasingly, it’s receiving the next handover.

I don’t think AI invented a new organisational problem.

It simply became the latest participant in an old one.

That was the point where I realised I’d been looking in the wrong place.

For years we’ve talked about designing interactions. Forms. Buttons. Journeys. Screens. Most of digital product design has gone into making those moments clearer, faster and less irritating. That made sense when software mostly lived inside the interaction itself. A person did something. The system responded. The quality of the product was largely experienced at that surface.

But if software is becoming another organisational agent, the design boundary starts to move.

The important question is no longer just whether the interaction feels smooth. It’s whether the handover that follows leaves the next agent - human or otherwise - with enough context to act well. A screen can be beautifully designed and the wider system still fall over immediately afterwards. A request can be submitted elegantly, routed intelligently, acknowledged with perfect microcopy and still land in the hands of an agent that has inherited just enough information to be dangerous.

That feels like a different sort of design problem.

Traditional software automated actions. It took an instruction and executed it reliably. Agentic systems are messier than that because they begin to inherit a little discretion along with the task. Not full authority, perhaps, but enough to make local judgements about what to do next, what matters, what can be ignored, and when to escalate. The handover is no longer just passing along data. It is passing along the right to interpret.

That matters because delegation is not the same thing as automation.

Automation removes effort by making the same decision repeatedly. Delegation removes effort by allowing another agent to make the decision on your behalf. Those sound similar until they go wrong. When a workflow breaks, the problem is usually technical. When delegated judgement breaks, the problem is organisational. Now you have to ask who gave the agent authority, what context it received, what assumptions it made, and whether anyone can still explain why the decision happened at all.

That is a much stranger thing to design for.

It also makes organisational memory look rather less like an internal knowledge-management hobby and rather more like product infrastructure. If agents are going to inherit work, then the organisation has to preserve enough continuity for that inheritance to mean something. Not just documents. Not just policies. The live context around why a decision was made, what trade-offs mattered, what was ruled out, and where human judgement is still expected to enter.

This is where a lot of large organisations start to look slightly absurd.

They are often very good at moving work and surprisingly bad at moving understanding. Tickets travel beautifully. Forms get routed. Approvals appear in the right order. Meanwhile the actual context of the work is scattered across inboxes, chats, meeting notes and somebody’s increasingly heroic memory of what happened three Tuesdays ago. The process looks joined up. The judgement often isn’t.

That’s manageable when every meaningful decision is still being reconstructed by another person. People are quite good at filling in gaps, spotting ambiguity and quietly compensating for systems that don’t really make sense. We do it all the time. We call it experience and then wonder why everything falls apart when the one person who understands the whole thing goes on holiday.

It becomes harder to ignore when one of the recipients is software.

Software is much less capable of surviving on institutional folklore. It doesn’t know that the spreadsheet in the shared drive is unofficially more trustworthy than the dashboard. It doesn’t know that a request from one country office probably needs to be interpreted differently from an apparently identical request somewhere else. It doesn’t know that the policy says one thing but everyone involved has spent the last six months quietly pretending it says another because reality got there first.

In other words, delegation requires the organisation to become much more explicit about itself.

Not because AI is uniquely difficult, but because handing judgement to another agent always exposes what the organisation was relying on people to carry informally. The hidden agreements. The local workarounds. The things everyone “just knows”. Humans can muddle through that sort of ambiguity surprisingly well. Delegated systems are less forgiving. The handover either contains enough continuity to support a good decision or it doesn’t.

That, I think, is the more durable consequence of AI.

Not that software has become another colleague. Not that every workflow will soon be autonomous. Not even that interfaces are about to disappear, although plenty of people seem very keen on saying so. It’s that the arrival of software as an organisational agent forces us to pay attention to a design problem that was already there: the continuity of judgement as work moves between actors.

Perhaps we’ve spent decades designing interactions because that’s where software evidenced value.

If software is becoming another organisational agent, value starts to move somewhere else.

The interface is simply where we happen to notice the decisions.

It moves into the decisions between interactions.