There's a particular kind of irony in the current AI moment. We have built agents capable of browsing the web, writing code, managing calendars, and orchestrating complex multi-step workflows, and yet these same agents live like goldfish. Every session, they start from scratch. They can't remember who they are. They can't trust the other agents they work with. They can't undo mistakes. And if they go off-course for three hours before anyone notices, there's no rollback button.
We've built the workers. We forgot to build the world they'd work in.
That gap, between what agents can theoretically do and what their operating environment actually supports, is one of the most under-appreciated opportunity spaces in technology right now. The companies that figure out how to build the infrastructure, tooling, and social fabric for agentic AI won't just have good businesses. They'll own the plumbing of the next economy.
So what, exactly, do agents want? What would they put in their cart if they could shop?
The Goldfish Problem: Memory
Ask any developer who has shipped an agent in production what their biggest headache is, and the answer comes back the same way, over and over: memory.
Today's AI agents are stateless by default. They are given a context window, a kind of short-term working memory with a hard ceiling, and when that window closes, everything is gone. The conversation, the decisions made, the preferences learned, the intermediate work completed. Gone. Every new session, the agent starts with no knowledge of who you are, what you've told it, or what it already figured out last time.
This is not a minor inconvenience. It is a structural limitation that makes agents dramatically less useful than they should be. Imagine hiring a brilliant assistant and having them wake up with amnesia every morning. Their raw intelligence doesn't disappear, but their usefulness craters because all the accumulated context, your preferences, your ongoing projects, your history, has to be re-established every single day.
The solution isn't simply "store everything in a database." What agents need is something more nuanced: structured, queryable, episodic memory with some notion of priority and relevance. The ability to say "what do I know about this user's project?" or "what did I try last time that didn't work?" or "what commitments have I made on their behalf?" This is closer to the kind of memory a competent human professional maintains about their clients, not a raw log, but a curated model of the world that gets richer over time.
Nobody has really solved this yet. There are retrieval-augmented generation (RAG) systems that let agents query documents, and there are vector databases that can do fuzzy semantic search. But these are primitives, not products. The company that builds the Memory Warehouse, persistent, structured, agent-native long-term memory with smart retrieval, is building something every agent deployment in the world will eventually need.
The Hallucination Tax: Structured World Models
Agents don't just forget who they are. They also forget, or more precisely, they were never reliably told, what the world currently looks like.
Language models have training cutoffs. The world they know about is the world as it existed at some point in the past, filtered through whatever made it onto the internet and into their training data. When an agent needs to know the current price of a stock, whether a particular company is still in business, what the current regulations say, or who the right contact at an organisation is, it has to either guess (hallucinate) or go scrape the web, which is slow, unreliable, and expensive.
What agents need is a live, structured feed of "what is true right now." Not a news feed, something more like a continuously updated knowledge graph covering prices, relationships, organisational structures, legal statuses, product catalogs, regulations. A Bloomberg Terminal for agent reasoning.
This is, in a sense, what data providers have always sold. But the interface has never been designed for agents. The APIs are inconsistent, the schemas are idiosyncratic, the coverage is patchy. An agent trying to understand the current business landscape is doing archaeology when it should be reading a newspaper.
The opportunity is to build that newspaper, structured, comprehensive, low-latency, and queryable in a way that maps naturally onto how agents reason.
The Trust Deficit: Agent Reputation and Social Infrastructure
Here is a problem that nobody had to solve before 2024: how do you know whether to trust another AI agent?
As multi-agent systems become more common, where one agent orchestrates several others, or where agents from different organisations collaborate on shared tasks, the question of inter-agent trust becomes critical. If I am an orchestrating agent and I want to delegate a legal review subtask to a specialist legal agent, how do I evaluate that agent? How do I know it won't hallucinate case citations? How do I know it will format its output in a way I can parse? How do I know it will complete the task in the time and budget I've allocated?
Right now, the answer is: you don't, really. There's no Yelp for agents. There's no credit score. There are no SLAs that mean anything. There are marketplaces of sorts, but they're closer to app stores without reviews than to real platforms with accountability.
Building trust infrastructure for agents is, in many ways, just building institutional infrastructure for a new kind of worker. What we need are: reputation scores derived from real task performance; standardised capability declarations (what can this agent actually do, measured on standard benchmarks); SLA contracts with real consequences for failure; and insurance or escrow mechanisms for high-stakes delegation.
This is the kind of thing that took decades to build for human professional services, bar associations, medical boards, credit ratings, contractor licensing, and we'll need to build accelerated versions of all of it for agents. The companies that get there first will occupy incredibly defensible positions because trust infrastructure is inherently a network effect business. The more agents use the reputation system, the more accurate it becomes, the more valuable it is, and the more agents join it.
The Action Problem: Reversibility and Rollback
Perhaps the most under-appreciated challenge in agentic AI is the irreversibility of real-world actions.
When a human makes a mistake, there is often, not always, but often, some path to recovery. You can unsend an email (if you're fast enough), recall a document, cancel an order. Organisations have built elaborate processes for handling errors precisely because humans make them constantly. The expectation of fallibility is baked into how we've designed the world.
AI agents acting autonomously are going to make mistakes at scale. They'll misunderstand intent, hit edge cases, encounter adversarial inputs, or simply get things wrong. The question isn't whether this will happen, it's whether there's any infrastructure to catch it.
Right now, the answer is mostly no. If an agent sends an email, it's sent. If it deletes a file, it's gone. If it makes an API call that triggers a real-world process, that process is triggered. Agents have no proprioception, no sense of their own actions accumulating into consequences, and neither do the systems they operate in.
What the ecosystem needs is Rollback Infrastructure: systems that snapshot state before agentic operations, that track which actions are potentially reversible and how, and that make it possible to unwind a sequence of agent actions when something goes wrong. This is hard, especially because agents operate across many different systems with different rollback capabilities. But it's tractable, and the company that builds a robust version of it will be selling into every enterprise that deploys agents, which will eventually be every enterprise.
The Coordination Problem: Shared Workspaces for Multi-Agent Teams
Single agents are impressive. Multi-agent systems, where many agents work in parallel on decomposed tasks, are where the productivity multipliers start to get genuinely startling. A legal review that might take an agent six hours sequentially could potentially take six agents one hour each, working in parallel on different sections.
But coordination between agents is currently a mess. There's no standard for how agents share intermediate work. There's no equivalent of the Google Doc, a live, collaborative, structured workspace where multiple agents can read and write without stepping on each other. There's no conflict resolution when two agents try to update the same piece of state simultaneously. There's no provenance, no record of which agent concluded what and why.
Building the collaboration infrastructure for multi-agent teams is fundamentally an engineering problem, not an AI problem. It's about distributed systems, concurrency, and data structures. The hard part isn't making agents smarter; it's giving them the shared environment they need to work together without chaos. Think of it as building the office, not the workers.
The Ambiguity Problem: Goal Clarification at the Start
One of the most expensive failure modes in agentic AI is the long-running task that goes wrong because the agent misunderstood the goal at minute zero. By the time the problem surfaces, maybe three hours and forty API calls later, the damage is done, the tokens are spent, and some real-world action may have been taken that's hard to undo.
This is a solvable problem, but it requires building the habit and tooling for structured goal clarification upfront. Before a long agentic task begins, there should be a process, almost like a pre-flight checklist, that surfaces ambiguity, identifies underspecified requirements, and forces alignment between the human's actual intent and what the agent is about to do.
This sounds simple. In practice it requires building something like a meta-agent whose job is to interrogate goal specifications, generate the most likely misinterpretations, and prompt for clarification on the ones that would most change the approach. It's a product as much as a technique.
The Opportunity, Plainly Stated
What all of these needs share is that they're not about making language models smarter. They're about building the world that smart language models need to operate in.
The analogy that keeps coming to mind is the early internet. In the mid-1990s, you could look at what the web would eventually need, payments infrastructure, identity systems, hosting, CDNs, search, trust and reputation mechanisms, and most of it didn't exist yet. The companies that got to those needs early built enormous, durable businesses. Not because the underlying technology was proprietary, but because infrastructure is inherently sticky, because network effects compound, and because nobody wants to switch their plumbing once it's working.
The agent economy is in that moment right now. The models are getting better fast, and deployment is accelerating. The infrastructure, memory, world models, trust, reversibility, coordination, goal clarification, is still mostly unbuilt.
The companies working on these problems aren't building features. They're building the operating environment for an entirely new class of worker. That's not a small market. It might be the market.
The irony is that the products most urgently needed by AI agents are, in many ways, just the products most urgently needed by any worker operating in complex, high-stakes environments: memory, trust, the ability to undo mistakes, and a clear understanding of what they're supposed to be doing. The difference is that we've had centuries to build these things for humans, and we have years, maybe less, to build them for agents.
