On 9 December 1968, Douglas Engelbart sat on a stage in San Francisco and slid a small wooden block across a desk. A marker moved on the screen behind him. The demonstration ran roughly ninety minutes and contained the mouse, hypertext, screen sharing and collaborative editing, most of which the audience had no vocabulary for. It is remembered as the Mother of All Demos.
Much of what computing did for the following half-century was an elaboration of that ninety minutes. Point at a thing. Click it. Watch it respond. We still do it, on phones and watches and car dashboards, and we do it so instinctively that it takes deliberate effort to remember it was a design decision rather than a fact of nature.
That decision is now being revisited, and not by a better mouse.
What the Graphical Interface Actually Solved
The problem the GUI solved was not aesthetic. It was epistemic. Before it, using a computer required knowing the name of the thing you wanted before you could ask for it. The command line is unforgiving in a specific way: it will not hint. You either recall the syntax or you consult a manual.
The Xerox Alto in 1973, and then the Xerox Star in 1981, proposed something different. Put the available actions on the screen. Let people recognise instead of recall. Represent abstractions as objects that can be pointed at, dragged and dropped into other objects. Ben Shneiderman later named the principle direct manipulation, and the name is precise: you act on a representation of the thing itself, and the thing responds immediately and visibly.
Apple shipped that idea to consumers with the Lisa and then the Macintosh in 1984, Microsoft followed, and within a decade the argument was over. Windows, icons, menus, pointer. Four elements, endless variations, one durable insight: make the possibilities visible and people will find their way.
Touch, arriving at consumer scale in 2007, refined the idea rather than replacing it. Removing the intermediary of the mouse made direct manipulation more direct, which is why it felt revolutionary and why it changed remarkably little about the underlying model. You were still pointing at tools and operating them one at a time. The gesture got shorter. The structure held.
It worked so well that we stopped noticing what it costs.
The Cost Nobody Priced In
Direct manipulation makes each individual action obvious. It says nothing about which sequence of actions accomplishes your goal, and it certainly does not perform the sequence for you.
Consider a modest, entirely ordinary task: launch a small product next week. Nothing about it is technically exotic. But watch the actual labour. You research the market in a browser and a dozen tabs. You write positioning in a document. You build a deck for a partner call in a second application. You generate or commission images in a third. You assemble a landing page in a fourth. You draft ad copy in a fifth. You reconcile all of it when the positioning changes on Thursday, by hand, in five places.
At no point was any single tool difficult. The difficulty was entirely in the seams.
This is the part the GUI never addressed: the human being is the integration layer. You hold the objective in your head, decompose it into tool-shaped pieces, carry state between applications by copying and pasting, and re-explain your context to every new interface because none of them share any. Software got better at individual tasks for forty years while the coordination burden sat exactly where it always sat, on you.
Fifty years of interface progress optimised the verbs and ignored the sentence.
Why the Chat Box Was Not the Shift
When large language models arrived in consumer form, it was widely assumed the interface question had been settled. Type what you want in plain language. Done.
It was a genuine advance and it was not the shift, because it changed the input method without changing where execution happens. A conversational assistant produces text about your objective. Extremely good text, often. But a description of the work is not the work. Ask for a landing page and you get an explanation of how to build one, or markup you must still host. Ask for market research and you get prose you must still verify, format and place into whatever document actually needed it.
The advice-to-action gap is the whole problem. You are still the integration layer, only now you are also the transcriptionist. Worse, conversation flattens structure: everything arrives as a wall of prose, whatever shape the work actually needed. A deck is not paragraphs. A website is not paragraphs. Neither is a spreadsheet.
Intention as the Interface
The shift underway is smaller in appearance and larger in consequence. Instead of naming a tool, you name an outcome. The system decomposes the outcome into steps, selects its own instruments, executes, and returns finished work rather than instructions.
Programmers will recognise the distinction immediately, because their field made the same move decades ago. Imperative code specifies how: loop through the records, compare each field, collect the matches. A declarative query specifies what: give me the customers who ordered twice last quarter. The database decides how to retrieve them, and nobody misses writing the loop.
Applying that to general computing is the actual proposition. The question the interface asks you changes from which tool do I need to what do I need to accomplish. That sounds like marketing copy until you notice it relocates the planning step. Planning was always the expensive part, and it was always yours.
There is a useful way to frame the ambition. If generative AI shortened the distance between imagination and creation, agentic systems aim to shorten the distance between intention and execution. The first compressed making. The second compresses coordinating, which is where most working hours actually go.
Inside the Imagine Computer AI Workspace Model
Abstractions are easier to argue about than to evaluate, so it helps to look at how this is being built. ImagineArt, which reached over three and a half million monthly users on image generation before turning to agents, structures its Imagine Computer AI Workspace around a single agent with a full toolset behind it rather than a suite of separate applications with a chatbot bolted on.
The distinction matters more than it sounds. In the suite model, each tool is a destination you visit and each visit begins with re-establishing context. In the workspace model, documents, slides, images, video, research, code and site publishing sit behind one agent that already holds the brief. You state the objective once. The plan spans the tools. Nothing is copied between tabs because there are no tabs to copy between.
That architecture is also what makes the earlier launch example collapse. Research, positioning document, deck, visuals, published page: one instruction, one context, one continuous chain, with the human reviewing the output rather than assembling it. When the positioning changes on Thursday, the change propagates through the chain instead of requiring five manual edits in five places, which is the difference between a workspace and a folder of shortcuts.
What an Intention Interface Must Have to Work
Three requirements separate a working intention interface from a demo.
Persistent context. An agent that forgets your brand, your audience and your last four decisions is a very fast stranger. Memory is not a convenience feature here; it is the thing that makes objective-level instruction possible at all, because a short instruction only works when everything unstated is already known.
Permissioned execution. Action implies reach, and reach implies risk. Any system that touches your files, mail or accounts needs explicit, per-connection permission that you grant deliberately and can revoke instantly. Nothing should be granted by default, and a system that cannot show you what it is allowed to touch is not ready for your accounts.
A shared surface. The tools must live where the agent lives. The moment execution requires exporting to somewhere else, the seams return and the human becomes the courier again. This is the design commitment behind Imagine AI: one workspace, one context, a full set of instruments inside it.
What Gets Harder, Not Easier
An honest account of an interface shift includes the new problems it creates, and this one creates real ones.
Verification moves and grows. When you performed each step, you inspected each step by doing it. When the system performs nine steps, you are reviewing an outcome without having watched it form. Plausible output is the dangerous register, and agentic output is fluent by construction. The research report reads beautifully whether or not its citations hold, and confidence in the prose is no evidence at all about the sources beneath it.
Errors compound down chains. A wrong assumption in step two propagates silently through steps three to nine, and it is discovered at the end, in the artefact, where it is most expensive to fix. Reviewing intermediate steps therefore stops being optional diligence and becomes basic operating practice.
Legibility becomes a requirement. If you cannot see the plan the system intends to follow, you cannot correct it before it executes. An agent that shows its reasoning and its intended actions is not merely more pleasant; it is the only kind you can supervise.
Accountability does not transfer. The output carries your name, goes to your client, and reflects on your judgement. Delegating execution has never once delegated responsibility, and it does not begin to now.
The GUI Does Not Disappear. It Changes Jobs.
The most common misreading of this shift is that screens and buttons are on their way out. They are not, and the reason is instructive.
Interfaces have historically layered rather than replaced one another. The command line did not vanish when the GUI arrived; it moved to where precision matters more than discoverability, and millions of engineers still live there daily. Expect the same pattern. Direct manipulation is superb for fine adjustment, exact control and judgement calls, and no plain-language instruction will ever place an element precisely where your eye wants it faster than dragging it.
What changes is the GUI’s primary job. It stops being where work gets performed and becomes where work gets reviewed, corrected and approved. Previews, diffs, permission panels, plan inspection, one-click intervention. Less workshop, more control room, which is roughly the transition every automated system has forced on the humans supervising it.
What to Watch Over the Next Few Years
Three developments will indicate whether any of this becomes the dominant paradigm or settles into a useful niche.
Permission standards. Agents acting across services need a common, auditable way to hold and surrender access. Without it, every integration is a bespoke trust decision and adoption stalls in exactly the places with the most to gain.
Memory portability. If context is what makes intention-level instruction work, context becomes the switching cost. Whether you can export the accumulated understanding of your work will determine whether this ecosystem stays competitive or ossifies.
Verification tooling. The bottleneck is shifting from production to checking. The interfaces that win will probably be the ones that make review fast and confident, not the ones that make generation marginally faster.
The Sentence, Finally
Engelbart’s demo answered a question about pointing. The question now is whether we still need to point at all, for most of what we do.
The GUI made computers usable by making possibilities visible. An intention interface tries something harder: making the gap between wanting and having small enough that the tools stop being the subject. If it succeeds, the achievement will be strange to describe, because success looks like an interface you barely notice, coordinating work you never had to break into pieces.
Fifty years of interface design taught us to speak in verbs, one at a time, in the order the software preferred. This is the first serious attempt at letting us speak in whole sentences and have something come back finished.
