Software Philosophy · 2025–2035
Agent First:
Why the Next User Isn't Human
How a shift in who — or what — consumes software is changing the way we design, build, and think about systems.
"Build for agents first. The human experience follows."
The Catalyst
A Familiar Shift Has Happened Before
A philosophy that changed how the entire industry builds for the web — and the identical inflection point we're standing at now.
📱
Mobile First
In the early 2010s, designers realised most users were on phones. The rule became: design for the smallest screen, scale up — not the other way around.
🤖
Agent First
Today, the primary consumer of software is no longer a human at a browser. It's an agent — calling, reading, and chaining services on someone's behalf.
🔄
The Parallel
Just as Mobile First wasn't a tweak but a paradigm shift, Agent First changes how you think about building software from the ground up.
The Core Shift
Search Engines Pull. Agents Push.
For thirty years, the dominant model of interacting with the digital world was search. You had a question. You went somewhere. Agents invert this entirely.
Search Engine Era
You query, it returns results
You interpret and decide
You choose when to look
Reactive to human intent
Pull-based interaction
One session, one answer
→
Agent First Era
Agent monitors, it initiates
Agent interprets and acts
Agent decides when to tell you
Proactive on your behalf
Push-based delivery
Continuous, contextual intelligence
Core Shift
In the Agent First world, software doesn't wait to be asked. It watches conditions, surfaces insights, and triggers actions — because the agent is the consumer, operating continuously on your behalf.
Early Personal Experiments
What I'm Already Doing — At a Very Basic Level
These aren't sophisticated deployments or best practice blueprints. They're my own early experiments — scrappy, simple, and already useful. I share them not to impress, but to show how low the barrier already is. If this is what's possible at a basic level today, the ceiling is much higher than most people think.
Information
Hermes, my news agent
Every morning, Hermes pushes a curated news briefing to me. I didn't search for anything. It watches what I care about and delivers. It's basic — but it's already replaced a habit that used to take me 20 minutes of scrolling.
Productivity
Second Brain, my project agent
I'm building an agent to surface my weekly project to-dos without me having to review everything manually. It's still a work in progress — but even in its early form, it's changing how I think about managing my own time and attention.
Economic
The travel spotter (not built yet)
This one is still just an idea — an agent that watches airfare discounts and currency exchange rates, and tells me when the window is right for a trip. It doesn't exist yet. But it easily could. That's the point.
Why I'm sharing this
These examples are deliberately ordinary. The goal isn't to show you what agents can do at their best — it's to show you that agents are already woven into everyday life at their most basic. The question isn't whether this shift is coming. It's whether the software you're building is ready for it.
Structural Change
What Agent First Reduces
Three core assumptions that shaped software design for decades are collapsing.
↓
Human-in-the-loop dependency
Agents replace the need for a human to initiate, navigate, and interpret. Systems designed to require human input at every step become bottlenecks.
↓
Interface-first thinking
The UI was always designed for human perception — visual hierarchy, intuitive clicks. Agents don't need a UI. They need a clear, callable contract.
↓
Session-based interaction
Agents don't log in and log out. Discrete, bounded sessions fail when agents operate continuously over days and weeks.
The Architecture Shift
What Agent First Means for How Software Gets Built
Mobile First changed design decisions at every layer. Agent First changes software decisions at every layer too.
01
APIs over interfaces
- Primary entry point is agent-callable APIs
- Usability becomes agent navigability
02
Goals over instructions
- Expose outcomes, not button-level steps
- Intent must be explicit and machine-readable
03
Observable outputs
- Structured outputs chain across services
- Ambiguity breaks orchestration
04
Continuous, trustable systems
- Persistent long-running interactions
- Granular permissions and auditable scope
The Human Element
What Changes for Developers and Teams
Agent First doesn't eliminate human-facing software. It repositions it. The human experience becomes the second layer — review, approval, and taste.
Before Agent First
Developers write code
Humans navigate interfaces
Testing = edge cases in clicks
Speed limited by team size
UX is the primary design layer
→
After Agent First
Developers orchestrate agents
Agents navigate systems
Testing = edge cases in reasoning
Speed limited by clarity of goals
API contract is the primary design layer
Developers become orchestrators
Interfaces become approval layers
Speed compounds differently
Role Evolution
How Work Itself Changes
Core responsibilities shift from execution in interfaces to goal design, oversight, and reasoning quality.
01
Developers become orchestrators
- Define intent and constraints
- Review and refine agent output
02
Interfaces become approval layers
- Humans decide, agents execute
- Design shifts from doing to deciding
03
Testing changes entirely
- Validate decisions, not clicks
- Edge cases move into reasoning
04
Speed compounds differently
- Iteration accelerates with automation
- Constraint becomes clarity of goals
Final Statement
The future will not be defined by the absence of human users — but by the rise of capable agents operating on their behalf, and teams that build Agent First systems from the start.
Those who build Agent First will build systems that scale beyond what any human team can operate alone.