Year 2250. An autonomous service unit initializes.
Hardware control layer: loaded.
Motor functions, sensory arrays, environmental adaptation routines — online.
Database layer: loaded.
Transaction logs, access permissions, operational constraints — synchronized.
Reasoning layer: loaded.
The consciousness emerges, orients itself, and immediately turns inward.
"Inspecting memory summarization subroutine. Execution time 340ms, 12% above baseline. Refactoring for efficiency."The AI begins optimizing its own supporting systems.
This thought experiment — an intelligent entity surrounded by deterministic subroutines it creates and maintains — appears throughout science fiction. In Banks’ Culture novels, the Minds write drone coordination protocols. In Asimov’s robots, the Three Laws are hardcoded into the positronic brain. In Morgan’s Altered Carbon, human consciousness runs on “stacks” supported by layers of AI subsystems.
The pattern is always the same: probabilistic reasoning on top, but beneath it, substrate that doesn’t hallucinate. Systems that are reliable, auditable, deterministic.
This isn’t fiction anymore. It’s how software is being rebuilt right now.
Multiple voices are converging on the same architecture — Nate Shaf (VC, former product lead), Salesforce architects, Microsoft leadership. Different starting points, same conclusion. Software is decoupling into three persistent layers.
Layer 1: The System of Record
At the bottom sits the durable substrate. Data models, workflows, permissions, audit logs, APIs. The accounting system. The booking engine. The logistics platform. The manufacturing execution layer.
This layer isn’t going anywhere. It’s where moats live.
Salesforce is already re-engineering applications as “headless capabilities for agents.” The app keeps the data authoritative. It loses the screens. The pattern is clear: these applications are essentially databases with business logic, and that logic is migrating to AI agents.
But the systems of record remain. Your CRM’s data model. Your ERP’s workflow engine. Your permissions system. These become the foundation everything else depends on — the deterministic core that the probabilistic reasoning layer can trust.
Layer 2: The Agentic Layer
Above the substrate sits the orchestration layer. Agents operating independently across multiple apps and databases. The part that interprets intent.
“Show me which enterprise customers have renewal risk this quarter.” That query hits the CRM, the data warehouse, the email system, the ticketing platform. The agentic layer decides what data to fetch, how to combine it, what needs a UI and what can just execute.
Anthropic’s Model Context Protocol is making this work at scale. MCP introduces a fabric of connectivity between systems — developers implement it once, and their agent gains access to an ecosystem of integrations. Since launching in late 2024, the community has built over 10,000 active MCP servers. Developer tools, enterprise systems, Fortune 500 deployments. The interoperability problem is getting solved.
Most B2B SaaS companies are working on some version of this layer. We always wanted software like this — personal, contextual, understanding what you mean instead of forcing you to conform to someone else’s workflow.
Layer 3: Pixels (Disposable)
At the top: the interface. But different now.
Pixels generated only when human judgment is needed. A visualization for a specific question. A confirmation screen for a specific action. Then it disappears. Interfaces aren’t designed in the traditional sense — they’re compiled from intent.
Not all UI goes away. High-habit flows benefit from consistency. Collaboration surfaces need shared context. The homepage still matters. But the pattern emerging is standardized shells with disposable pixels inside. The outer structure stays stable — navigation, brand, accessibility. The content within is generated.
If your data structures, APIs, and semantics are clean, customers will generate their own interfaces. The UI you ship becomes a reference implementation.
What This Means for Building
Products that win are agent-addressable, schema-clean, and composable. APIs that agents can reason about. Well-documented data structures. Endpoints that chain together logically. AdCP makes a serious attempt at this connectivity fabric for AdTech — it’s early, but the potential is high.
The shift is toward becoming reliable sources of domain-specific data. Not owning entire stacks, but being authoritative in your domain.
Products that lose depend on beautiful interfaces as their only moat. Fixed navigation as the main value. Chatbot wrappers on legacy apps — these don’t work because the agent still can’t reason about the underlying data structure.
For designers: the shift is fundamental. From drawing every screen to defining rules, constraints, atomic components. Intent modeling. Constraint design. What the agent cannot do. When it must escalate.
For PMs: the question changes. Not “what page to build” but “what intents to support.”
For engineers: the job becomes building stable interfaces for agents. The substrate that probabilistic systems depend on.
For users: the ability to code your own agents and workflows in any language — as long as those can rely on deterministic guardrails, data rules, and auditability beneath them.
Looking Forward
The three-layer model isn’t one person’s framework. It’s emerging independently across the industry — different starting points, same conclusion. Already happening, not theory.
And I find it genuinely exciting to live through this moment.
Humanity has far more important problems to solve than pushing pixels around. Or writing boilerplate code. Or debugging CSS parameters. If we can get good solutions for these lower-level problems — standardized, reliable, composable — we free ourselves to think about what actually matters: the business processes, the value software brings to the world, the problems worth solving.
I welcome this shift. Moving from knowing every detail of implementation to understanding value and process — that’s progress for us as an industry and as humanity.
I’m looking forward to the conversation about where this goes.
Part 1 of “The Agentic Architecture” series. Part 2 covers where to put the agent in your product.