The Agent Factory: Scaling Agents by Design, Not by Accident
An agent factory is not a team that builds agents faster. It's an operating model that decides better which agents to build, and then industrializes everything after that decision. It runs in two phases. Envisioning and rapid prototyping, where ideas pass a structured assessment funnel into a small number of proofs of value. And implementation excellence, where the survivors move through defined development stages on a shared foundation of architecture, governance and change. Projects don't scale. Systems do.
The problem the factory solves
After the first agents prove useful, every organization hits the same wall. Demand explodes and delivery doesn’t. Fifty ideas arrive from the business. Three developers build heroically. Nobody knows which requests deserve the effort, and every agent becomes a bespoke project with its own architecture debate, its own security discussion and a maintenance question nobody wants to own.
The instinctive answer is more builders. The right answer is a system. That’s what the Agent Factory is: the operating model I use in enterprise programs to turn agent building from serial heroics into a repeatable production line. I present this framework on stage regularly, and the slide that gets photographed most is the funnel. There’s a reason for that.
Phase 1: Envisioning and rapid prototyping
The first phase exists to protect the second. Its job is business alignment and evaluation. In plain terms: making sure that what enters the factory deserves to be there.
All ideas enter one structured intake. Each gets assessed against business value and feasibility, and before anything else, against the skill-or-agent decision from the Governance Guide: does this task need an actor, or just a play? A good chunk of “agent requests” exit the funnel right here, as skills, prompts or plain process fixes. That’s the cheapest win the factory produces, and most organizations never collect it.
What survives becomes a small set of parallel proofs of value. Deliberately small. And the wording matters here. A proof of concept asks “can we build it?”, and the answer is almost always yes, which proves almost nothing. A proof of value asks “does it move a metric someone owns?” Each POV enters with a named business owner and a defined outcome hypothesis. Each one exits with a decision: scale, park, or kill.
Killing a POV is a factory success, not a failure. It’s the funnel doing its job late instead of never.
Phase 2: Implementation excellence
Candidates that prove value enter the production line. Multiple agent projects run in parallel through the same defined development stages: initialization, experimentation, evaluation and refinement, deployment and operations, continuous improvement. Same stages, same quality gates, same agile delivery method, every time. The repetition is the point. Your tenth agent should cost a fraction of your first, because nothing about how it gets built is decided anew.
What makes the parallel line possible is the foundation underneath it. This is the part most organizations skip, and then rebuild in a panic twelve months later. Seven concerns, solved once, inherited by every agent:
↳ AI architecture design: reference patterns instead of per-project invention
↳ Change and enablement: adoption isn’t an afterthought per agent, the Adoption Playbook applies here too
↳ Vendor management
↳ Regulatory and legal: in the DACH context that means EU AI Act readiness and works-council involvement, handled at foundation level instead of renegotiated per agent
↳ Data engineering: agents are only as good as the data they inherit, which is the whole point of the Governance Guide
↳ Interfaces and MCP servers: standardized ways for agents to reach systems
↳ Governance, compliance and security: registry, identity, lifecycle, wired into Agent 365 and Entra Agent ID from day one
What the factory is not
It’s not a central team that builds everything. That’s the bottleneck, and the bottleneck doesn’t stop building. It just pushes building into the shadows. The factory is the system through which distributed building becomes safe: clear intake, shared foundation, common stages. Business teams keep proposing and co-owning. The factory keeps the standards.
And it’s not a tooling purchase. Copilot Studio, Foundry, Agent 365: those are the machines. The factory is the layout of the plant. Who decides what, in which order, against which gates. Buying more machines without a plant layout produces exactly the forty-agent graveyard the Governance Guide describes.
Where organizations get it wrong
Three failure patterns show up again and again in my projects.
Starting with Phase 2. Building infrastructure for demand that hasn’t been qualified gives you an empty factory with excellent conveyor belts.
Skipping the funnel under pressure. “Just build it, it’s urgent” turns the factory back into a project shop within a quarter. The funnel only works if urgent requests go through it too. Especially then.
Measuring the factory by agents shipped. That’s the fastest way to produce many agents nobody needed. The honest KPIs: funnel throughput with exit reasons, POV-to-scale conversion, cost per agent over time, and the business metrics that actually moved.
Your next step: the factory readiness check
- Do agent ideas enter through one structured intake, or through whoever shouts loudest?
- Does every candidate pass the skill-or-agent decision before anyone builds?
- Do your POVs enter with a named business owner and an outcome hypothesis?
- Could your teams describe the standard stages an agent moves through, identically?
- Which foundation concerns (architecture, legal, data, interfaces, governance) are solved once, and which get renegotiated per project?
Three or more gaps: you don’t have a factory. You have talented people compensating for the absence of one.
The guide gives you the model. Training happens differently.
- Weekly training rhythm: Copilot Your Day, every Monday at 7:30 CETSubscribe to the newsletter
- Live: the "Become a Frontier Firm" keynote, or an executive briefing with your numbers on the tableSpeaking →
- In your organization: full transformation programs are the work I do with my team at Campana & Schott. The contact page points the way.
FAQ
How do we get from single agents to an agent factory?
Install the two phases in order. First the intake side: one structured funnel, the skill-or-agent decision as entry gate, POVs with named owners and outcome hypotheses. Then the production side: standard development stages and the shared foundation. Most organizations do it backwards, infrastructure first and qualification never. Pascal Brunner-Nikolla, Microsoft MVP for M365 Copilot & Agents, sums it up like this: the factory doesn't build agents faster, it decides better which agents to build.
What is a proof of value, and how is it different from a proof of concept?
A proof of concept asks whether something can be built. The answer is almost always yes, and it proves little. A proof of value asks whether the agent moves a metric a business owner cares about, with a defined hypothesis and a scale, park or kill decision at the end. Factories run POVs, not POCs.
Who should own the agent factory?
Jointly. The business owns the funnel input and the value hypotheses. IT owns the foundation and the stages. A small factory lead function owns the standards and the gate decisions. A factory owned by IT alone builds technically excellent agents nobody asked for. Owned by the business alone, it rebuilds the governance debt the funnel was meant to prevent.
How many agents should we build in parallel?
Fewer than your idea backlog suggests. The funnel exists to keep the parallel POV set small enough that each has a real owner and a real decision at the end. Scaling the parallel line is a Phase 2 capability that grows with the foundation. It's not a launch ambition.
What belongs in the AI foundation before scaling agents?
Seven concerns, solved once: reference architecture, change and enablement, vendor management, regulatory and legal (EU AI Act and works council in DACH), data engineering, standardized interfaces including MCP, and governance wired into the platform controls (agent registry, identity per agent). Every concern left unsolved at foundation level gets renegotiated per project, at a multiple of the cost.
How do we measure whether the factory works?
Not by agents shipped. Track funnel throughput with exit reasons (including how many requests correctly became skills instead), POV-to-scale conversion, cost and cycle time per agent over time (the tenth must be far cheaper than the first), and the business metrics the scaled agents move. An impressive agent count with flat business metrics is the factory failing loudly.
Where to go deeper
- Skills vs. Agents: The Governance GuideThe entry gate of the funnel, in full.
- The Adoption PlaybookThe change-and-enablement foundation the factory inherits.
- Episode 98 — Agent Factory BlueprintThe newsletter origin of this framework.
- Episode 111 — Agent 365 is GA. All You Need to KnowThe control plane the factory's governance layer builds on.