00 · The One-Liner
Why now is different from every previous shift.
For fifty years, software has been Pre-Cambrian: rigid, single-purpose, isolated, hard-shelled. Each app a single-celled organism with a hard-coded anatomy.
The reasoning layer, large language models reaching threshold capability, is the oxygen. The Cambrian Explosion is now.
01 · The Diagnosis
What "Pre-Cambrian software" actually means.
Every piece of software you've used until now has had these properties. Every one.
Property 01
Static and single-celled
A calculator calculates. A word processor processes words. A CRM tracks contacts. A monitoring tool monitors. They don't talk to each other in any meaningful way. They don't evolve based on environment. Each one is a primitive organism, complete in itself, isolated by API boundaries that were designed to keep things separate.
Property 02
Hard-coded anatomy
Traditional software has a rigid exoskeleton: the UI. If the developer didn't build a button for it, the software can't do it. The user is constrained to whatever stimuli the developer anticipated. Every menu, every form field, every keyboard shortcut is a fossilized decision someone made years ago about what users would want.
Property 03
Reactive, not anticipatory
Pre-Cambrian software waits to be told. Click here, it does that. Type this, it shows that. It has no internal model of what you're trying to accomplish. It can't infer, can't propose, can't act on your behalf. It's a tool that you wield, not a collaborator.
Property 04
Disconnected from context
It doesn't know what you did five minutes ago. It doesn't know what you're trying to build. It doesn't know who you are. Each session starts from zero. The state lives in your head, not in the software.
Property 05
Incapable of evolution
Pre-Cambrian software changes only when developers ship a new version. Months between releases. Each version is the result of human hands typing into other Pre-Cambrian tools. The pace of change is bounded by human typing speed.
That's been every piece of software, ever. Until now.
02 · The Substrate Shift
The oxygen threshold.
Earth's atmosphere needed to reach a critical oxygen level to support complex multicellular life. About 600 million years ago, after 3 billion years of single-celled organisms. Software needed reasoning to reach a critical threshold to support complex autonomous behavior.
The reasoning threshold has been crossed. Not perfectly, not universally, but sufficiently. Large language models in 2025 to 2026 can:
- Read code and understand intent
- Decompose problems into steps
- Operate tools and APIs
- Maintain state across sessions
- Propose actions and learn from feedback
- Collaborate with humans without explicit instruction at every step
That capability is the oxygen. Without it, software was stuck single-celled. With it, every category becomes a re-founding opportunity.
03 · The Explosion Underway
New body plans that weren't possible before.
What's emerging over the next five to ten years isn't iteration on Pre-Cambrian software. It's an explosion of new body plans.
Body Plan 01
From tools to agents
Software stops being a hammer and starts being an assistant. It doesn't sit there waiting; it perceives, anticipates, and acts. The user-software relationship inverts. Software no longer waits for the human to direct every step.
Body Plan 02
Fluid interfaces
The hard shells of menus and buttons dissolve. Software morphs its interface in real time to fit what you need. Forms become conversations. Dashboards become drift summaries. Settings pages become approval surfaces. The UI is generated, not authored.
Body Plan 03
Interconnectivity by default
In the biological Cambrian, organisms started eating each other, defending themselves, forming ecosystems. AI software consumes data from other software, collaborates with it, replaces it, and forms ecological niches. The era of isolated apps with their own data silos is ending. Everything talks to everything via open protocols.
Body Plan 04
Continuous evolution
Software changes constantly, not in versioned releases. Agents update behavior based on feedback. Patterns that work propagate. Patterns that don't get pruned. The pace of change uncouples from human typing speed.
Body Plan 05
Context-native
New software remembers. It knows what you did yesterday, what you're trying to accomplish today, what your team has been working on for months. State lives in the software, not in your head.
Body Plan 06
Behavior over interface
"Click here to do that" becomes "understand this and make it happen." The output is the same: work gets done. The mechanism changes completely. The user expresses intent; the software figures out the steps.
04 · The Structural Pattern
Every existing software category gets re-founded.
Every one. The pattern is consistent.
Pre-Cambrian Incumbent
Built for human typing into rigid interfaces
Fossilized assumptions, isolated state, reactive behavior. A hundred million dollars or more in revenue, a customer base, network effects, brand recognition. The known winner of the previous era.
Cambrian Successor
Built for agent-and-human collaboration
Fluid interface, networked state, anticipatory behavior, continuous evolution. None of the incumbent's lead. All of the structural advantage of being built for the new substrate.
Over five to ten years, the substrate advantage compounds and the incumbent's lead erodes.
This has happened before. Mainframe to minicomputer to PC to mobile to cloud. Each substrate shift produced new incumbents and demoted previous ones. Most previous incumbents survived in narrowed roles; some disappeared entirely. The substrate winners aren't determined by who was biggest in the previous era. They're determined by who builds first for the new constraints.
05 · Ecosystem Shape
Apex species and infinite niches.
The ecosystem that emerges is fractal. A few apex species dominate foundational layers; infinite niche variety fills everything above.
Apex Layer
Reasoning substrate
Foundation model providers. Already converging on a few (Anthropic, OpenAI, Google, maybe one or two more). Power-law winners.
Apex Layer
Agent runtime
The layer that runs agents reliably. Nascent but consolidating fast. Three to five winners likely.
Apex Layer
System graph
The unified state model agents query. Two to three winners eventually.
Apex Layer
Identity, billing, auth
Clerk, Stripe, and their peers. Either evolve to agent-first or get displaced by agent-shaped successors. One to two winners per category.
Apex Layer
Distribution channels
Agent app stores, or whatever shape that takes. Apex layer eventually.
These layers consolidate to few winners because they're infrastructure. Network effects, capital intensity, switching costs all favor concentration.
Niche Variety
Vertical SaaS
Every industry gets agent-shaped products. API monitoring gets an agent-shaped product. So do accounting, legal, healthcare, real estate, logistics. Thousands of products, most small, most viable because the economics shifted.
Niche Variety
Internal tools
Companies build hundreds of bespoke agent-driven workflows. Most never become products. They exist as competitive advantage.
Niche Variety
Personal agents
Cambrian explosion at the individual level. Custom workflows people build for themselves and friends.
Niche Variety
Combinatorial integrations
Every existing service times every other service times every workflow equals billions of niche tools. Most short-lived but real.
The niche layer doesn't consolidate the same way. The economics that previously required a fifty-person team to build a vertical SaaS now require a one to three person team. The number of viable niche products explodes by ten to a hundred times.
06 · Implications for Founders
What this means if you're building.
Rule 01
Don't try to be apex unless you have apex-class capital and timing
Foundation model competition requires billions. Agent runtime competition requires a full venture stack and a two-year head start. Apex plays are not solo founder plays.
Rule 02
Niche economics work for solo and small-team operators
A niche product doesn't need to win the category. It needs to capture enough customers to compound. There may be five apex API monitoring products eventually. There will be hundreds of niche ones serving specific customer types.
Rule 03
Know which game you're actually playing
The trap most founders fall into: thinking they're playing apex when they're actually playing niche, or the reverse. Apex players control infrastructure, partnerships, distribution. Niche players ship fast, charge real money, stay close to customers, and ignore TAM-flexing.
Rule 04
The biggest trap
"Every category is Pre-Cambrian, I should build in every category." Pre-Cambrian was followed by 540 million years of evolution and most body plans went extinct. The current AI moment will produce hundreds of new categories of tools and most will fail. Picking one and shipping through to revenue is the discipline that survives the extinction event.
Pick one. Ship one. Let the next emerge.
The trap of "everything is open" is itself the trap. The Cambrian Explosion in biology took 20 to 25 million years; the software version will play out across five to ten years for most categories. Specific timelines are unknowable. Many incumbents will survive by adapting; some will go extinct. What's predictable is the pattern, not the players.
This isn't a prediction with dates. It's the macro frame: the vocabulary that lets you sort products into Pre-Cambrian (incumbent, vulnerable) versus Cambrian successor (re-founded, structurally advantaged). Use it to choose which game you're playing, not to predict which competitor wins.