Related: sources · notes · metadata · Published Pieces

Agents Are Not the Interface

Every app may become an agent internally. But the user should relate to artifacts, not a parliament of little personalities.

The mistake is easy to make because the word “agent” is so tempting. Once software can act, once models can use tools, once apps can run in the background, once workflows can continue without the user staring at them, it becomes natural to say: the future is agents. Every app becomes an agent. The user will manage agents. The computer becomes a team.

This is almost right, and therefore dangerous.

Every app may become an agent internally. But agents are not the interface.

The user does not want to manage a parliament of little personalities: a writing agent, search agent, coding agent, citation agent, calendar agent, publishing agent, video agent, finance agent, memory agent, verifier agent. That is not the future. That is app-switching with faces.

The user wants an automatic computer.

The automatic computer is not a chatbot with many tools. It is not an assistant that controls your device. It is not a swarm of cartoon coworkers reporting their progress in a shared chat. It is a coherent machine whose state is alive. Apps act. Artifacts update. Agents run behind the glass. The user interacts with durable objects, visible state, revisions, timelines, media, documents, dashboards, code, source trails, and outputs.

The agent is an implementation detail. The artifact is the interface.

This distinction matters because current product culture is still trapped inside the chatbot’s ontology. A user sends a message. The model replies. Tools are called. Maybe the tools are hidden. Maybe the model compacts context. Maybe it spins off a subagent. Maybe it edits files. But the center of gravity remains the transcript. That means the world of the system is still one agent’s context window.

A chat thread is a record of conversation. It is not a workspace, database, event log, document model, version-control system, permissions layer, project state, or public artifact. It can contain traces of all of these things, but it cannot safely become all of them.

Chat works for short exchanges. It fails when work becomes long-running, when agents mutate state over hours or days, when several agents work in parallel, when the user needs to know what changed and what can be reverted, when the system must preserve provenance, and when the output is not a response but a living artifact.

The obvious patch is multiagent chat: let several agents speak in one thread. If you expose the process, the chat becomes unreadable. Nobody wants to read the internal Slack of the computer. If you hide the process, the user loses provenance. The system says “the agents worked and here is a summary.” But a summary is not state. It is a story about state.

Multiagent chat collapses in either direction: too verbose to use, or too compressed to trust.

The problem is not multiagent systems. The problem is chat as their surface.

A real multiagent system needs canonical state outside any one agent’s context window: durable objects, messages, event logs, artifacts, permissions, traces, verifiers, and versions. Agents should read and write through bounded protocols. They should emit patches, citations, objections, test results, media segments, diffs, decisions, and claims. The user should inspect the evolving object, not the agent’s performance of effort.

The user should not ask, “What did all my agents say?” The user should ask, “What changed?”

This is why the automatic computer should be artifact-centered. A document is an artifact. A codebase is an artifact. A claim graph is an artifact. A podcast transcript is an artifact. A video timeline is an artifact. A research dossier is an artifact. A public profile is an artifact. A source map is an artifact. A web app is an artifact. A vtext is an artifact. These things have state, history, versions, citations, search, forks, revisions, publication paths, and verification.

Agents are useful because they can operate on artifacts. They are not useful because they talk.

The web desktop is one bridge to this future: familiar enough to be legible, portable across devices, model-legible, and capable of showing persistent runtime state without making users stare at logs. But the web desktop is only a skin over the deeper structure: a persistent agentic workspace where app state is alive, durable artifacts are canonical, and agents run inside boundaries.

This is also why “AI controls your device” is a dead end as a primary form. It inherits the old computer as a target. The agent moves the cursor, clicks buttons, opens apps, fills forms, and tries to operate interfaces designed for human hands and eyes. This can be useful. It is not the new computer.

A computer becomes automatic not when an AI can click around old software. It becomes automatic when the software itself becomes agentic.

A writing app should have source awareness, revision history, citation memory, criticism layers, voice drafts, publication paths, and agents that transform the artifact while preserving provenance. A coding app should have branches, tests, microVMs, verifiers, semantic patch extraction, dependency maps, and agents that mutate code in disposable environments before promoting changes. A media app should contain transcripts, real human clips, source links, claim maps, counterframes, prior art, and agents that render the artifact as text, radio, or video.

Every app becomes an agent internally. But the user does not want agents as their interface. The user wants artifacts that respond.

The future is not “talk to your apps.” It is “your apps act.” The future is not “manage your agents.” It is “work with a computer whose objects are alive.”

Agents execute. Artifacts remember. The user steers.