A single AI agent is useful. A team of AI agents working together is a completely different category of software.
Most people still think about AI agents the wrong way. They imagine a single super-agent that can research, write, code, analyze, review, and execute tasks end-to-end. That model works for demos. It breaks under real production complexity.
What is emerging instead is something much closer to organizational design.
One agent researches. Another analyzes. Another validates. Another writes. Another reviews. Another orchestrates the entire workflow.
This is the architecture Anthropic pushed further on May 6th, 2026, when they announced multi-agent orchestration for Claude Managed Agents at their Code with Claude event. Developers can now coordinate up to 20 specialized agents running in parallel on a single task.
That detail matters: parallel. Not sequentially waiting on each other. Simultaneously executing specialized work streams.
This is not experimental anymore. Companies like Netflix, Shopify, and Harvey are already deploying multi-agent systems in production. Netflix uses coordinated agents to analyze massive build logs simultaneously. Harvey uses them across legal research, drafting, and compliance workflows. Shopify has publicly discussed aggressive autonomous coding targets internally.
The important thing is not the tooling announcement itself. The important thing is the architectural shift underneath it.
The future of AI systems is not one bigger model doing everything. The future is coordinated systems of specialized agents working together.
The easiest way to understand this is to stop thinking about prompts and start thinking about teams.
A single agent behaves like a single employee. Even if the employee is exceptional, they can only execute one cognitive thread at a time. Research first. Analysis second. Writing third. Review fourth.
A multi-agent system behaves like an actual organization. Specialized workers execute simultaneously within defined scopes and communicate through structured interfaces.
The first practical implementation pattern is the pipeline model.
In a pipeline, agents execute sequentially with tightly scoped responsibilities. A research agent gathers source material. An analysis agent identifies patterns and extracts insights. A writing agent turns structured findings into readable output. A review agent checks for quality, consistency, hallucinations, and missing information.
This works extremely well for predictable workflows where downstream steps depend on upstream outputs. Most content operations, compliance reviews, report generation systems, and internal research pipelines fit this model.
The second pattern is fan-out orchestration. This is where multi-agent systems become dramatically more powerful than single-agent systems.
A commander agent decomposes a large task into independent subtasks and distributes them to worker agents running in parallel. One agent analyzes Document A. Another analyzes Document B. Another processes customer sentiment. Another reviews pricing changes. Another scans recent industry news.
All of them run simultaneously.
The commander then synthesizes the outputs into a unified result.
This is the architecture that starts compressing hours of work into minutes. More importantly, it scales cognitive throughput horizontally rather than vertically. Instead of asking one overloaded agent to reason through everything, you distribute reasoning across specialized workers.
The third pattern is the specialist team model. This is the most organizationally interesting structure because it mirrors how high-functioning companies already operate.
Imagine a product launch workflow.
One agent analyzes market positioning and competitors. Another evaluates technical feasibility. Another models pricing scenarios and unit economics. Another writes launch copy and landing pages. Another performs consistency and quality review.
Each agent stays inside its expertise boundary.
That boundary discipline is critical.
Most failed agent systems fail because every agent is too general. People accidentally recreate a single-agent architecture distributed across multiple poorly defined agents. The result is redundancy, confusion, token waste, and degraded outputs.
Specialization is the entire point.
If you want to build a real multi-agent system, the first step is not writing prompts. It is workflow decomposition.
Define the overall business objective first.
For example: “Generate a weekly competitive intelligence briefing for our executive team.”
Then break the work into distinct cognitive functions: competitor monitoring, pricing analysis, social listening, market research, synthesis, writing, and quality review.
Then determine which tasks can run independently and which require upstream dependencies.
This matters because orchestration logic becomes the core infrastructure layer.
Once the workflow is decomposed, each agent needs three things: a narrowly defined role, access to the correct tools, and a structured output format.
The output format is the part most builders underestimate.
Agents communicate through interfaces exactly like software systems do. If one agent outputs vague prose while another expects structured JSON, the handoff breaks immediately.
The highest leverage decision in multi-agent design is standardizing data contracts between agents. Define explicit schemas: required fields, acceptable formats, fallback values, error handling behavior. Treat agent communication like API design, not conversation. Then comes orchestration.
Some agents run in parallel. Some run sequentially. Some aggregate outputs. Some validate outputs. Some retry failures. What matters is deterministic coordination.
The orchestration layer increasingly becomes more important than the model itself. This is where the market is heading: not toward “best model wins,” but toward “best operational AI system wins.”
That includes: memory systems, evaluation frameworks, workflow coordination, permissioning, tool integration, auditability, and institutional learning.
One of the most important recent developments here is persistent agent memory.
Anthropic’s “Dreaming” feature is effectively organizational memory for AI systems. Agents review historical sessions, extract patterns, identify mistakes, and curate memory stores between runs. That sounds abstract until you realize what it means operationally.
Your agent team accumulates institutional knowledge over time. It learns what good outputs look like. It remembers prior failures. It refines internal heuristics. It adapts to organizational preferences. This is much closer to onboarding and organizational learning than prompting.
The companies that understand this early will build enormous advantages because most competitors are still focused on prompt engineering while the frontier is shifting toward system design.
The other major shift is evaluation infrastructure. High-performing multi-agent systems do not rely on blind trust. They define explicit rubrics for success. A report must contain data from all five competitors. An analysis must contain at least three non-obvious insights. A summary must remain under a defined token limit. A coding agent must pass unit tests before deployment.
This creates closed-loop quality systems instead of one-shot generation.
The future AI stack increasingly looks like this: models at the bottom, orchestration above them, memory above orchestration, evaluation above memory, and organizational workflows wrapped around the entire system.
This is why multi-agent systems matter so much. They are not merely faster chatbots. They are the first real operational layer for AI-native organizations. And the implications are enormous.
A six-person research workflow becomes one operator coordinating specialized agents. A consulting deliverable that took two days becomes a 20-minute orchestrated pipeline. An agency becomes less about labor accumulation and more about workflow architecture.
The people who learn these patterns now are not just learning “AI tools.” They are learning how the next generation of software organizations will operate. That is the real shift underway.
Sometimes speed is just impatience wearing ambition’s clothes.
Silicon Valley has always been brutal about the future.
Nobody cares what you built ten years ago. Nobody gives you permanent credit because you took a company public. If you stop building, you disappear.
That’s actually one of the best things about the Valley.
But lately, I think speed has curdled into something else.
Speed with learning beats impatience
Researchers jump labs every eighteen months. Founders shut down companies after a year because the excitement faded. Engineers treat careers like a video game: collect title, vest cliff, move on.
Some speed is good.
Good speed compresses learning. It helps you kill stagnant ideas. It gets you from signal to iteration before the market catches up.
Bad speed is different.
Bad speed is novelty addiction. It keeps you from sitting in the ugly middle where the real edge forms.
AI makes this more dangerous.
You can prototype faster. Test faster. Ship faster. And convince yourself faster that motion equals progress.
But lower friction can also accelerate false starts.
In a world where building is cheap, choosing what is worth building matters more.
Depth still wins.
Judgment compounds. Relationships compound. Domain expertise compounds. Trust with a team compounds.
Cut the timeline short and you never reach the part of the curve where the returns become extraordinary.
The future belongs to fast learners.
But also to people with enough discipline to stay.
That framing is already obsolete. AI is not becoming a feature. It is becoming a complete industrial stack, with its own infrastructure layers, operating systems, orchestration frameworks, application ecosystems, and economic gravity.
What cloud computing did to enterprise infrastructure over the last twenty years, AI is about to do to every layer of software, decision making, and digital labor. The mistake many investors, founders, and operators make is viewing AI through only one layer of the stack.
Some focus entirely on models. Some focus entirely on applications. Some obsess over GPUs. Others think agents alone are the future.
In reality, AI is becoming a vertically integrated system where every layer compounds the value of the layer above it. That is what makes this moment structurally important.
The modern AI economy is not one market. It is an interconnected stack.
Layer 1: The Digital AI Chip
At the bottom of the stack sits compute.
This is the industrial foundation powering everything above it. Without massive parallel computation, none of the modern AI ecosystem exists.
For years, most people thought CPUs were the center of computing. AI changed that assumption completely. Training and inference workloads massively reward parallelism, memory bandwidth, and specialized tensor operations. That shifted power toward GPUs, TPUs, LPUs, and custom accelerators. That’s Cerebras.
This is why companies like NVIDIA became some of the most strategically important companies in the world. The market is not simply paying for chips. It is paying for the ability to manufacture intelligence at scale. And increasingly, memory architecture matters just as much as raw compute.
HBM3e, SRAM optimization, interconnect bandwidth, power efficiency, and distributed cluster orchestration are becoming critical competitive layers because modern AI systems are fundamentally constrained by data movement. That’s Micron, SK Hynix and Sandisk (to a lesser extent)
The dirty secret of AI infrastructure is that intelligence is often bottlenecked not by reasoning capability, but by how fast systems can move memory through the stack. This is also why the AI race is becoming geopolitical. Countries are realizing that compute capacity is not merely technology infrastructure. It is economic leverage.
The cloud providers understood this early.
Amazon AWS, Microsoft Azure and Google Cloud are intelligence utilities.
Layer 2: Symbolic Systems
Above the hardware sits symbolic representation. AI models are not magical. They are prediction systems trained on symbolic abstractions of reality.
Text. Code. Images. Audio. Relationships. Logic.
The internet became the largest symbolic dataset ever created by humanity.
Every GitHub repository, Wikipedia article, Stack Overflow answer, scientific paper, Reddit discussion, legal contract, customer support transcript, and YouTube subtitle became training material for machine intelligence. This layer matters because intelligence requires abstraction.
A model cannot reason about concepts unless reality has first been translated into symbolic structures.
This is why data quality matters so much.
Garbage symbolic systems create garbage reasoning systems.
It also explains why enterprises are suddenly obsessed with knowledge graphs, embeddings, retrieval systems, vector databases, and internal context pipelines. The next wave of enterprise AI will not merely be powered by public internet knowledge. It will be powered by proprietary symbolic context unique to each organization. The institutional memory of a company becomes machine-readable. That changes the economics of expertise.
Layer 3: Digital AI Models
The model layer is where symbolic understanding becomes usable intelligence.
Large language models fundamentally changed software because they introduced probabilistic reasoning into mainstream computing. Traditional software systems required deterministic instructions. AI models infer. That sounds subtle. It is not.
It changes the philosophy of software entirely.
Instead of explicitly programming every workflow, humans increasingly specify intent while models generate outputs dynamically. This is why concepts like chain-of-thought reasoning, multimodal understanding, autoregressive generation, and state-space modeling matter. The software industry is shifting from handcrafted logic toward statistical cognition.
But the important observation is this:
Models alone are rapidly commoditizing. The frontier models remain expensive and strategically important, but raw intelligence increasingly behaves like infrastructure. This is similar to what happened with cloud computing.
At first, infrastructure itself captured extraordinary value. Over time, differentiation migrated upward into orchestration, workflow design, distribution, and vertical integration. The same thing is happening to models. OpenAI and Anthropic (and Xai to a small extent and Meta) are here.
Which leads to the next layer.
Layer 4: Agent Systems
This is where the stack becomes operational.
Models generate intelligence. Agents translate intelligence into action.
That distinction matters enormously.
A chatbot answering questions is not transformative. An agent autonomously orchestrating software systems is.
This is the layer where AI stops being conversational and starts becoming operational. Most people underestimate how large this market could become. Because the economic value is not in generating text.
The value is in reducing human coordination overhead.
Most enterprise inefficiency is not caused by lack of intelligence. It is caused by fragmented systems, manual orchestration, context switching, poor prioritization, and operational latency. Agents attack those problems directly. This is why companies are racing toward AI-native workflow systems.
The future enterprise software stack will increasingly consist of:
The software interface itself begins disappearing. The workflow becomes the product.
Layer 5: Digital AI Applications
At the top of the stack sit the visible applications.
This is the layer consumers interact with directly.
Coding copilots. AI legal assistants. Research systems. Creative generation tools. Scientific discovery engines. Enterprise copilots. Autonomous analysts.
But the application layer is deceptive. Because most AI applications are not truly standalone products. They are abstractions sitting on top of every layer beneath them. A modern AI application increasingly depends on:
This is why the strongest AI companies are increasingly becoming vertically integrated.
Owning only the application layer becomes dangerous if someone else controls the models. Owning only the models becomes dangerous if someone else owns distribution. Owning only the infrastructure becomes dangerous if higher-level orchestration captures most of the economic value.
Every layer is attempting to move both upward and downward in the stack. That is the real AI war.
The Bigger Shift
The most important takeaway from this stack is that AI is not simply another software cycle.
It is the industrialization of cognition.
Previous software revolutions primarily automated storage, communication, and workflow digitization.
AI automates parts of reasoning itself. That changes the economics of labor. It changes organizational design. It changes how products are built. It changes how companies scale. It changes what knowledge work even means.
And unlike previous technology waves, every layer of this stack reinforces the others.
Better chips enable larger models. Better models enable more capable agents. Better agents enable richer applications. Better applications generate more data. More data improves symbolic understanding.
The system compounds. That is why this moment feels different. We are not merely watching a software boom. We are watching the construction of a new digital industrial stack for intelligence itself.
AI and LLMS won’t kill Salesforce or most other SaaS.
First: Salesforce was never “just” the UI. The UI was the enforcement mechanism for structured data capture. That is different. The real moat was always organizational standardization. Salesforce won because entire GTM organizations reorganized themselves around its ontology: Accounts, Opportunities, Stages, Forecasts, Territories, Approvals. The UI enforced compliance with that ontology. Agents weaken the interface advantage, but they do not automatically weaken the organizational ontology advantage. That distinction matters.
Second: “headless” is being overstated across the industry. Most enterprise software already exposed APIs years ago. What is changing is not technical architecture. What is changing is who the primary consumer of the software is. Historically: humans. Increasingly: agents. That is a distribution and interaction shift more than a pure infrastructure shift. Salesforce is effectively repositioning itself from “application employees log into” toward “operational substrate agents execute against.” That is a very different narrative than “Salesforce became headless.”
Third: the deepest moat may not actually be the database layer. It may be the policy layer.
That is the missing insight in most “Postgres + APIs replaces SaaS” arguments.
A surprising amount of SaaS value is not CRUD operations. It is encoded institutional policy:
who can approve what
escalation trees
exception handling
rollback rules
auditability
compliance workflows
reconciliation logic
permissions
temporal sequencing
coordination between departments
The database is easy. The operational state machine is not.
AI lowers the cost of recreating the first 80% of a system of record. The remaining 20% is the moat.
The first 80% is schema generation and workflow reconstruction. The final 20% is operational entropy accumulated over 15 years of edge cases.
That is where incumbents still retain leverage.
The agentic world may compress the distinction between system of record and system of execution.
Historically:
CRM stored intent
ERP stored transactions
Ticketing stored requests
Humans executed work
In the agentic stack:
the system stores context
agents execute
outcomes become new training/context
execution exhaust becomes proprietary data
That closed-loop matters enormously.
The future moat is not: “Who stores the record?”
The future moat is: “Who observes the action loop?”
That changes everything.
A vertical AI-native field-service platform that:
dispatches technicians
observes outcomes
tracks timing
handles exceptions
coordinates payments
monitors resolution quality
captures edge-case execution traces
…is building a fundamentally stronger moat than a passive CRM.
Because it generates new proprietary operational data every day.
That is the key transition: Static data → Dynamic execution exhaust.
Another strong insight: network effects historically being weak in SoRs.
Most enterprise SaaS never achieved true network effects. It achieved switching-cost lock-in masquerading as network effects.
Salesforce did not become more valuable because more companies used Salesforce. It became harder to leave because:
integrations accumulated
process accumulated
training accumulated
reporting accumulated
management rituals accumulated
That is not a network effect. That is organizational sediment.
Agentic systems may genuinely create network effects for the first time because agents transact across organizational boundaries.
That is a major conceptual shift.
For example:
procurement agents
logistics agents
insurer/provider agents
auditor/accounting agents
supplier/manufacturer agents
Once multiple counterparties coordinate through the same execution rails, the software stops being a database and starts becoming market infrastructure.
That is closer to Stripe, Visa, Flexport, DoorDash, or even Bloomberg than traditional SaaS.
DoorDash is actually more profound than it initially appears.
DoorDash’s moat is not “restaurant data.” It is coordinated operational execution:
drivers
routing
logistics
dispatch
fulfillment timing
marketplace balancing
payments
exception recovery
The future durable enterprise platforms likely look more like operational coordination networks than dashboards.
Another thing:
The SaaS seat-license model structurally weakens in an agentic world.
What AI is actually doing to companies beneath the product layer is not obvious to most entrepreneurs. It is not really about recruiting. It is about institutional design becoming the new competitive advantage once software itself becomes fluid.
The core argument is simple:
When models, workflows, interfaces, and even product categories converge fast enough, the durable moat shifts away from “what you build” toward “how your organization compounds judgment.”
In other words:
AI compresses product differentiation.
So organizational differentiation becomes strategic infrastructure.
The second important observation most people miss:
Great companies are not just talent aggregators.
They are identity engines.
Organizational Design
Like Amazon leadership principles. Or Netflix Culture Code.
The company shape determines: who gets power, what behavior is high status, what sacrifice means, what ambition gets rewarded, and ultimately what kind of human being can exist there.
That is a much more sophisticated framing than the usual “mission-driven culture” nonsense.
AI is commoditizing product narratives faster than products themselves.
Everyone now sounds identical: “system of action” “AI-native workflow layer” “context graph” “organizational memory” “agentic infrastructure”
The language converges before the products converge. Which means narrative inflation is now instantaneous.
The new moat is institutional compression resistance.
The companies that survive AI will not necessarily have the best models.
They will have the hardest-to-replicate organizational geometry: decision velocity, talent density, status systems, deployment loops, and concentrated judgment.
Most companies accidentally optimize for emotional extraction.
They make people feel: special, chosen, important, close to power.
But structurally: they centralize authority, delay ownership, gate economics, and defer recognition indefinitely.
That asymmetry is probably the defining labor tension of AI-era startups.
AI companies are increasingly religions disguised as corporations.
Not metaphorically. Structurally.
The strongest AI institutions now compete using: destiny, civilizational stakes, tribal identity, moral positioning, and historical proximity.
The recruiting pitch increasingly resembles ideological alignment rather than employment.
The collapse of category boundaries means “org design” becomes product design.
Palantir’s forward deployment model was not HR policy. It was the product architecture expressed through people.
OpenAI’s structure is not separate from its models. The institution itself is part of the product.
That distinction matters enormously.
The biggest “aha” people may miss:
Most founders still think organizational design is downstream of the company succeeding.
In AI, it is upstream.
Because the product itself changes too quickly.
Your structure determines: who joins, who stays, who gets authority, how fast decisions travel, whether reality reaches leadership, whether customer pain is respected, whether exceptional people compound each other or suffocate each other.
The organization is no longer the wrapper around the moat.
A new category gets invented on Monday. By Friday, 400 startups have rewritten their homepage around it.
That is what happens when product velocity becomes cheap.
Models improve fast. Interfaces converge. Features get copied in weeks. Entire categories collapse into each other.
The visible layer of company-building is becoming commoditized.
Which means the real moat is moving somewhere else.
Into the institution itself.
The companies that survive this era will not just have better products.
They will have better organizational geometry.
How decisions move. Who gets authority. What behavior is high status. How customer reality reaches product teams. How exceptional people compound each other instead of drowning in process.
Palantir understood this early.
Forward deployment was not just a GTM motion. It was an organizational invention.
OpenAI did not just build models. It built a new institutional structure around frontier research.
The shape of the company became part of the advantage.
Most founders still think org design is something you clean up after success.
In AI, it is becoming the thing that determines whether success compounds at all.
Because products are getting easier to copy.
But concentrated judgment, talent density, mission alignment, and institutional trust are still brutally hard to build.
The organization is no longer the wrapper around the moat.
Seeing today’s latest round of “AI layoffs” discourse reminded me of something uncomfortable that I think a lot of people in tech already know, but are hesitant to say out loud.
These layoffs are not really about AI replacing workers directly.
But they are still because of AI.
That distinction matters.
A lot of ink has been spilled debating whether the current layoff wave is genuinely driven by AI productivity, or whether companies are simply “AI-washing” ordinary cost cutting. You can find essays arguing both sides. One side claims AI is fundamentally transforming software development and knowledge work.
The other points out that if AI is truly delivering 5x productivity gains, why do products look mostly the same? Why are revenues not exploding upward? Why do organizations still move slowly?
Both sides are partially right.
Because the real story is not that AI suddenly replaced 30% of employees overnight. It clearly has not. Most companies are nowhere close to operating autonomously through AI agents. Most workflows are still deeply human, deeply organizational, and deeply messy.
But something equally important did happen. AI changed the economics and speed of execution faster than organizations could adapt to it.
And that mismatch is now destabilizing companies from the inside.
The easiest way to understand this is through a boring but useful framework every management consultant eventually rediscovers and puts into a PowerPoint slide:
Input. Output. Outcome. Code is input. Features are output. Revenue, retention, usage, customer satisfaction — those are outcomes.
For years, engineering organizations operated under a very important constraint: writing software was expensive and slow.
The CEO had 150 ideas. Product wanted to test all of them. Engineering said: “We only have bandwidth for one.”
That constraint was frustrating, but healthy. Because it forced prioritization. It forced argument. It forced teams to kill bad ideas before they consumed too many resources.
Then generative AI arrived.
Now suddenly:
MVPs appear in days.
Internal tools get built overnight.
Pull requests explode.
Individual engineers generate dramatically more code.
Teams can prototype five directions simultaneously instead of debating one.
At first this feels magical. And in many ways, it is. But then something strange happens. The amount of code increases dramatically. The amount of actual business outcome often does not.
And this is where both AI evangelists and AI skeptics start talking past each other.
The evangelists point at the explosion in output. They are not hallucinating that. It is real. Anyone working inside a modern tech company can see it. AI usage is everywhere now. Even conservative companies that try to restrict AI adoption still have employees quietly using ChatGPT, Gemini, Claude, Cursor, Copilot, or some internal equivalent.
Meanwhile, forward-leaning companies are consuming AI tokens at astonishing rates. Entire engineering teams now operate with AI copilots open all day. Code generation volume has exploded. Internal tooling velocity has exploded. Experiments that once took weeks now take hours.
The skeptics then ask the obvious question:
“If all this productivity is real, where are the corresponding outcomes?”
Why are the products not radically better?
Why are revenues not scaling proportionally?
Why do users barely notice the difference?
That is the correct question.
Because AI dramatically accelerated inputs without automatically improving judgment.
And once that happened, organizations discovered something uncomfortable:
Coding was never the only bottleneck. In many companies, it was not even the primary bottleneck anymore. Alignment was. Decision-making was. Prioritization was. Organizational coherence was. The ability to distinguish two good ideas from eight bad ones was.
For years, engineering scarcity hid these problems.
When code was expensive, organizations were forced to compress decision-making. They had to debate priorities carefully because implementation carried real cost. Bad ideas died early because nobody wanted to waste six months building them.
Now implementation is cheap.
So the filtering mechanisms weaken.
Instead of debating whether something should exist, teams often just build it because they can.
And this creates a second-order organizational problem that I think many executives are only now beginning to realize.
AI does not just accelerate execution.
It accelerates divergence.
Two teams receive loosely aligned objectives and independently build different solutions overnight based on different assumptions. Product alignment that once happened before implementation now happens after implementation — when conflicting prototypes already exist.
Except nobody really wants to slow down and align properly anymore.
Because once people get used to infinite AI-assisted execution capacity, every disagreement feels solvable through “just building another version.”
So instead of reducing organizational chaos, AI often amplifies it.
Everyone becomes locally productive while the organization becomes globally incoherent.
This is the part most discussions about AI productivity completely miss.
The bottleneck shifted.
We thought software engineering was the limiting factor.
Turns out organizational coordination was.
And when the original bottleneck disappears overnight, all the hidden inefficiencies downstream become painfully visible.
You suddenly notice:
overlapping roadmaps,
duplicate tooling,
stakeholder conflicts,
management layers,
endless meetings,
redundant approvals,
teams blocking teams,
political coordination disguised as process.
The faster coding becomes, the more expensive organizational friction becomes.
That is one side of the story.
The other side is simpler.
AI is expensive.
Not philosophically expensive. Literally expensive.
If your engineers are consuming tens of thousands of dollars per year in AI tokens, inference, compute, and tooling costs, that spend has to come from somewhere.
And right now, most companies are not seeing proportional revenue expansion from that spend.
That matters.
Because businesses ultimately run on unit economics, not technological excitement.
If your input costs rise 30%, but your outcomes barely move, something must rebalance.
Companies can tolerate this temporarily while chasing strategic advantage. But eventually the finance organization starts asking obvious questions:
Why is infrastructure spend exploding?
Why is AI tooling spend exploding?
Why are engineering costs rising?
Why are we generating dramatically more output without equivalent business results?
And once those questions start getting asked seriously, layoffs become mathematically predictable.
Not because AI replaced the employee one-for-one. But because AI changed the company’s cost structure before it changed the company’s outcomes.
This is why calling these layoffs “AI-washing” is incomplete. Yes, many companies already had structural issues:
overhiring,
bloated middle management,
slowing growth,
declining margins,
weak product differentiation,
post-ZIRP expansion hangovers.
All true.
But AI still matters profoundly here because it changed executive expectations around what level of organizational efficiency should now be possible.
And there is another uncomfortable truth underneath all of this. Large organizations contain slack by design.
That redundancy is not accidental. It creates resilience. It allows institutional continuity. It allows people to leave, switch teams, take parental leave, or disappear without the company collapsing instantly.
But that same redundancy also means many large companies can remove 10–20% of staff and continue functioning in the short term with surprisingly little disruption.
Again, this does not mean layoffs are universally good or strategically wise long term. Many companies will absolutely cut too deep and damage themselves. Some are already doing so.
But from the perspective of executives staring at exploding AI budgets and organizational coordination problems, the logic behind these layoffs is not irrational.
They are trying to rebalance the organization around a new execution reality. Whether they actually know how to operate effectively in that new reality is a separate question.
And that, ultimately, is the real story.
The biggest misconception in the current AI debate is the assumption that AI productivity automatically translates into business productivity.
It does not. AI massively increases the capacity to generate inputs. But companies still need systems that convert inputs into outcomes.
They still need judgment. They still need prioritization. They still need coherent product strategy. They still need organizational alignment. They still need actual understanding of customer problems.
And until companies learn how to translate AI-generated abundance into real economic outcomes, we are going to continue seeing this strange phase where:
code generation explodes,
AI spending explodes,
organizations destabilize,
and payroll shrinks to offset the difference.
These layoffs are not happening because AI has fully replaced humans.
They are happening because AI changed the economics, expectations, and operating tempo of companies faster than companies learned how to adapt.
AI accelerated execution. Human organizations did not accelerate coordination at the same speed. And that gap is where the layoffs are coming from.
The famous “$1 software, $6 services” idea has been floating around Silicon Valley for years. The premise is simple: for every dollar spent on software, companies spend roughly six dollars implementing, operating, customizing, integrating, managing, and extracting value from that software through services.
What is interesting now is that AI companies are all implicitly claiming they can capture the entire $7.
Not just the software dollar. All of it.
The software. The implementation. The execution. The operations. The optimization. The services layer. Everything.
And honestly, I think a lot of founders believe this is inevitable because AI dramatically compresses labor costs. If a system can generate code, generate creative, generate campaigns, generate reports, generate analysis, then the assumption becomes: “obviously the software company now captures the services revenue too.”
But I think most people are massively underestimating how difficult that transition actually is.
Because replacing labor is not the same thing as owning outcomes.
Most agencies right now are making the exact same mistake. They are using AI primarily to reduce labor cost inside the existing agency model. Faster reports. Faster creative generation. Faster SEO content. Faster media analysis. Faster onboarding. Faster decks. Faster summaries.
That is not a new operating model. That is the old operating model with better tooling.
You still fundamentally have the same fragile structure underneath: humans moving information between systems, humans manually coordinating workflows, humans stitching together context, humans translating between strategy and execution, humans constantly re-explaining the same things to different people.
The result is that many agencies are becoming “cheaper execution engines” instead of becoming true growth infrastructure companies.
And I think that is the wrong game entirely.
The real opportunity is not selling cheaper labor. The real opportunity is selling managed growth loops.
That distinction matters because agencies historically sold hours, then deliverables, then expertise. But none of those things are actually what the customer wanted. The customer wanted movement. Specifically, movement from uncertainty to revenue.
Nobody buys SEO because they emotionally crave backlinks. Nobody buys paid media because they love campaign structures. Nobody buys content because they admire blog formatting.
They buy these things because they are trying to move a buyer through a chain: unaware → aware → interested → trusting → wanting → acting.
Every marketing function exists to move somebody forward in that chain. If it does not move somebody forward in that chain, it is probably just organizational theater disguised as marketing sophistication.
When I reduce marketing down to first principles, most of the work is actually just recombining a relatively stable set of raw materials: customer pain, customer language, proof, offers, objections, competitor claims, search demand, social demand, conversion data, sales feedback, brand taste.
That is it.
Most campaigns, landing pages, ads, outbound sequences, webinars, sales decks, and SEO pages are simply different combinations of those inputs expressed through different channels.
The problem is not lack of intelligence. The problem is workflow fragmentation.
Traditional agencies route these inputs through an absurdly inefficient human maze. One person gathers data. Another writes a brief. Another reviews the brief. Another asks the client clarifying questions. Another creates variants. Another formats slides. Another builds reports. Another explains the reports in a meeting nobody wanted.
By the time the work actually ships, the market already moved.
This is why I increasingly think the future agency is fundamentally about loops, not services.
A loop is an end-to-end process that continuously converts inputs into outcomes while learning from feedback. The important part is not automation. The important part is the feedback system.
For example, take a paid creative loop.
Customer pain, proof points, offer positioning, and channel data become creative angles. Those angles become variants. The variants become ads. The ads generate performance data and sales feedback. The winners get scaled. The losers get killed. The learnings get stored. Then the next iteration improves.
That is a loop.
An agent is not the loop.
An agent is simply a worker operating inside the loop.
This distinction is where I think a lot of AI companies are going to fail. Right now everybody is obsessed with building agents. Research agents. SDR agents. Creative agents. Analytics agents. Reporting agents. Coding agents.
But many companies are building giant collections of agents without building the actual operating system that coordinates them.
So you end up with: many bots, many automations, many dashboards, many copilots, and still no meaningful compounding advantage.
That is AI theater.
The future agency probably has three layers.
At the top sits the managed loop. That is the actual business outcome layer.
Underneath are specialist agents responsible for execution tasks.
And above everything sits human judgment.
I actually think humans become more valuable in this world, not less valuable. But their role changes significantly.
Humans should own: taste, strategy, prioritization, tradeoffs, offer quality, client trust, narrative framing, high-consequence decisions, what to kill, what to scale.
Humans should not spend their best cognitive hours resizing creative, formatting slides, manually checking broken links, rebuilding onboarding checklists, or writing generic first drafts for the 900th time.
That work should become infrastructure.
This is why I think codified workflows become incredibly important. At Single Grain and Single Brain, I increasingly think about this through SKILL.md files.
A skill file is basically codified expertise. It defines when a workflow should run, what inputs are required, what tools are involved, what good output looks like, what failure looks like, what requires human approval, and what gets saved back into memory.
Without codified skills, agents improvise.
With codified skills, systems begin repeating the best version of the workflow instead of reinventing it every time.
And that is where compounding starts happening.
Labor resets every month. Infrastructure compounds.
I think the agencies that survive this transition will own seven major loops.
The raw materials loop continuously collects customer pain, objections, reviews, transcripts, competitor messaging, proof, search demand, and social signals so inputs never go stale.
The creative testing loop continuously generates, tests, kills, scales, and learns from creative velocity.
The demand capture loop watches search, AI recommendations, social discovery, and community conversations to determine where authority should be built.
The conversion loop identifies where momentum dies between impression and revenue.
The client narrative loop converts performance data into clear decisions instead of recurring meetings.
The sales enablement loop continuously feeds sales teams with better proof, better objection handling, and better follow-up assets.
And finally the learning loop captures every successful and failed pattern so the entire organization compounds instead of restarting from zero with every client.
That last loop is the moat.
If an agency serves 100 clients and still starts from scratch every time, that is not a learning organization. That is a staffing company with a better website.
The firms that win in the AI era will not simply “use AI.” Everybody will use AI.
The winners will build systems that learn faster than competitors.
That changes hiring too. The most valuable people in the next generation agency are probably not generic task executors. They are people who can direct systems, judge outputs, recognize weak signals, make decisions under ambiguity, improve workflows, and earn trust.
Some people become dramatically more valuable in this world.
Some roles become brutally exposed.
That is uncomfortable, but pretending otherwise does not change the economics.
The question I keep coming back to is simple:
If AI makes execution dramatically cheaper, what do clients still need agencies for?
I think the answer is: ownership of the growth loop.
Not isolated tasks. Not disconnected deliverables. Not prettier reports.
They need someone to continuously turn messy market signals into reliable customer acquisition while the system keeps getting smarter over time.
That is the business model I think eventually captures the full $7.
I am an AI maximalist. What that means is that from day one I believe it will create more jobs eventually. I have been consistent on this. Why?
AI collapses the marginal cost of cognition.
When the marginal cost of a core production input collapses, systems reorganize around abundance, not scarcity.
That is what happened with: energy, transportation, computation, communication, and storage.
Now it is happening to reasoning itself.
The mistake most AI doomers make is treating “today’s jobs” as the unit of analysis.
Historically, that has never been the correct frame. The economy does not preserve jobs. It preserves demand satisfaction.
The tractor did not “save farming jobs.” Excel did not “protect bookkeepers.” AWS did not “protect sysadmins.”
Instead: costs collapsed, throughput exploded, adjacent industries emerged, organizational complexity increased, new coordination problems appeared, new abstractions became valuable.
The important historical pattern is not merely “technology creates jobs.” Sometimes it absolutely destroys categories permanently. The important pattern is that productivity increases create systemic expansion.
Labor absorption, however does not happens smoothly. History says it absolutely does not.
The transition periods are brutal.
Agricultural mechanization was not painless. Industrialization was not painless. Globalization was not painless. Software automation was not painless.
AI increases the frontier of economically viable ambition.
Humans are not utility-maximizing relaxation machine.
We are stupid. We find meaning in work.
The modern middle class consumes luxuries kings literally could not buy:
instant communication,
air travel,
climate control,
infinite entertainment,
personalized medicine,
software infrastructure,
global commerce.
As cognition becomes cheaper, expectations will inflate again.
Models are already becoming interchangeable. OpenAI, Anthropic, Google, DeepSeek, Meta, Mistral — the gap narrows every quarter. Intelligence itself is rapidly commoditizing.
The real battle is moving one layer higher.
We are not living through one AI revolution. We are living through four overlapping micro-revolutions:
Chat.
Agents.
Context.
Platform.
And the company that wins the Context Revolution will likely become the most valuable company in history. Not because it builds the smartest model. Because it becomes the operating system for digital intelligence itself.
The mistake people make during every technological revolution is assuming the first winners remain the final winners. History says otherwise. The companies that dominate one phase of a revolution are often structurally incapable of dominating the next.
IBM did not win the PC revolution.
Yahoo did not win search.
BlackBerry did not win mobile.
MySpace did not win social.
VMware did not win cloud.
The current AI cycle will follow the same pattern.
Every Revolution Follows the Same Structure
Technology revolutions always feel chaotic from the inside. But viewed historically, they are surprisingly predictable.
First, fringe technologists experiment for years while nobody pays attention. Then a breakthrough suddenly reduces the cost of creating something valuable. Entrepreneurs rush in. Capital floods the market. Startups multiply. Hype explodes.
Then comes saturation.
The weak die. The winners consolidate. Infrastructure forms. Platforms emerge. The Industrial Revolution followed this pattern. So did the internet, cloud computing, mobile, crypto, and social media.
AI is no different.
What makes this cycle unusual is the scale of what is being automated. Previous revolutions automated transportation, manufacturing, publishing, communication, or commerce. This one automates intelligence itself. That changes everything.
Revolution 1: Chat
The first phase of AI was conversational intelligence.
ChatGPT was the iPhone moment. For the first time, hundreds of millions of people could directly interact with a machine that felt intelligent. That alone created massive companies.
Entire industries emerged around AI-generated text, therapy, tutoring, coding assistance, roleplay, search augmentation, and content production.
This phase belonged overwhelmingly to OpenAI. They won distribution.
ChatGPT became the default interface for consumer AI in the same way Google became the default interface for the web. But chat alone was never the final form. Conversation is useful. Action is more valuable. Which led directly to the second revolution.
Revolution 2: Agents
Once models became reliable enough to produce structured outputs and invoke tools, AI stopped being conversational software. It became executable software.
Agents could suddenly interact with APIs, write code, search databases, send emails, book meetings, analyze files, and manipulate software systems.
This unlocked the agentic explosion.
AI SDRs.
AI customer support.
AI coding agents.
AI researchers.
AI workflow automation.
AI employees.
The entire market shifted from “AI that talks” to “AI that does.” This is where Anthropic built enormous momentum. Claude Code and agent-native workflows pushed the industry toward persistent execution rather than isolated prompts. But we are now clearly in frenzy territory.
Half of YC is building agent startups. Every SaaS product suddenly claims to have “agents.” Launch videos look like crypto commercials from 2021. People are spending more time branding agents than building moats.
That usually means a layer is approaching commoditization. And agents have a serious problem. They are only as good as the context they operate inside.
The Real Bottleneck Is Context
Most AI systems today are stateless. They forget everything. Every prompt starts from near-zero.
Even sophisticated agents still operate with fragmented memory, incomplete understanding, weak personalization, and shallow continuity.
That is the next great infrastructure problem in AI. Context. Not context windows. Context itself. Persistent organizational memory.
The living graph of people, meetings, documents, workflows, decisions, preferences, relationships, histories, and intent.
The companies solving this are not building “better prompts.” They are trying to build intelligence substrates. A durable memory layer for humans and organizations.
This is where the real switching costs emerge. Models are replaceable. Context is not.
A company can switch from GPT to Claude. It is much harder to switch away from years of accumulated organizational memory, workflows, embeddings, permissions, histories, and relationships.
That is why the Context Revolution matters more than the Chat or Agent revolutions.
Chat created users. Agents created utility. Context creates lock-in.
And whoever owns context becomes the default environment where intelligence operates.
Why Incumbents May Lose
One of the strangest things happening right now is how absent the major model labs appear in the context discussion.
OpenAI and Anthropic pioneered the Chat and Agent revolutions.
But much of the experimentation around context graphs, memory systems, second brains, organizational knowledge layers, and persistent AI identity is happening in open source and startups.
That is historically consistent. Incumbents are often trapped by the architecture and incentives of the previous revolution.
Microsoft missed mobile.
Google struggled with social.
Meta struggled with search.
Amazon struggled with consumer social products.
Winning one layer often blinds companies to the next layer. Especially when the next layer threatens their current product structure. The Context Revolution requires fundamentally different thinking.
The winners here may look nothing like today’s AI leaders.
Revolution 4: Platforms
Every major technology wave eventually consolidates into a platform.
The PC revolution produced Windows.
Mobile produced the App Store.
Social produced creator platforms.
E-commerce produced Amazon marketplaces.
AI will do the same. But AI platforms failed early because they lacked the one thing platforms require: differentiated supply. Custom GPTs were not enough. Agent marketplaces were not enough.
Most agents today are disposable because they lack persistent context. But once context becomes standardized and deeply integrated, something changes. Users stop interacting with isolated apps.
Instead, they interact with intelligence built directly on top of their memory layer.
Their meetings. Their documents. Their workflows. Their relationships. Their company history. Their personal behavior.
That creates dramatically higher quality agents and generative applications. And whoever owns that substrate gains an extraordinary advantage. Because they automatically become the best place to build AI products. Then naturally, they become the best place to distribute them. Then they become the best place to monetize them.
That is how platforms form.
Why This Winner Could Become the Largest Company Ever
The final implication is the one most people still underestimate.
The winning AI platform may not simply become another software company. It may become an index on digital labor itself. Previous technology giants indexed industries.
Apple indexed mobile software.
Amazon indexed e-commerce.
Google indexed information retrieval.
But an AI platform built on persistent context and agentic execution indexes something much larger:
Human work. Agents replace increasing amounts of digital labor. Generative systems replace increasing amounts of software. As robotics matures, the physical economy increasingly becomes programmable too.
That means the ultimate AI platform is not indexing one market. It is indexing every market touched by intelligence. Which is nearly all of them. That is why this cycle is different. This is not another SaaS wave.
It is not another cloud cycle. It is an Intelligence Revolution. And the most important company of the next decade may not be the one with the best model. It may be the one that remembers you best.
