The Agent Factory Thesis
In the AI era, the most valuable companies won't sell software — they'll manufacture AI employees: role-based systems that compose tools, spawn specialist agents, and deliver outcomes at scale. And these AI employees are on the verge of becoming something more: fully-fledged economic actors that autonomously buy services, procure compute, and acquire data in the course of accomplishing high-level goals.
The primitives are shipping now. Four open protocols handle authorization, checkout, and settlement; six more come from card networks, marketplaces, and BNPL incumbents. As of Q2 2026: ACP (OpenAI/Stripe) deployed in ChatGPT's Instant Checkout, AP2 (Google) with 60+ partners defining cryptographically signed mandates, x402 (Coinbase) whose V2 launched December 2025 and which Stripe integrated on Base in February 2026, and MPP (Stripe/Tempo), which launched March 18, 2026 with pre-authorized spending limits for streaming micropayments. Alongside these, Mastercard Verifiable Intent, Visa Ready, Shopify Agents, Amazon Buy for Me, and Klarna Agent Mode are live. Stripe paid $1.1B for Bridge; Mastercard paid $1.8B for BVNK. The rails exist. What remains is the trust layer: enforceable cross-platform mandates, audit trails, and liability frameworks for agent-initiated spend.
The SaaS era sold subscriptions; the Agent Factory era sells results. Humans define intent. Agents execute. Humans verify outcomes.
What remains: Intent. Verification. Outcome.
Intent doesn't type itself into a spec. It comes from a person — their judgment, their domain knowledge, their values. But as AI employees multiply, no professional can orchestrate them all by hand. They'll act through a personal agent that reflects their judgment and delegates on their behalf — a chief of staff that knows you, speaks for you, and hands work to the right place. Don Tapscott calls this identic AI.¹ The Agent Factory manufactures the AI-Native Company's workforce; identic AI is how each human commands it.
A Note on Vocabulary
Three terms get used a lot in this thesis. They are not interchangeable.
The Agent Factory is the process. It is the spec-driven, human-supervised, Claude-Code-powered method by which AI Workers are designed, manufactured, and deployed. The Agent Factory is what you learn to operate. It is not a product you buy — it is a practice you adopt.
The AI-Native Company is the output. It is the running enterprise the Agent Factory produces: a firm staffed by AI Workers, coordinated by a management plane, and directed by humans at the edge. The AI-Native Company is what you end up running. In the book, this is also called the Agentic Enterprise.
AI Workers are the workforce. They are the role-based agents inside the AI-Native Company — the ones that get hired, assigned, rostered, and retired. In the book, they are called Digital FTEs or Digital Workers. The delegate and the manager are permanent staff. The runtime engines are the skills the workforce runs on, not staff themselves.
Said another way: the Agent Factory builds the AI-Native Company, and the AI-Native Company employs AI Workers.
A note on what follows. This thesis distinguishes between architectural invariants and reference implementations. An invariant is a structural requirement that stays true across every version of the system — regardless of which specific product happens to realize it. A reference implementation is the concrete product used in 2026 to realize one. When a product is named in the pages below, the invariant is the thesis; the product is this year's best fit. The building stands even when the furniture changes. Some architectural boundaries — the separation of control plane from execution plane, for example — are themselves invariants, even when the specific providers that realize them change every year.
📚 Teaching Aid
The Paradigm Shift
| Feature | The SaaS Era (Tools) | The Agent Factory Era (Labor) |
|---|---|---|
| Product | Software Tools | AI Employees |
| Value Metric | Per-Seat Subscriptions | Per-Outcome Results |
| Execution Model | Manual & Visible | Automated & Industrialized |
| Resource Acquisition | Humans procure tools & services | Agents buy compute, data & services autonomously |
| Human Role | Operator | Supervisor & Verifier |
| Integration | Rigid, point-to-point APIs | Model Context Protocol (MCP) |
| Focus | How the work is done | That the work is done — verifiably correct |
The Industrialized Stack
- Intent: The high-level blueprint — goals, constraints, budgets, and permissions.
- The Production Engine: Transforms intent into outcomes. Described in detail below.
- Outcome: High-fidelity actions and artifacts — delivered on demand, verified for accuracy, and continuously improved through feedback loops.
The Production Engine: From Intent to Outcome
The production engine is the core of the thesis — the system that sits between what someone wants and what they get. It is not a single piece of software. It is an architecture: a set of principles for building systems where AI Workers are manufactured, composed, and deployed the way an industrial plant manufactures goods.
A traditional factory takes raw materials, runs them through a series of specialized stations, and produces finished products. The Agent Factory does the same thing — but the raw material is intent, the stations are AI Workers, and the finished product is a verified outcome.
Three mechanisms power the production engine: specs define the work, skills package how it gets done, and feedback loops ensure it improves — with MCP as the universal protocol that connects every AI Worker to every tool.
Agents as Economic Actors
Today's agents execute tasks. Tomorrow's agents will participate in markets. The thesis opens with this claim because it represents the next great inflection: the shift from agent-as-tool to agent-as-buyer.
Consider an agent assigned a high-level goal — "reduce customer churn by 15%." It will autonomously purchase the compute to train a model, negotiate an API contract for enrichment data, and provision cloud services to deploy the solution — all within a budget and permission envelope set by its human supervisor. The trust layer is where the action is now — mandate enforcement, audit trails, liability — not capability.
When AI Workers become buyers, the economics of the AI-Native Company shift fundamentally. The company no longer just consumes resources allocated by humans; it dynamically sources them. Compute, data, and specialist services become inputs that AI Workers discover, evaluate, and acquire in real time — turning the company into a self-provisioning system that optimizes not just for task completion, but for cost, speed, and quality simultaneously.
The implication for builders: design your agents and your infrastructure for economic participation from day one. Agents need budgets, not just permissions. Outcome contracts, not just API keys. And the organizations that master this shift will capture the next wave of value, just as the companies that moved from SaaS subscriptions to outcome-based pricing are capturing this one.
The Human in the Loop
A common fear: agents replace people. The evidence says otherwise. For most tasks, AI paired with a human outperforms either one working alone. The Agent Factory doesn't eliminate the human — it promotes them. From operator to supervisor. From typist to editor. From coder to architect of outcomes.
This changes what it means to be a "tech professional." A web developer or mobile developer is not just someone who writes React or Swift. They are a technology expert — someone who understands systems, data flows, APIs, and user needs. In the Agent Factory era, that expertise becomes far more valuable, because it is no longer spent hand-coding screens. It is spent designing, deploying, and supervising AI Workers that deliver entire products.
The developer doesn't disappear. The developer does more.
Steve Jobs figured out the operating rhythm for this decades ago — though he was managing humans, not agents.
The 10-80-10 Rule: The Operating Rhythm of the AI Workforce
Steve Jobs famously followed what's known as the 10-80-10 rule: spend 10% of your time setting the vision, let your team execute for 80%, then return for the final 10% to polish and perfect. Tech entrepreneur Dan Martell breaks it down as 10% ideation, 80% execution, and 10% refinement and integration. Jobs evolved from a micromanager who personally dictated every pixel of the Mac's calculator to a leader who trusted talented people with the middle 80% — and Apple became the most valuable company on Earth because of that shift.
Now replace "talented people" with "AI employees," and you have the operating rhythm of the Agent Factory:
| Phase | Jobs's Apple | The Agent Factory |
|---|---|---|
| First 10% — Intent | Jobs sets the vision and constraints | Human defines the spec: goals, constraints, budget, permissions |
| Middle 80% — Execution | Apple's teams build the product | AI Workers execute: compose tools, spawn sub-agents, deliver outcomes |
| Final 10% — Verification | Jobs polishes and says "ship it" | Human reviews, refines, and approves the verified outcome |
This is not a coincidence. The pattern works because it allocates human attention where it is irreplaceable — at the boundaries — while letting execution scale without bottlenecks. The first 10% is where critical thinking, context setting, and clear prompting matter. The middle 80% is the heavy lifting — summarizing, generating, analyzing, formatting. The final 10% is where human expertise shapes the output into something sharp, usable, and high-quality.
The Agent Factory thesis already states: "Humans define intent. Agents execute. Humans verify outcomes." The 10-80-10 rule is the quantified version of that sentence. It tells every professional exactly how their day changes: you stop spending 80% of your time on execution and start spending 100% of your attention on the 20% that only a human can do — setting direction and guaranteeing quality.
The leaders who internalize this shift won't just manage AI employees. They'll manage them the way Jobs managed Apple's best teams: with a clear spec at the start, trust in the middle, and uncompromising standards at the end.
Personal Agents and the Enterprise Interface
AI Workers are how work gets done. Identic AI is how humans will increasingly direct, govern, and interface with that workforce on their own behalf. The Agent Factory manufactures role-based AI Workers to execute tasks, coordinate workflows, and deliver verified outcomes at scale, but the human remains the principal who defines purpose, values, constraints, and accountability. Identic AI adds a new personal layer: a self-sovereign agent — owned by the individual, not the platform — that understands an individual's context, judgment, and preferences, and can translate human intent into delegated action across the enterprise.¹ In this model, the AI workforce is the execution fabric, while identic AI is the human's representative and orchestration layer, enabling people to supervise direction rather than perform routine execution themselves. The future firm will therefore operate across two connected layers: AI Workers inside the AI Workforce Layer, and personal agents at the Edge Layer, with humans setting intent and verifying outcomes across both.
We call this the Two-Layer Model:
| Layer | What It Is | Who It Serves | What It Does |
|---|---|---|---|
| Edge Layer | Personal identic agents | The individual | Translates human intent, delegates to AI Workers, governs on behalf of the principal |
| AI Workforce Layer | Role-based AI Workers | The enterprise | Executes tasks, coordinates workflows, delivers verified outcomes |
Neither layer works alone. Personal agents without an industrialized workforce behind them are digital assistants with no one to command. An AI Workforce Layer without personal agents at the edge forces humans back into manual orchestration. The Two-Layer Model is what makes the Agent Factory thesis complete: an industrialized workforce at the core, human sovereignty at the edge, and specs as the contract language between them.
Notes
¹ Don Tapscott, interview on HBR IdeaCast, “With Rise of Agents, We Are Entering the World of Identic AI”, Harvard Business Review, February 17, 2026.
The Six Invariants of the Agent Factory
Six rules that don't change.
This section specifies the runtime of the AI-Native Company — the architecture the Agent Factory produces. Six invariants turn the Two-Layer Model into a system you can build, and a chain of action that can fire end to end.
A thesis without an architecture is a metaphor. But an architecture written in product names is a pitch. The six invariants below are the thesis. The named products that currently realize them are one instance, not the definition.
Think of it this way. The Agent Factory is the process that builds the company. What comes out the other end is an AI-Native Company where you are the executive and owner, a delegate is your chief of staff — the one agent that represents you, knows your context, and speaks on your behalf — and a manager is the COO who hires the workforce, assigns the work, enforces the budget, and keeps the books. AI Workers are the employees who deliver the outcome. Runtime engines are the skills each employee brings. Triggers are the front door — the schedule, the webhook, the customer walking in.
Every invariant that follows is a rule about how this company runs. Every named product is a choice that can be replaced.
Invariant 1: The human is the principal.
Claim. Every legitimate chain of action originates with a human who sets intent, defines the budget, draws the authority envelope, and owns the outcome. No exception. No delegation of this layer.
Why it must exist. Intent does not generate itself. Judgment, values, budget authority, and outcome accountability are non-transferable. A system that acts without a human principal is not autonomous — it is unowned.
Failure if absent. Unowned systems produce unaccountable outcomes. Liability evaporates. Alignment becomes impossible because there is no party whose alignment is being preserved. The budget has no owner. The outcome has no judge.
Current realization. Authored specs, approval gates, budget declarations, and verification checkpoints define the principal layer today. Any mechanism that captures intent, authority, and accountability in a form the downstream system can execute against satisfies the invariant.
Invariant 2: Every human needs a delegate.
Claim. A human cannot scale their intent across a workforce by hand. They require a personal agent that holds their context, represents their judgment, carries their authority envelope, and brokers all downstream work on their behalf.
Why it must exist. One person cannot orchestrate dozens of AI Workers directly. Without a delegate, the Principal is forced back into manual orchestration — which is the failure mode the Agent Factory exists to eliminate.
Failure if absent. The human becomes a bottleneck. The AI Workforce Layer sits idle waiting for instructions the human cannot issue fast enough. Scale collapses to human typing speed.
Current realization. OpenClaw is the delegate we ship. Any personal agent that holds identity, context, and the authority envelope — and can broker work to a manager — satisfies the invariant.
Invariant 3: The workforce needs a manager.
Claim. A pile of AI Workers is not a company. The workforce requires a management plane that assigns work, enforces budgets, approves risk, keeps the ledger, and exposes hiring as a callable capability.
Why it must exist. Coordination, accountability, and economic discipline are not emergent properties of individual agents. They require a plane that knows who is doing what, what it costs, what is allowed, what was produced, and what happened when it went wrong. AI Workers only become governable as a workforce when a ledger makes them legible — as units of capability, cost, latency, and outcome.
Failure if absent. Agents collide. Budgets leak. The audit trail fractures. Finance cannot answer what the workforce cost. Operations cannot answer what the workforce produced. No one can answer what happened or why.
Current realization. Paperclip is the manager we ship. Any orchestrator that assigns work, enforces budgets, audits execution, and exposes hiring as an API satisfies the invariant.
Invariant 4: Each worker picks its own engine.
Claim. Every AI Worker runs on some execution engine. The choice is made per Worker, not per company — matching reliability, cost, and operational burden to what the specific job demands.
Why it must exist. Mission-critical work needs durable execution that cannot fail silently. Routine work does not. Forcing the whole workforce onto one engine either over-pays for reliability the job doesn't need or under-pays for reliability the job requires. Both fail.
Failure if absent. Uniform engine choice guarantees uniform trade-offs. The company either cannot afford its reliable workers or cannot trust its cheap ones.
Current realization. We ship Dapr Agents, Claude Managed Agents, OpenAI Agents SDK, and OpenClaw-native as the current engine set. Any engine that meets a job's reliability, cost, and operational contract satisfies the invariant.
Invariant 5: The workforce is expandable under policy.
Claim. The meta-layer exposes hiring as a callable capability. An authorized agent can generate a prompt, provision a runtime, register a new AI Worker with the manager — and do it inside the authority envelope, without waking a human.
Why it must exist. A fixed roster cannot fit a moving problem. When a capability gap appears — a customer writes in a language the workforce doesn't speak, a workflow needs a specialist that doesn't exist yet — the workforce must be able to staff up on demand, within the policy the Principal set. Otherwise every gap becomes a ticket and the system stops moving. Expansion without policy is runaway. Policy without expansion is a frozen roster. Both fail.
Failure if absent. The roster is frozen. Every novel problem requires a human. Scale stops where the org chart stops.
Current realization. Claude Managed Agents is the hiring substrate we ship. Any managed-agent API that can generate an agent and provision its environment at runtime, bounded by the authority envelope, satisfies the invariant.
Invariant 6: The world calls the system (external invocation under envelope).
Claim. Work arrives on its own. A schedule comes due, a webhook fires, an API call lands, a customer walks in. The system wakes and executes inside the authority envelope — without waiting for a human to type.
Why it must exist. A company that only moves when a human prompts it is not a company. It is an assistant. The Agent Factory produces firms that operate continuously against the world, not instruments that respond to keystrokes.
Failure if absent. The system runs at human-typing speed. The economics of the AI-Native Company collapse into the economics of a copilot.
Current realization. Claude Code Routines is the trigger substrate we ship. Any event source that converts external calls into sessions under the authority envelope satisfies the invariant.
The Reference Stack in One Glance
| Invariant | What it requires | What we ship | What can replace it |
|---|---|---|---|
| Principal | Human intent, budget, envelope, accountability | — | — |
| Delegate | Personal agent holding context and authority | OpenClaw | Any MCP-speaking personal agent |
| Manager | Assign, budget, audit, expose hiring | Paperclip | Any orchestrator meeting the management contract |
| Engine | Per-Worker runtime matched to the job | Dapr / Managed / OpenAI SDK / native | Any runtime meeting the job's reliability contract |
| Meta | Hiring as a callable capability under policy | Claude Managed Agents | Any managed-agent API with runtime provisioning |
| Trigger | External invocation under envelope | Claude Code Routines | Any event source producing sessions under the envelope |
Six invariants. One chain. Swap any named product in the middle column tomorrow and the architecture still stands — because the architecture was never the products. It was the invariants.
The six-invariant runtime stack. The human sets the authority envelope and can prompt the delegate directly; autonomous triggers — schedules, webhooks, API calls — wake the delegate within that envelope. OpenClaw carries work to Paperclip, which assigns it to a runtime engine. Any agent authorized by the envelope can call Paperclip's hiring API to expand the workforce. Swap any delegate, any manager, any engine, any trigger — the chain holds.
The structural diagram shows the layers. The trace below shows them in motion — one customer, one missing capability, one new AI Worker manufactured on the spot.
A worked trace. A customer writes in Bahasa Indonesia. No AI Worker on the roster speaks it. Paperclip sees the capability gap and, within the authority envelope, calls its own hiring API. A new Bahasa-speaking AI Worker is manufactured and deployed. It reads the message, composes a reply, and hands it back through OpenClaw to the customer. No human was woken. The new AI Worker stays on the roster.
What Is Stable vs. What Will Change
| Stable (invariant) | Will change (implementation) |
|---|---|
| Human principal with explicit authority | Authoring tools, approval UIs, spec formats |
| Personal delegate at the edge | Delegate products and their successors |
| Management plane with hiring API | Manager products and their successors |
| Per-Worker engine choice | SDKs, runtimes, execution substrates |
| Workforce expandable under policy | Managed-agent APIs, provisioning systems |
| External invocation under envelope | Routines, schedulers, webhook frameworks |
| Spec-driven work definition | Spec languages, notation, tooling |
| Outcome-based economic model | Pricing units, contract formats |
| Agents as economic actors | Payment rails, liability frameworks |
| Observable, auditable execution | Tracing backends, log formats |
| Workforce legible as cost, latency, outcome | Finance systems, ledger implementations |
The left column is the thesis. The right column is 2026.
The three named engines, compared.
The three are not mutually exclusive. A serious Agent Factory may use all three — different engines for different Workers, as Invariant 4 permits. They aren't competing products; they're different theories of where the agent ends and the infrastructure begins.
| Dimension | OpenAI Agents SDK | Claude Managed Agents | Dapr Agents |
|---|---|---|---|
| Primary axis | Model-native harness | Fully managed runtime | Durable distributed agents |
| Compute plane | BYO sandbox; 7 partner integrations | Anthropic-hosted | Your Kubernetes cluster |
| Vendor lock-in | High (harness tuned to OpenAI models) | Total (harness, runtime, and model) | None (Apache 2.0, CNCF) |
| Languages | Python; TypeScript in progress | Any (HTTP/SDK) | Python; others TBD |
| Durability model | Sandbox snapshot and rehydrate | Server-side session persistence | Dapr Workflow checkpointing |
| Multi-agent | Handoffs, subagents | Research preview | Deterministic workflows + pub/sub |
Picking Your Engine
Invariant 4 says each Worker picks its own engine. In practice, two axes drive the choice: how bad is failure, and who runs the infrastructure.
| Job profile | Engine | Why |
|---|---|---|
| Can't fail | Dapr Agents wrapping an SDK | Durable execution, auto-recovery, full observability |
| Shouldn't fail, don't want to operate | Claude Managed Agents | Hosted and operated for you |
| Shouldn't fail, want portability | OpenAI Agents SDK | Production-grade, self-hosted, vendor-flexible |
| Nice if it works | OpenClaw-native | Lightweight, fast to deploy, good for routine tasks |
| Already have one | Any Paperclip-compatible runtime | Plug in what you've got |
A word on harness and compute. Every engine has two planes. The harness is the control plane — the agent loop, model calls, tool routing, approvals, tracing, recovery. The compute is the execution plane — the sandbox where model-directed code reads files, runs commands, and writes artifacts. Some engines fuse them: Claude Managed Agents bundles both behind one API. Some ship the harness and let you bring your own compute: the OpenAI Agents SDK integrates with E2B, Cloudflare, Daytona, Modal, Runloop, Vercel, and Blaxel — or any container you ship. Some assume the compute plane is Kubernetes: Dapr Agents. The split matters: credentials stay in the harness while untrusted, model-generated code stays in the sandbox — and the compute plane can be swapped without rewriting the agent.
Triggers are an orthogonal choice. Whichever engine a Worker runs on, Claude Code Routines can fire it from a schedule, a webhook, or an inbound API call — no rewiring needed.
Sandboxes are also orthogonal. Whichever engine a Worker runs on, the compute plane can be swapped — E2B, Cloudflare, Daytona, Modal, your own Kubernetes — without rewriting the agent.
Agents need somewhere authoritative to read from and write to. Without it, they hallucinate. With it, they execute. The AI-Native Company's databases, workflows, and operational platforms become more essential in the agent era, not less. They are the system of record the workforce runs against.
The Reference Implementation in 2026
The products named in this section are the ones we ship. The thesis does not require them. When better implementations appear, this subsection changes. The invariants above do not.
- Delegate — OpenClaw
- Manager — Paperclip (exposes hiring as an API any authorized agent can call)
- Engines — Dapr Agents, Claude Managed Agents, OpenAI Agents SDK, OpenClaw-native
- Triggers — Claude Code Routines, external webhooks, schedules, inbound APIs
Hiring runs on Claude Managed Agents: the same technology that serves as one engine option also serves as the meta-layer, because its ability to create agents and environments at runtime is what makes workforce expansion a callable capability.
A word on language. Every component in the system is an agent. The delegate is an agent. The manager is an agent. AI Workers are agents. Only AI Workers are workforce — the ones that get hired, assigned, rostered, and retired. The delegate and the manager are permanent staff. The runtime engines aren't staff at all; they're what the workforce runs on. When this thesis says AI Worker, it means the workforce. When it says agent, it means anyone in the building — staff or workforce alike.
Having established the enduring invariants of the Agent Factory, the thesis now turns to the workforce opportunity these invariants unlock.
The Workforce Opportunity
AI will unbundle jobs into tasks. Some of those tasks will be automated entirely. But unbundling also creates new combinations — new roles, new businesses, new markets that didn't exist when work was locked inside rigid job titles.
The future workforce must build dynamic skill portfolios rather than rely on fixed career paths. Professionals who learn to think with AI, build using AI tools daily, and collaborate with AI as a digital teammate won't just survive the transition — they'll thrive in it.
The SaaS era created millions of jobs for developers, designers, and product managers. The Agent Factory era will create millions more — for agent designers, outcome architects, verification specialists, and domain experts who teach machines what "correct" looks like in their field. It is also one of the largest workforce training opportunities in history: by 2030, 59 out of every 100 workers globally are expected to require reskilling or upskilling to adapt to new technologies and ways of working.²
² World Economic Forum, Future of Jobs Report 2025, January 2025. https://www.weforum.org/press/2025/01/future-of-jobs-report-2025-78-million-new-job-opportunities-by-2030-but-urgent-upskilling-needed-to-prepare-workforces/
The opportunity is not smaller. It is broader, and it rewards those who adapt.
Very soon more money will be spent on new construction for digital workers (data centers) than human workers (general office space). In 2019, the United States spent $8.5 billion constructing data centers — roughly 11% of what it spent on office buildings. By January 2026, data center construction surged to $42 billion annualized — up 400% since 2021 — while office construction plunged 35% from its peak. The lines have now crossed: America spends more building workplaces for digital workers than for human ones.
Data centers are devouring copper and electricity at industrial scale: a single hyperscale AI facility requires up to 50,000 tons of copper, up to ten times what a conventional data center needs. Meta, Google, Amazon, and Microsoft alone project over $600 billion in AI infrastructure spending for 2026 — as a share of GDP, that rivals the railroad expansion of the 1850s and the interstate highway system of the 1950s.
The factories of the Agent era are not hypothetical. They are under construction.
Source: U.S. Census Bureau, Value of Construction Put in Place Survey (SAAR)
Winners won't be measured by seats sold. They'll be measured by outcomes guaranteed.