Software Design for the Agent Era
The shift
For decades, software design centered on one question: how does a human user interact with the system? Aaron Levie argues this is breaking: “Almost everything about how we’re building enterprise software products is changing right now. Now many of the core design challenges are more about how the user will work with AI Agents to do this task.”
The new design questions are different:
- How does the user set up, deploy, and orchestrate AI agents?
- How does the user provide context to agents?
- How does the user review and incorporate agent output?
- Does this happen through an existing UI, chat, a task queue, a workflow builder?
The UI inversion
In a world of AI agents, the user-facing interface gets simpler while the machine-facing interface gets richer. Levie observes: “The knobs, toggles, switches, and components needed for people to execute tasks are less necessary in a world of AI Agents. The APIs to these capabilities still matter for the AI Agents to use — but they’re primarily leveraged in the background.”
This creates a design inversion:
| Element | Pre-agent era | Agent era |
|---|---|---|
| Primary interface | Complex GUI for humans | API for agents |
| Human interface | Feature-rich, multi-step | Simplified: setup, review, exceptions |
| Interaction model | Human executes tasks | Human orchestrates agents |
| Design surface | Screens, forms, dashboards | Prompts, task queues, review flows |
Building for trillions of agents
Levie projects a future where “there will be trillions of agents executing every type of task for us imaginable.” This creates infrastructure demands that current software was never designed for:
- Identity: Agents need verifiable identities across platforms
- Storage: File systems and databases for agent work products, sessions, and shared data
- Collaboration: Tools for agents to work with humans (and other agents)
- Finance: Safe mechanisms for agents to spend or manage money
- Compute: Sandboxed environments for agents to execute code
“CLIs/APIs are their native tongue” — software designed for agents must be API-first, not UI-first with an API bolted on.
New design challenges
Building for agents introduces challenges that don’t exist when building for humans:
- Oversight requirements. Agents require far more oversight than human users. They cannot self-correct the way a human notices they’re going down the wrong path.
- Accountability gap. Agents can’t be held responsible for their work. The person who launches the agent bears responsibility.
- Privacy asymmetry. Agents don’t get the same privacy rights as humans — their work must be auditable.
- Failure detection. Agents “don’t quite know when they’ve run astray and can’t execute the task at hand.”
Proactive vs. reactive software
Elvis argues: “Proactive agents are going to fundamentally change how we interact with software.” Traditional software waits for user input. Agent-era software anticipates needs, monitors conditions, and takes action before the user asks — shifting the interaction model from pull (user requests action) to push (system initiates action).
Where the value lives: business logic above the database
The headless shift raises a critical question for incumbent SaaS companies: if agents bypass UIs and consume APIs, does the software retain value? Levie argues the answer depends on a specific variable — how much business logic sits above the database.
The reductive critique — “all software is just a database with a UI on top, and agents don’t need the UI” — misses the intermediate layer. An ERP system is “way more than a database at this point because you’ve written a tremendous amount of business logic of how your supply chain should be automated and work and how you should do accounting.” That business logic — security permissions, compliance rules, workflow orchestration, entity relationships — does not go away when the UI does. The moat is not the buttons; it is the encoded institutional knowledge in the API layer.
Levie proposes a diagnostic two-by-two for evaluating software vulnerability to the agent era:
| Low agent-human collaboration | High agent-human collaboration | |
|---|---|---|
| High business logic | Agents use APIs heavily; value accrues to API quality and pricing (e.g., ERP, content management) | Agents + humans need shared surfaces; the software provides both APIs and review UIs (e.g., compliance tools, FINRA-compliant document systems) |
| Low business logic | Most vulnerable — agents replace thin UI wrappers over simple CRUD operations | Transitional — humans still need the UI, but agents will erode the need over time |
Levie has become “more convinced that software is headless in the past year” due to the acceleration in agentic tool-calling accuracy: “Two to three years ago, if you wired up an agent and told it to go work inside of Box and find a document… it would basically almost always find the wrong document.” That is no longer the case. The practical barrier to headless software has fallen, making API-first architecture an urgent priority rather than a future consideration.
The two-track split
Levie predicts “a split between two types of teams or companies for the foreseeable future” — those designing for the agent paradigm and those still building traditional user-centric software. This parallels every prior platform shift: companies that built for mobile early gained structural advantages over those that treated it as a feature of their desktop product.
The same dynamic applies at the startup level: “We’re at a fascinating point where there’s a decent thesis for starting new companies in literally every established software category.” The thesis is that incumbents built their UX for humans; challengers can build from scratch for the agent-and-human paradigm.
Connection to the two machine ages
This shift mirrors the pattern in The Two Machine Ages. The steam engine (first machine age) augmented physical power but required factory redesign to capture its value. AI (second machine age) augments cognitive power but requires software redesign. The electric motor wasn’t transformative until manufacturers redesigned the factory floor. AI agents won’t be transformative until software is redesigned around agent-first architecture.
Related
- The Two Machine Ages — Each machine age required redesigning the infrastructure around it
- Context Engineering — The discipline of structuring agent-facing software interactions
- The Expanding Work Frontier — Agent-era software enables new categories of work
- Agentic Systems Infrastructure — The systems primitives beneath agent-era software