When the canvas starts to act: who really controls agentic interfaces?

The article, published in the design publication UX Collective, poses a central question: if interfaces no longer merely wait for instructions but can interpret an intent, act on their own and decide when they need a person, what does designing an interface mean then? The reflection starts from a historical comparison: for decades, software has been the place where a person tells the system what to do —you click, you drag, you type— and much of interaction design has consisted of making that next step obvious. The terminal, by contrast, was always different: it offers a great deal of power, but hidden behind commands you have to know in advance. AI coding agents are reintroducing that model: you describe an outcome and the agent decides which commands to run, which files to change or which tests to execute. There are gains, but very classic design questions reappear: what has the system understood? what is it doing? what has changed? what can I stop? what should I review myself?

One starting point is the problem of the empty 'prompt'. The first generation of generative AI presented users with a blank field with the instruction to describe what they wanted, which is not just a variant of the classic 'blank page' problem, but something different and harder: that field gives no hint about what is possible to do with the tool. The system's capabilities are hidden behind language, so the user needs to know what to ask for before they can even discover what the tool can do. The burden of exploring falls entirely on the person, instead of the interface itself revealing its possibilities and inviting experimentation.

Against this, the text revisits the classic usability heuristics (Nielsen's) to argue that they remain relevant, even if their meaning changes. 'Visibility of system status' comes to mean that the person understands what the agent has understood, what it is doing and where it is in the process. The principle of 'recognition rather than recall' translates into making the agent's capabilities visible through context and already-available materials, rather than requiring the user to remember the perfect command or phrasing. 'User control and freedom' comes to include the ability to interrupt, redirect or undo an agent's action. And 'error prevention' becomes the task of defining what the agent can do on its own and what necessarily requires a person's involvement. In short: the principles still hold, but the relationship they describe has changed, because we are now designing software capable of deciding when it needs human intervention.

The article illustrates this shift with the concept of the 'agentic canvas', using real collaborative design products as examples. Miro has reportedly developed an agentic canvas that brings together context from tools such as Slack, GitHub, Amplitude and Granola, plus PDFs, presentations, spreadsheets and screenshots, all in a shared spatial-type space (with zoom, panning, grouping of ideas and connecting pieces of work) instead of pages, slides or chat histories. Within that environment, features called 'Sidekicks' would interpret that context to create documents, diagrams, prototypes or boards, while 'Flows' would turn those interactions into workflows a team can see, run and reuse. What matters, the text notes, is not just that AI no longer works from an isolated prompt, but that it can read the canvas, reference prior assets and pass results from one step to the next, so that people can inspect the inputs, modify the outputs and build on them.

Figma is said to be moving in a similar direction: a design agent that works directly on the canvas, and 'Figma Make', which would allow going from ideas or existing designs to working prototypes and applications. The company has also reportedly opened its canvas to third-party agents and introduced 'skills' that give agents context about design decisions and intent, in an approach the article compares to how 'skills' work in Anthropic's ecosystem. The underlying idea is that a Miro board contains a project's context, a Figma file contains components, layouts and relationships, and a code repository contains files, dependencies, tests and errors: in every case, the agent has real material to operate on, and that changes the nature of the interaction.

There is, however, a further twist: agents not only consume the context they are given, but are beginning to decide what context they need to seek out. As an example, it cites Google DeepMind's work on agentic video understanding: instead of processing a video as a fixed stream of frames, a model like Gemini could determine which part of the video it needs to inspect, at what speed, and whether it requires frames, audio or a transcript, retrieving through an agentic loop the moments and signals relevant to the task, which would make it possible to answer complex questions about a video's content while consuming far fewer tokens than a static analysis. The article reads this not as a mere technical optimization, but as a fundamental shift: the system stops waiting to be pointed at the right information and starts deciding for itself which information is relevant and going to find it. That same pattern, the text argues, is beginning to appear in agentic canvases: the agent does not just receive a work environment, it navigates it, finds relevant context, connects information across tools and decides what to do with it. Context stops being something the system passively receives and becomes something the system actively seeks, and that turns attention into part of the design problem.

The text devotes a block to the idea of 'human in the loop', drawing on a Stanford essay that distinguishes between fully automating a task and designing a system where the person retains the ability to shape what happens. Human involvement need not mean doing the work manually, but deciding where the agent should act on its own, where it should check in and where a person should make the final decision; it is not a binary choice between doing everything yourself or delegating everything, but a flexible division of responsibilities. The article illustrates this with the example of planning a trip: you could give an agent the budget, the preferences and an approximate destination, and let it search for options and build an itinerary, without needing to approve every search or booking (because that would amount to doing the work yourself), but without wanting the agent to decide everything without intervention either: if two hotels are similar but one is in a neighborhood you don't like, or if the cheapest flight involves an awkward overnight layover, those are decisions where context and personal preference matter, and the agent should bring them back to the person instead of resolving them on its own. The formula the article proposes is 'AI in the loop, humans in command': what matters is not how many times a person clicks 'approve', but whether people retain control over the decisions that depend on judgment, context or preference.

From there follows another central idea: the 'handoff' becomes part of the interface itself. Designing no longer consists only of screens and interactions, but of deciding what the agent can do without asking, when it should request confirmation, which actions must be reversible and which decisions must always remain in a person's hands. These are decisions that look nothing like traditional interface design, but they shape the experience as much as a screen or an interaction does, and they constitute what the article calls the product's 'policy layer': the designer no longer defines only the interface through which people operate the system, but the conditions under which the system operates itself.

This, according to the text, is already changing how design systems and design knowledge are thought about: the conventions and decisions that used to live in designers' heads or in reference documentation could become operational context for an agent —that is, instructions and constraints that determine how a machine behaves, and not just reference material for humans. This also redefines what design 'taste' or judgment means: when AI can generate possibilities, taste helps decide which ones are worth pursuing; when AI can execute decisions, taste also helps decide which decisions should remain human and which can be delegated. The designer shapes not only the outcome, but the distribution of decision-making power that produces it.

The article closes by pointing to a further consequence: if agents can gather context, generate options, make changes and move work forward, execution stops being the scarce resource and attention becomes it. And there are, according to the text, two kinds of attention to consider: the attention the system itself devotes to things, and the attention the system asks the person to devote. The designer no longer needs to make every decision, but to recognize which ones deserve to be made by a person; an agent could inspect hundreds of files, compare dozens of options or review hours of video without involving anyone, and the design problem consists of deciding what it should show when it does need the person, and what it can handle without them. Human attention thus becomes a resource the system itself helps allocate, at the intersection of intelligent interfaces, orchestration and design judgment. The article's conclusion is that the designer's role shifts from specifying every interaction to deciding how responsibility and attention should move between people and systems: we still design interfaces, but now we also design the behavior behind them, the boundaries around it and the moments when control returns to a person. The question, the text suggests, is no longer just what the interface should look like, but who should decide what happens next and who should be paying attention when it does.