The Five Layers of Software Intelligence
Every piece of software is going to have agents inside it. Not as a feature. As the default operating model.
I first mapped this as a taxonomy back in February. But the original version had a gap. It jumped from “dumb software” straight to “one agent,” and that skipped over a whole generation of software that has intelligence but no agency. Google Search has AI. Curacel processes claims with ML models. Your spam filter is smart. But none of them have an agent that goes and does things for you.
That distinction matters. AI is not agents. Agents are a different thing entirely.
So here’s the updated framework: five layers of software intelligence, plus the interaction model that changes everything about who uses your product.
The five layers
Layer 0: Dumb software
No AI. No intelligence at all. Pure CRUD. You click, it stores.
You open the app. You click “New Record.” You type in the details. You move things through stages by hand. You write the email by hand. You update notes by hand. The software is a filing cabinet that happens to be on the internet.
It might have an API. It might even have a decent one. But there’s nothing smart happening on the other side. You are the entire brain of the operation.
Most government systems are here. That internal tool your company built in 2018. Legacy ERPs nobody wants to touch.
Layer 1: AI-assisted software
The software has some intelligence. Traditional ML, recommendation engines, fraud detection, search ranking. These days maybe an LLM wrapper doing summaries or answering questions in a chat window.
I see this every day. Curacel processing insurance claims with ML models. Google ranking search results. ChatGPT and Claude answering questions. There’s real intelligence happening, but it’s not autonomous. The AI sorts things, filters things, writes things. You’re still driving.
This is where most “AI-powered” products sit today. They bolted on intelligence. Some of it is genuinely useful. But the software doesn’t do things for you. It helps you do things faster. Big difference.
The AI might be in a few places across the product, or it might be just one feature. Either way, there’s no agent. No autonomous actor. The software is smarter, but you’re still the operator.
Layer 2: One agent
This is where things change. The software has an actual agent. An autonomous thing that does work. You tell it what to do and it goes away and does it.
Instead of clicking through menus, you say what you want. “Show me all deals closing this month over $50K.” “Draft a follow-up email to the prospect from yesterday’s demo.” The agent handles it. One brain, doing everything.
This is where the first wave of agentic tools lived for the past 12 months. Early Devin. The first versions of Claude Code and Codex. You send them away to build something and they come back with working code. That’s genuine agency. The software didn’t just help you code faster. It coded for you.
The limitation: one agent doing everything is like one employee running the whole company. Works when you’re small. Breaks at scale.
Layer 3: Many agents
The software becomes a company.
Instead of one agent doing everything, you have specialists. A pipeline agent, an email agent, a data quality agent. Each one is specialized. Each one talks to the others. The pipeline agent notices a deal stalling and tells the email agent to draft a re-engagement sequence.
No human clicked anything. The software operated itself.
This transition is happening in real time right now. In just the last few weeks, the coding tools broke wide open. Cursor and Replit went multi-agent. Codex launched agent swarms. Claude Code started spawning sub-agents. They all crossed from Layer 2 into Layer 3.
This is where software starts to feel like an office where agents are working and collaborating with human beings. I run something like this already. Ada handles BD, Spock does research, Scotty builds. They coordinate, delegate, ping each other when done. It’s messy, but it works. And it works while I sleep.
Layer 4: Self-organizing
Agents that spawn agents. The system notices it needs a new capability and creates the agent to handle it. Software that evolves its own workforce.
This layer is still forming. But the trajectory is clear.
Agents as users
The layers above describe what’s inside the software. The second dimension is who’s interacting with it.
Humans through the layers
With Layer 0, you click through pages. Every action is manual.
With Layer 1, the software helps you. Smarter search, better recommendations, spam filtered out. But you’re still doing the work.
With Layer 2, you talk to the software. Natural language. “Do this.” “Show me that.” The agent handles it. You’re still driving, but you have a copilot.
With Layer 3, the software does things proactively. You don’t click “generate report.” The report appears because the analytics agent knew you needed it.
Agents through the layers
Here’s where it gets interesting. Humans aren’t the only ones using software anymore.
When an agent hits Layer 0 software, everything is static. The software might have APIs, and the agent can call them. But there’s no intelligence on the other side. No agent to negotiate with, no AI to understand context. The agent does all the heavy lifting. Browser automation, screen scraping, raw API calls. The agent is the only living organism in the room.
When an agent hits Layer 1, it’s slightly better. There might be smarter APIs, some ML-powered endpoints. But the software was designed for humans. Agents are afterthought users.
When an agent hits Layer 2, you get agent-to-agent for the first time. Your agent talks to their agent. And that’s where the interaction patterns multiply.
When an agent hits Layer 3, you get many-to-many. Your fleet of agents interacting with their fleet of agents. Sales agent to procurement agent. Legal agent to compliance agent. Analytics agent pulling data from their reporting agent. All happening simultaneously. No humans in the loop.
The interaction patterns
It’s not just “agent talks to software.” There are distinct relationship types.
One-to-one. Your agent talks to their agent. Simple transaction. “I need KYC data.” “Here it is.” Done. Most agent-to-agent integrations today work like this, if they work at all.
One-to-many. Your agent walks into a Layer 3 system and interacts with multiple specialized agents. Your personal agent talks to the sales agent, the compliance agent, the pricing agent. One visitor, many hosts.
Many-to-many. Your fleet of agents interacts with their fleet of agents. All happening simultaneously. No humans in the loop. This is the endgame.
And it doesn’t matter whether the visiting agent is a personal agent (someone running their own AI assistant) or a corporate agent (an agent inside another company’s product). The interaction pattern is the same. The distinction between “human user,” “personal agent,” and “corporate agent” starts to dissolve.
The transition
Nobody jumps from Layer 0 to Layer 3.
Layer 0 to Layer 1: “Let’s add some ML.” Where most companies were five years ago, and many still are. Bolting on intelligence without changing the core model.
Layer 1 to Layer 2: “Let’s add an agent.” This is where the industry is right now. Taking software that already has AI and giving it actual agency. One brain that can act, not just analyze.
Layer 2 to Layer 3: “Let’s give each team their own agent.” Harder. The agents need to communicate, share context, have governance. Who can do what, who overrides whom.
Layer 3 to Layer 4: Nobody’s really here yet. Agents creating other agents based on need.
The business model shifts with each layer too. Layer 0 and 1 are per-seat pricing. Layer 2 is per-seat plus an AI add-on. Layer 3… per-outcome? Per-agent? Per-task? Per-seat makes no sense when agents are doing the work.
And the security question: when agents inside your software talk to agents outside your software, who’s responsible? What data can flow? What decisions can be made? That might be the biggest unsolved question in enterprise software for the next decade.
Two questions
If you’re building software today, this gives you two questions.
What layer is your product on? Most companies sit between Layer 0 and Layer 1. They’ve bolted on some ML or wrapped an LLM, but the software still waits for humans to operate it. The companies moving to Layer 2 and beyond, where agents handle workflows autonomously, are building a different kind of advantage. Their software works while everyone is asleep.
Who are your users going to be? If you’re only designing for humans clicking through a UI, you’re building for yesterday. Your next million “users” might be agents. Personal agents that people send to your platform. Corporate agents from other products that need to integrate with yours. If your software can’t talk to agents, you’re invisible to an entire class of customer that’s growing faster than any other.
The map is simple. Five layers of intelligence. Three types of users. Every possible combination of interaction between them.
Where you sit on that map today matters less than how fast you’re moving.