When the Machine Starts Pedalling on Its Own

For fifteen years I built software on one assumption I never thought to question. You build an interface, a person comes to it, and they operate it: clicking, searching, filling forms, either to pull up some data or to set off an action an engineer had wired in advance. The software never decided anything on its own. It waited to be operated, and it only ever did what it had already been told to do.

I shipped hundreds of those screens, seven years of them at Qonto, for more than 600,000 businesses. The human always went first. That was simply what software was.

Think about how much care we have poured into that single move. Entire disciplines, UX and UI, exist to perfect the moment a human meets a machine. We argue for hours over the placement of one button, the wording of a label, the number of clicks to a result, the curve of a loading state. A generation of designers has treated the interface as a craft, and rightly so, because making a machine legible to a person is genuinely hard.

Take a step back, though, and the strange part comes into focus. Almost all of that effort went into compensating for the human. The screen was narrow because our attention is narrow. The flow was kept simple because our memory is small. We were never really designing for the machine. We were translating the machine down to a size a person could hold.

I stopped believing the assumption this year. In April 2026, Salesforce rebuilt its platform around a phrase I have not been able to unsee: no browser required. It re-exposed its entire product so an AI agent can call it directly, and described that agent as its new consumer.

It is tempting to read that as the human being written out. I read it the other way. The person is still the consumer. What changed is that a new layer slid in between them and their tools.

Agents now operate the old interfaces, the buttons and forms and dashboards, on the person's behalf. The human is left with a far simpler surface: say what you want, and the layer beneath goes and does it. The interface did not disappear. It moved down a level, and a much simpler one took its place on top.

That is the inversion. For about fifty years, software waited for a human to operate it, screen by screen. The next fifty will not.

It was never about intelligence

Most people describe the AI shift as machines getting smarter. Better reasoning, bigger benchmarks, fewer mistakes. That framing is comfortable because it keeps the human in the same seat: we operate, the machine responds, only now it responds better.

The real shift is not about intelligence. It is about initiative. About who decides what happens next.

What flipped

For forty years the best metaphor for the computer was Steve Jobs's: a bicycle for the mind, a tool that makes a human dramatically faster while the human keeps pedalling. It was the perfect image for the era of direct manipulation, where the machine amplified your effort but the effort, and the steering, stayed yours. The agent breaks the metaphor. It does not wait for you to pedal; it can take the routine stretches of the route on its own.

It helps to see this as three tiers. The bicycle was tier one: the machine amplified you, and you still pedalled. Direct manipulation, the era of the GUI, was tier two: you operated the machine screen by screen, and it waited. The agent is tier three: it holds more context than you can carry, reasons over it, and goes first. Each tier did not so much improve the last as make it invisible.

Two things changed at once, and only their combination matters. First, the machine can now hold the full state of a business at once: every transaction, contract, vendor, deadline, and prior decision. Second, it can reason over that context rather than just retrieve from it. Models that interleave reasoning with action, that decide on their own which tool to call, that plan from a memory store, are shipping, not theoretical.

Put those together and the bottleneck moves. When a system holds the whole picture and can reason about it, the human is no longer the best-placed actor to decide what to do next. For the routine calls, the machine is simply better positioned to go first.

There is an older idea underneath this. In 1945, Friedrich Hayek argued that the knowledge a business runs on never exists in one place. It is dispersed across people, documents, and tools, incomplete and often contradictory, and no single mind can hold it. The interface rationed scarce attention because the context was scattered and any one person could only see a slice. A system that finally aggregates that dispersed context is the first that can spend its effort on deciding, rather than on looking.

This is no longer hypothetical. A frontier lab now ships an assistant whose memory builds a context graph that grows more stateful with every task, and big platforms demo agents that run in the background and act under your direction while your laptop is closed. The capability is arriving from every direction. What is still scarce is the structured context of your specific business, the connected and resolved picture an agent needs before it can be trusted to act, and that is the gap we are closing at Well.

Context is the bottleneck, not horsepower

The easy version of this thesis is wrong, and it took me too long to accept. The naive move is to assume a bigger context window solves everything. It does not. Models systematically underuse information buried in the middle of a large window. More is not the same as better.

Context has to be structured, not just large. A pile of every document a business ever produced is not context any more than a landfill is a library. The value is in the graph: the relationships between a transaction, the contract behind it, the vendor on the other side, and the decision it should trigger. A memory layer is an engineering problem, not a storage problem.

I learned this inside my own company before I believed it about the market. When we put a fleet of AI agents on a problem, the quality of their work tracks one thing above almost everything else: how much real, structured context actually reaches each agent. Compress it to save room, and the output degrades in ways that are obvious only in hindsight. The lesson was not that the models were weak. It was that context, not intelligence, was the binding constraint, even for us.

Two years out

I do not think the operator survives in their current form. Picture an e-commerce founder today. On their phone sits Shopify, Stripe, Mercury, QuickBooks, an ERP, an analytics app. Six logins, six dashboards, six places to check, and the only thing connecting them is the founder. They are the integration layer, carried around in one tired human head.

Within a couple of years, I expect that founder to stop opening those apps, and to clear most of them off the phone. A single conversational channel takes their place. You ask one question about an order, and the system goes to Shopify, checks the payment against Stripe, the cash against Mercury, the books against QuickBooks, and comes back with an answer and a proposed next step. Not six tools you operate. One surface that operates them for you.

This does not mean the tools die, or that you stop paying for them. Shopify still runs the store, Stripe still moves the money, and the subscriptions may well continue. What disappears is the fragmented interface, the six separate logins that each demand a human go first and stitch them together by hand. The engines stay, the agent operates them, and you stop being the integration layer.

There is a deeper reason this is not just another all-in-one. Every all-in-one I have seen eventually hits a wall: it picks a territory, payments or accounting or invoicing, and stops at the edge of it. A conversational surface built with systems thinking, over one unified context, has no such edge. The range of what you can ask and have done is far wider than any single-territory tool can offer, because you are no longer adding features inside a tool, you are composing agents across all of them.

What we still go first on

The question is no longer whether machines will initiate. They already do, in your inbox, your code editor, and increasingly your back office. The question is what humans still go first on. After fifteen years building the other model, my answer is intent, and judgment at the edges.

We say what the business is for. The machine, holding more context than we ever could and reasoning over it in ways we cannot, proposes and executes the path. We stay in the loop where it matters: the exceptions, the irreversible calls, the moments where being responsible is the whole point.

That is what we are building at Well. Not a smarter dashboard, and not a chatbot bolted onto your bank feed. A structured business context complete enough that the machine can act on it, with the human kept exactly where their judgment still beats the machine's. The interface spent fifty years waiting for you to operate it. The next one is already working when you arrive, and the skill that matters is knowing what to let it do.