For decades, software was designed around one assumption:
A human would be the one using it.
That assumption is starting to break.
We are entering a world where software increasingly needs to serve two categories of users:
- human users
- agent users
And those two stakeholders have very different requirements.
My observation
Over the last months, I have noticed that an increasing number of products are being built with AI agents in mind rather than humans.
I recently connected with builders actively working on products for AI agents to use:
- make specific data points for merchants searchable by AI agents so they can differentiate and reveal this information to human consumers when searching via LLMs.
- improve the searchability of human profiles on the internet by providing crawlable inputs for LLMs to ingest and agents to act upon
We are witnessing a big shift at the moment. An increasing number of companies, big and small, are leaning into this trend. The big players in AI are making it easier for companies to plug into emerging AI ecosystems through things like Claude Connectors or ChatGPT Apps.
The goal is to build high-leverage infrastructure for agents.
A merchant for instance may soon care less about whether a user lands directly on their homepage, and more about whether an AI shopping agent can accurately retrieve and compare their product information.
This shift opens up timely opportunities to build tooling that supports and plugs into these new agent-first ecosystems.
Noticeable trends
Some important trends I am seeing:
1) UI matters less, interfaces matter more
Think of it as the agent bringing relevant data directly to the human user, rather than the human manually navigating systems to find it themselves.
One consequence of this is the increasingly uniform chat interface we now see across many AI products.
The agent runs in the backend with a minimalistic human oversight layer.
Agent-first systems optimize less for visual exploration and more for reliable retrieval.
In many cases, APIs, schemas, and retrieval layers are becoming the real interface.
MCPs are one example of this shift.
The early web often felt handcrafted and expressive.
But maybe that's just my nostalgia speaking...
2) The internet is becoming machine-readable infrastructure.
LLMs are frequently trained on data pulled from the internet. As a result, you need to think about the quality of your data and how it can be used by LLMs.
Content is no longer just being consumed by humans. Increasingly, it is being parsed, ranked, retrieved, and acted upon by machines.
Think schema markup, citation-ready and brand-coherent content. High-authority mentions to elevate trust.
3) System design will change with agentic systems
Agentic systems require a very different kind of infrastructure than traditional apps.
Reliability, permissions, memory, observability, and rollback mechanisms become critical because the system is no longer just displaying information to humans, but actively acting on their behalf.
Trust becomes critical.
Visual polish matters less than reliability for agentic systems.
Safety mechanisms are also crucial:
- approval systems
- human-in-loop controls
- policy engines
- simulation environments
The mindset shift
My main takeaway from this post is to start considering the AI Agent as a new category of stakeholder with requirements to be satisfied.
Here is a good list of questions as a starting point for your new agent stakeholder:
- What would an agent need to know to act safely here?
- Is this information readable by machines, or only understandable by humans?
- What decisions should the agent make, and which should remain human-owned?
- What signals should change the agent’s behavior?
- What is the agent’s failure mode?
- What would make this workflow easier to delegate?
- What should be logged, remembered, or learned from this interaction?
- Is the interface designed for human navigation or agent retrieval?
- What policy should govern the agent here?
- Could this become a reusable agent primitive?
Taking this perspective as an agent will help unblock new ideas and opportunities and help you engineer more reliable systems over time.
I recently shifted gears into this mindset and unlocked a new way of thinking about software design.
Let's discuss
Are you excited about this shift?
Can you think of any opportunities that can arise from this new agent-first paradigm?
Closing remarks
For years, we optimized software for clicks.
Now we may need to optimize software for delegation.
That changes how we think about:
- interfaces
- trust
- documentation
- infrastructure
- even discoverability itself
The next generation of software may not be defined by the best UI.
But by how effectively humans and agents collaborate together.
Top comments (3)
For years, we optimized software for clicks. Now we may need to optimize software for delegation." — This is the absolute mic-drop quote of the year, Julien. Completely agree with your entire breakdown.
The shift toward the M2M (Machine-to-Machine) infrastructure means our metrics for success have inverted. When an AI shopping agent or an IDE agent fetches an endpoint, it completely skips the client-side UI layer. It doesn't care about pixel polish; it cares about reliable context retrieval.
This is exactly why MCP (Model Context Protocol) is gaining such massive gravity. It's becoming the universal OS for this delegation layer.
To address your brilliant checklist at the end ("Is the interface designed for human navigation or agent retrieval?"), we've been building a framework around what we call the Agent Readiness Score (ARS). It basically measures how machine-readable, schema-compliant, and safe a target DOM is before an active agent ingests it. If the site has dynamic rendering blind spots or hidden prompt injections, the agent's delegation path breaks.
We are truly moving into an era of Generative Engine Optimization (GEO). Fantastic piece, man. Def hit a nerve with this one!
I completely agree with the idea of considering AI agents as a new category of stakeholders with their own requirements. One aspect that caught my attention was the emphasis on reliability and safety mechanisms in agentic systems. I think it's crucial to balance the level of autonomy given to agents with the need for human oversight and control. What are some potential strategies for implementing effective human-in-loop controls in agent-first systems, and how can we ensure that these controls are scalable and efficient? I'd love to hear more about the author's thoughts on this matter, particularly in regards to the role of approval systems and policy engines in maintaining trust and reliability.
Yeah potentially excited, but "really" excited only once I see usable patterns, tools, frameworks, "best practices" and standards emerging to enable all of this - right now it all sounds pretty vague and abstract ...
How would you (re)design your app to make it "operable" by AI agents - rely more on a 'discoverable' REST API, rather than a fancy UI? Of course AI agents can scrape and operate your web UI, but that seems circuitous when it could more simply call your (REST) API ...