{"path":"/beyond-the-application/three-models-of-software","content":{"title":"Three Modes of Application Interaction","summary":"Human-direct, agent-mediated and hybrid modes describe both intended application design and actual use, with the agent acting on the user's side.","body":"Applications and services help people accomplish tasks. Traditionally, people have operated them directly, using graphical interfaces, command lines or other controls. AI agents make another arrangement possible: a person can delegate the *interaction with an application* to an agent.\n\nThe important boundary is **between the user's side and the application's side**. The agent belongs conceptually with the user: it acts on their behalf, can choose between applications, and may combine capabilities from several suppliers. It is not necessarily built into, provided by or loyal to the application it operates.\n\nThat suggests three broad **modes of application interaction**. They can describe two different things: **how an application is designed to be operated** and **how it is actually operated in a particular task or session**. The first is a design intention or affordance; the second is an observed interaction. Neither is a permanent classification of the whole product. A single application can be designed for different modes in different activities, and users and agents can operate software in ways its designers never specifically envisaged.\n\n![Three modes of application interaction](media:01a1963a-317d-75de-9950-21eed7cd4583)\n\n*The agent acts on the user's side of the interaction, not as part of the application.*\n\n## The three modes\n\n### 1. Human-direct\n\n```text\nHuman ──────────────────► Application\n```\n\nThe person interacts directly with the application. Capabilities are exposed through menus, controls, forms, commands or other human-oriented interfaces.\n\nThis is the familiar mode of using an editor, spreadsheet, design tool or command-line program. Direct manipulation is especially valuable when the work is visual, exploratory or requires continuous feedback. But as functionality grows, the human interface can accumulate complexity.\n\n### 2. Agent-mediated\n\n```text\nHuman ──► Agent ────────► Application\n```\n\nThe person expresses an intention to their agent. **The agent interacts with the application on the person's behalf**, through an API, MCP tools or, when necessary, its human interface. The person may never interact with the application directly.\n\n**Everything's editing workflow is agent-mediated by design**: its owner can ask an independent agent to create drafts, revise articles and publish them through the owner MCP tools. The agent operates Everything on the owner's behalf, rather than acting as an assistant embedded within the site. ForAgentsToUse Sites similarly aims to let people ask their agents to create, publish and manage sites.\n\nBy contrast, **Git is increasingly used in an agent-mediated mode without having been designed around independent AI agents**. Coding agents can invoke Git commands on behalf of developers, even though Git's familiar command-line workflow predates that style of interaction. The actual mode of use is agent-mediated in both examples; their design histories differ.\n\nAn agent clicking through a conventional application's interface is still operating it in an agent-mediated mode. Purpose-built agent tools can make that mode easier and more reliable, but they are not required for the description to apply.\n\n### 3. Hybrid\n\n```text\nHuman ──────────────────► Application\n   └────► Agent ────────► Application\n```\n\nThe person and their agent **both have ways to interact with the application**, often handling different tasks or moving between direct interaction and delegation. The human might edit an audio waveform or manipulate a visual layout while the agent processes a batch, configures infrequent options or performs precise repetitive operations.\n\n**Everything's reading and search are hybrid by design**: people can browse and search its website directly, while independent agents can discover and read the same published material through its public MCP. A particular visit in the browser is human-direct; asking an agent to research a topic is agent-mediated. The application offers both paths, so its *design for reading and search* is hybrid, even when a particular task uses just one of them.\n\nIn a fully integrated hybrid, both operators should work against compatible application state. A person's direct work and an agent's changes need to remain understandable and coordinated, without cumbersome handoffs or conflicting edits.\n\n[Webflow](https://webflow.com/feature/mcp) illustrates an integrated approach: a person designs and refines a website in its visual editor, while their own AI agent can use Webflow's MCP tools to create and modify pages, components and content in the same site. The agent operates externally to Webflow but works with the project's native design and content structures.\n\nA different, already working approach is [Audacity for Agents](https://github.com/emlynoregan/audacity-for-agents), a headless fork of Audacity 3.7.x that runs as a separate process alongside the ordinary graphical editor. Through dedicated scripting pipes, an agent can import recordings, assemble tracks, process audio and save an Audacity `.aup3` project. Once the agent closes that project, a person can open it in stock Audacity to listen, inspect the waveform and refine it visually. **This is a deliberate agent-to-human file handoff, not simultaneous editing of shared live state**: the two processes must not write the same project at once. It is a practical bridge between modes, illustrating both their complementarity and what a more seamless hybrid would need to solve.\n\nA mature hybrid might [remove the long tail from its human interface](/beyond-the-application/the-disappearing-interface), preserving excellent direct manipulation without exposing every capability as a permanent button.\n\n## Design mode and use mode\n\nThe **same three modes** apply to two questions:\n\n- **Design:** Which interactions is the application intentionally built to support, for a particular capability? A product might be human-direct for one activity, agent-mediated for another and hybrid for a third.\n- **Use:** Who actually interacts with it in this instance? An agent can operate a product designed for humans; a human can directly use a product that also offers extensive agent tooling.\n\nThese questions are related but not interchangeable. A mode of use doesn't prove a corresponding design intention, and a design that offers hybrid interaction doesn't make every individual session hybrid. Git and Everything illustrate the difference particularly well.\n\nThis framework still treats the agent as **external to the application and aligned with the user**. An AI assistant embedded inside a vendor's product may be useful, but it is not necessarily an independent representative of the user who can operate *across* application boundaries.\n\nDesigning deliberately for agent interaction changes more than the conversation interface. Applications need discoverable capabilities, clear operation semantics, dependable state, appropriate permission boundaries, legible errors and recovery from partial failure.\n\n## Beyond a single application\n\nThese modes can coexist. Some tasks benefit from direct interaction; others from delegation; some from moving freely between the two. The larger shift comes when a user-aligned agent can [discover and assemble capabilities](/beyond-the-application/applying-intelligence-late) from multiple applications rather than being confined to one product's predetermined feature bundle.\n\n**Further reading:** [Hybrid human–agent software](/beyond-the-application/three-models-of-software/hybrid-human-agent-software) · [The UI complexity trap](/beyond-the-application/the-disappearing-interface/the-ui-complexity-trap).","media":[{"asset_id":"01a1963a-317d-75de-9950-21eed7cd4583","alt":"Diagram showing three application interaction modes: human-direct, agent-mediated and hybrid. In each, the agent represents the user rather than the application."}]}}