The Intelligence Layer
A new category of software has emerged. Stop building for the old one.
One of the biggest reasons it’s hard for people to understand AI and how to apply it (which most people are NOT really doing yet) is because our mental model of what computers are and what they are capable of is fixed in our minds.
Computers are good at performing tasks for us: computation, storing files, and running applications. They are tools that help us get things done. This understanding is pretty locked in and is evident in how people are using AI today, as an application or a tool to get work done.
AI changes all that.
A new category of use of computers has emerged. It is crucially important to understand what this category is and why it’s important in order to be able to leverage AI to its full potential.
Welcome to software in the Intelligence Layer.
What is the Intelligence Layer?
For most of the history of computers, to most people, computers did two things really well: store data and calculate. As a result we built applications (tools) we could use to get work done.
Every job and every task is just a combination of knowledge + processes that use tools to get a job done. The historic way we employed computers in this mix was a tool that helped get a part of that job done. Humans still drove the process and had the knowledge.
Humans used to do ALL of these things in every layer. Initially it was our memory that recorded facts about the world. Then tablets. Then paper. Then filing cabinets. Then databases. We built tools to help us with this important task. To the point where we don’t do any of the ‘writing down’ of information any more. Computers made the storage and retrieval of information a solved problem for us.
Then came applications. People have always used tools to get things done. It’s one of our distinguishing characteristics in the animal kingdom. Those tools evolved from hammers and chisels to machines, to assembly lines and finally to Google Chrome, Microsoft Excel. All tools that provide a high degree of leverage to accomplish a task.
But the realm of intelligence - decision making, complex logic, deduction, synthesis, reasoning - what we loosely call ‘thinking’ has always been in the exclusive domain of humanity.
This has suddenly changed. Yes, you can argue that this has been happening for a while. Factory automation takes some of the thinking out of the minds of the people building things. And more recently RPA and automation tools have been able to automate computational tasks. But these were not consumer level tools, they were only useful in certain situations and are generally extremely brittle. Modern AI changes all of this. And that is probably way more profound - the implications - the amount of change this opens up - than we realize.
The Intelligence Layer is everything humans do to take a task from start to finish. It consists of:
Knowledge
Decision making
Processes
Tool use
Coordination / communication
Context
And for the first time ever (don’t get all nit picky here, some of these things were possible before, but vibe with me) we can now build software in a meaningful way in this strata of human work.
But it won’t look like what we know. In order to understand it we have to deconstruct (or throw out) our understanding of how computers are supposed to work, how software works, and rebuild it around some new ideas, some new principles.
This software behaves more as fabric than a specific interface.
It consists of knowledge and encoded processes
It works alongside people helping shepherd tasks to completion
We’ve all heard of agents by now. Agents are an example of software in the Intelligence Layer but they are not every bit of software in it. Right now they’re most of what exists here, and that’s part of what makes this moment interesting. That said, they are a good starting point.
Briefly - what does an Agent like OpenClaw or Claude Code do? What does it feel like?
They are ephemeral, you can’t really see them running (not like interfaces we’re used to with applications)
The IO / interface for them is through other applications (Telegram or WhatsApp for OpenClaw, the terminal for Claude Code)
Their behavior is dynamic - it changes over time
They are somewhat unpredictable
They are non deterministic
They make mistakes
They use tools
They make decisions, sometimes checking in, sometimes autonomously
The above are indications of how different this kind of software feels.
And if you squint a bit, you see it looks and feels almost exactly like... how we behave, what it’s like to work with us.
Implications
To be clear, I don’t know what the implications are, I’m just mostly naming the phenomena. This is new territory that will unfold and be discovered as we explore and build in this space.
That said I think we can draw a few potential implications that have some value.
What changes as we discover out how to build out this layer with software?
Skills and Hiring - If the Intelligence Layer is real, then the people who build in it need a different skill set than application developers. It’s less about syntax and architecture and more about encoding judgment, designing decision trees, understanding processes deeply enough to make them explicit. Product thinking and systems thinking rise up in importance. As well as being comfortable working alongside these systems.
Business Models - Application layer software is sold as products (SaaS subscriptions, licenses). What’s the business model for Intelligence Layer software? It’s more bespoke, more process-specific, harder to generalize. That suggests consulting/services models might actually gain relevance, but the service is encoding intelligence, not writing code. That’s a very different value proposition than what Substantial has historically sold.
Management and Organizations - Perhaps the biggest one. If software can now operate in the Intelligence Layer (making decisions, coordinating, shepherding tasks) then the layer of middle management that existed primarily to coordinate and track work is directly affected. Not eliminated, but fundamentally changed. The humans move up to judgment calls the system can’t make, and the system handles the routine coordination.
Trust and Liability - Application layer software either works or it doesn’t. Deterministic. Intelligence Layer software makes judgment calls, which means it can be wrong in ways that are harder to detect and harder to assign responsibility for. Who’s accountable when the Intelligence Layer makes a bad decision? That’s unsolved and worth naming.
Compounding Returns - Intelligence Layer software that learns from its own operation creates a feedback loop that application layer software never had. The more it runs, the more knowledge it encodes, the better its decisions get. That’s a moat that looks nothing like traditional software moats (network effects, switching costs). It’s an institutional knowledge moat.
The above is perhaps the most significant for organization. And for people, really. The sooner you hop on board, if you can get this compounding return loop started, the sooner you zoom ahead. We may (not saying this confidently) get to a place where those who start down this path build an advantage that can’t be caught up with. Maybe ever.
The Link to Criticality
I’m (somewhat intentionally) burying the lede on all of this. The implications are far more important and - I believe - world changing.
In the Criticality piece, we discussed what’s happening - software is exploding at the low end, AI capability is climbing the spectrum, the middle is getting compressed. But we didn’t talk about why.
The Intelligence Layer is both the why and the destination: it’s not just that code got cheaper to produce. It’s that an entirely new kind of software became possible — software that operates in the layer where humans used to be the only option. The reason the low end of the criticality spectrum was empty wasn’t just cost. It was that most of those small, bespoke tasks required judgment — understanding a specific workflow, making decisions about edge cases, adapting to context. You couldn’t automate them with traditional application-layer software because they weren’t purely computational problems. They were intelligence problems dressed up as tool problems. Now that we can build in the intelligence layer, those tasks are suddenly addressable. That’s what unlocked the explosion.
The very act of building software is in the Intelligence Layer. And it therefore, is opening itself up. It is building itself.
What made something “high criticality” in the old world was partly about technical complexity, sure. But a huge chunk of it was about the judgment required.
The capability frontier isn’t just about AI writing better code — it’s about intelligence layer software getting better at handling higher-stakes judgment. At the low end, the judgment calls are cheap: if the tool gets it wrong, you fix it in five minutes. As you move up the spectrum, the judgment calls get more expensive — more users affected, more money at risk, more complex tradeoffs. So the real question isn’t “can AI write more complex code?” It’s “can intelligence layer software make trustworthy enough decisions at higher levels of criticality?” That’s a fundamentally different question.
We’ll continue this as we map out what the Intelligence Layer is and how to best build in it.
What are your thoughts? Does this frame agree with what you’re seeing? What are we missing?
Let me know if you have any ideas, we’re all figuring this out together.