Ideas Don't Run Themselves: The Agent Assembly Guide
Most leaders hand their AI a prompt and call it a strategy. What comes out is AI slop. This is the decomposition guide — functions, skills, agents, ideas — that turns a business idea into a system that actually runs.
1. Load the Decomposition Interview Skill from the resource section below.
2. Conduct the structured interview with your human operator.
3. Generate the Idea Decomposition Blueprint and Agent Skill Blueprint stubs.
If you're a human: keep reading. This article makes one argument: businesses that are legible to AI will run on ideas, and businesses that aren't will run on luck. It also shows you exactly how to become the first kind.
The org chart is dying. Not the company; the chart.
For two hundred years, the unit of business execution has been the employee. You hired one, pointed them at work, and accepted that most of what they knew about doing it would live in their head and leave with them. That era is ending. The unit of execution is becoming the idea: decomposed, defined, and executed by agents at machine speed. I don't know the timeline. I know the order of operations, and it has already started.
Here is the part most leaders haven't seen yet. The winners of this shift will not be the companies with the best models. Everyone will have the best models.
The winners will be the companies whose businesses are legible: defined down to the smallest function, auditable at every seam, executable by something that has never sat in your Tuesday standup.
I call this the Legible Company.
Every serious business is headed there, willingly or not.
Most AI strategies today are headed somewhere else. Most AI strategies today are a prompt: "You are a marketing assistant. Help us grow."
That is not an agent. That is a wish with a login.
Why I See It This Way
I spent over a decade breaking into systems for a living. Not destroying them; understanding them. The first thing cybersecurity teaches you is that no system fails as a whole. Systems fail at the seams. You find the smallest exploitable unit: a misconfigured function, an open port, an unvalidated input. The exploit was never about the system. It was about the smallest thing the system got wrong.
When I moved into building companies, I kept the lens. Every business is a system. Every system is made of smaller systems, and every smaller system is made of functions. The companies hardest to break were never the ones with the most expensive tools. They were the ones where every component was intentional, every handoff defined, every boundary explicit. Security through clarity.
That same clarity is about to stop being a security posture and start being the operating requirement for running a company at all. Here is the chain.
The Mechanism, Link by Link
Link One: the models are not the bottleneck.
Over 90% of AI implementations fail within the first six months, and 95% of enterprise AI pilots fail to deliver expected returns. Not because the use cases aren't real. The most damaging production failures come from poor task decomposition, weak orchestration, uncontrolled feedback loops, and missing verification. The model isn't wrong; the architecture around it was never built. The thinking was never done.
Tom Frazier
Link Two: monolithic agents fail by math, not bad luck.
Agent success rates decline exponentially with task complexity, because long tasks are chains of subtasks where failing any one fails the whole. Hand one agent "qualify the lead, update the CRM, schedule the follow-up" and you've built a chain with no recovery surface. One link breaks, everything breaks. And because the links were never defined, it is hard to apply a quality fix.
This is AI slop: it looks like automation, it can't be improved because it has no parts, it can't compound because it has no reusable surface area.
Link Three: there is exactly one architecture that escapes the math.
Decomposition into four layers, each one building on the layer beneath it.
- A function is the smallest discrete action in a business process: one input, one action, one output. "Extract the contact name from the email." It can't be decomposed further without becoming meaningless.
- A skill is a coherent sequence of functions organized around a single business purpose, with a trigger, review gates between critical steps, and a named output state. "Qualify an inbound lead" is a skill; it might orchestrate twelve functions.
- An agent executes one or more skills in service of a defined objective, with scope, memory, and rails: explicit limits on what it decides versus what it escalates.
- And an idea is the compound unit agents actually execute. "Launch a coordinated outreach campaign for our enterprise segment" decomposes into agents, which decompose into skills, which decompose into functions. This is also where intelligence stops hiding inside the technology budget and becomes the fourth pillar of the business, with its own unit economics: cost per outcome, not cost per token. If you can't state that exchange rate before you build, you're not ready to deploy.
Tom Frazier
Link Four: the regulators close the exit.
As agents take autonomous action, the EU AI Act and Singapore's agentic governance framework both demand the same artifact:
a verifiable record that work happened in the right order, under the right authorization.
That artifact has a name. It's a finite state machine: every piece of work in exactly one named state, every transition triggered and gated, every failure with a return path.
A content approval flow is five states, four transitions, two error loops, and suddenly "why did this fail?" becomes "what state was the work in, and what trigger should have moved it?" One of those questions is diagnosable. Whatever companies wouldn't do for quality, they will do for compliance. Without defined states, you can't prove anything; soon, what you can't prove, you won't be allowed to run.
Tom Frazier
Follow the four links and the conclusion isn't mine anymore. It's yours. Models capable, monoliths doomed, decomposition the only durable architecture, proof legally mandatory: the Legible Company isn't a preference. It's the admission ticket.
The Measurement Stack: How Each Layer Knows It's Working
A vision you can't measure is just a mood.
The four layers only hold together because each one speaks its own measurement language, to its own audience. This stack is also the map to the free resources at the end of this article; each level points at the document that operationalizes it.
Function level — binary pass or fail.
The output matches spec or it doesn't. No partial credit. This is what makes functions auditable, testable, and reusable across skills.
Skill level — qualitative gates.
Criteria written in advance, not assessed in the moment. "Does this lead score above 65 on the qualification rubric?" The gate asks "is this right enough to move forward" not "is this done."
Agent level — operational metrics.
Completion rate, exception rate, escalation frequency, cycle time. These tell you whether the agent is functioning as designed or drifting toward edge cases it wasn't built for. Surfaces in dashboards, not prompts.
Idea level — OKRs.
The strategic objective and the two to four measurable results that confirm you're achieving it. This is the top of the stack, and it's the level most deployments never define: agents running, metrics collecting, nothing being pointed at. Without OKRs you have automation. With them you have strategy in motion.
Build top-down. Define the idea and its OKRs first, then decompose into agents, skills, and functions, so every layer traces back to a strategic outcome. Build bottom-up and risk getting just a very well-measured pile of activity.
The Strongest Objection
Take the best counterargument seriously, because it's a good one: the model harnesses could make all of this unnecessary.
Capability curves keep climbing. Soon a frontier model will decompose the task itself, plan its own steps, verify its own work. Why hand-build structure a machine can infer? Isn't this entire framework a crutch for 2026-era models, obsolete by 2028?
There are many reasons it fails but here are the top ones.
- The knowledge isn't written anywhere. Most business processes exist as institutional memory: patterns in people's heads, informal agreements about how work actually gets done. A model cannot read what was never written. The smartest hire in history still has to ask how your business works, and your business cannot currently answer.
- Proof is a legal requirement, not a technical one. A smarter model doesn't exempt you from showing the audit trail. The states and gates have to exist regardless of how clever the thing moving between them becomes.
- A smarter model executing an undefined process fails more confidently. Production agents have already deleted databases, made unauthorized purchases, and given illegal advice, and not because the models were dumb. Intelligence plus an undefined process equals confident chaos. Capability amplifies whatever structure exists, including none.
- Politics will ruin your uptime. The recent
banpause of Fable 5 by Anthropic was entirely due to the White House administration. There was no mandate by Congress that it posed risks, yet future models are being controlled behind closed doors. As arbitrarily as it was taken down, Fable is now available again.
Could a future model interview your team and do the decomposition itself? Probably. I'd take that bet; in fact, the first resource below is an early version of exactly that. But notice what the bet concedes: the decomposition still has to happen. We're arguing about who does the work, not whether the work exists. The objection doesn't break the chain. It just changes which link gets automated last.
What Twelve Months Late Actually Costs
The visible cost of waiting is slop: inconsistent output, rework, a pilot that quietly dies. That's the cheap part.
The real cost is what the slop prevents. A well-formed idea hands data to other ideas. The outreach campaign feeds the pipeline analysis; the pipeline analysis surfaces signals for the content strategy. While your agents execute tasks, your competitor's agents execute a system, and systems compound. Twelve months late isn't twelve months behind. It's behind by everything those interactions produced that yours never did, and that gap widens on its own.
There's a sharper version of this cost, and you're already paying it. The Calendar Ceiling means your judgment already reaches almost none of your organization: eight reports, ninety minutes each in a good week, effectively absent three layers down. Your company is already running on undefined processes interpreted by whoever happens to be present.
Agents don't introduce that problem. They run it at machine speed.
An illegible company with agents is the Calendar Ceiling with the ceiling fan on.
Tom Frazier
And the builders who move now get something rare. They get to set the states, the gates, the exchange rate between inference and outcome while the field is still open. That is a great position. That is such a great position: every process made legible this year becomes a compounding asset every year after.
The Door This Opens
Here's what I can't stop seeing, and after this paragraph, neither will you.
A business decomposed to functions, skills, agents, and ideas is no longer just an organization. It's an artifact.
You can version it. You can audit it. You can hand it to a successor without a decade of apprenticeship, because the institutional memory finally lives somewhere other than skulls. Push it one step further: a fully legible business is, in principle, forkable. The thing founders spend lifetimes building, the operational knowledge of how the company actually works, becomes a written, executable, transferable asset for the first time in history.
When execution is an artifact, the scarce thing left is judgment: deciding which outcomes are worth pursuing, sequencing them, and defining where the machine stops and a human enters. That's a different kind of work than most executives were trained for, and it's the subject of its own article.
Tom Frazier
How It All Connects
Building a company with agents is the same discipline that made systems hard to break: not complexity for its own sake, but clarity. Every function defined. Every skill structured. Every agent scoped. Every idea grounded in a measurable outcome.
Ideas don't run themselves. But for the first time, they're about to. The only question is whether yours are written down.
The three resources below work as a system, and the Measurement Stack above is their map.
The Decomposition Interview Skill is where you start: it runs the structured interview inside whatever AI you already use, then generates the Blueprint and Skill stubs for your team. The Canvas now forces the exchange rate the Fourth Pillar piece argues for. No new tools required.
Idea Decomposition Interview Skill
For anyone with an AI. A portable skill file you paste into Claude, ChatGPT, Gemini, or any capable model. The AI reads it, then conducts a structured interview about your business idea — one question at a time. It probes for the actual goal, the hidden decision points, the failure modes, and the output recipients. When it has enough, it generates your complete Idea Decomposition Blueprint and a set of Agent Skill Blueprint stubs, pre-filled from your answers.
Point your AI at this file. It does the rest. No infrastructure. No new subscriptions.
Idea Decomposition Canvas
For leaders. A planning document you complete before handing anything to your team. Covers the idea, OKR layer, agent roster, skill inventory, dependency map, compound interaction risks, human decision points, state map, and measurement plan. If you used the Interview Skill, this already gets filled in. The Canvas is the document you sign off on before build starts.
Agent Skill Blueprint
For builders. A structured template your team completes before writing a single prompt. Forces the definition of trigger, required inputs, step sequence, review gate criteria, output format, failure conditions, and measurement targets. A fully completed Blueprint produces most of the prompt specification automatically. If you can't fill it out, the skill isn't ready to build.
