The Framework: Six Stages, One Sprint at a Time
You’ve met the Co-Operating Model. The six-step Framework is how you build one. By the end of this chapter you’ll know the six-stage Sequence and the Sprint Planning Canvas: the one-page tool the rest of the book fills in, one row per stage, until you reach the last page with a complete map of your first Sprint.
We were mid-conversation with a CEO: Jesse, Julie, and her on the other side of the screen. She’d been talking for twenty minutes about her company, her bottlenecks, the AI-powered workflows she hoped would fix the quoting problem eating her operations lead’s time. Then she leaned forward and said it: “Can we just build the workflow? I just need this thing built.”
We knew exactly what she meant. She’d seen demos. She’d read the case studies. She had a clear picture of the tool that was going to solve her problem, and she wanted to stop talking and start building. That’s the instinct of someone who has run a business.
But we’ve also watched what happens when you start there. The spec changes. The scope expands. Edge cases surface because nobody understood the process well enough to anticipate them. The thing that was supposed to take three weeks is in week seven and still not done. A tool gets deployed, and then the team doesn’t use it because it doesn’t fit how the work actually moves. The actual constraint usually sits one or two steps upstream from where the CEO was looking.
That’s what we told her: you can’t start at Build. The conversation ended with us quoting a focused diagnostic engagement, what this book calls a Signal Sprint, and walking away from the quoting workflow until Signal named the real constraint.
Diagnose before you build
Each stage produces something the next stage requires. Signal produces a Constraint Statement. Source produces a Knowledge Map about that constraint. Design produces an accountability split that depends on both. Build executes against the Design. Deliver installs Build into the operating rhythm. Compound captures what was learned and feeds it into the next Sprint’s Signal. Skip a stage and the next one has nothing real to work against.
Skip the first two stages and you’re buying a tool. Run all six in order and you’re changing how the work is owned. That’s why the order matters. The rest of this chapter walks it.
This book uses four related words that are easy to conflate.
- Framework is the whole system you’re about to learn: the order, the stages, the cadence, the unit of work.
- Sequence is the ordered stages inside the Framework: Signal → Source → Design → Build → Deliver → Compound. Always all six, always in that order.
- Sprint is one pass through the Sequence on one validated constraint. Like a software Sprint, it’s bounded, fast, and produces a shippable outcome.
- Rhythm is what turns a single Sprint into a compounding business outcome: running another Sprint, then another, on a cadence.
Each names a different thing. You’ll meet them again as the chapter unfolds.
The six stages, in order
The Sequence is six stages, each taught later in the book. Here is the roadmap: what each stage does, the one artifact it produces, and where you’ll learn to run it.
Signal names and prices the constraint. The constraint sits beneath the symptom. “Quoting takes too long” is a symptom. “One person holds the pricing logic and her review is the queue” is a constraint. Signal produces a one-page Constraint Statement that names the failing function, the blocked outcome, the structural cause, and the cost in dollars. If you run EOS, Signal is a deeper root-cause version of IDS. You learn it in the Signal chapter.
Source maps what the organization knows about the constraint: what’s written down, what lives in systems, what lives only in someone’s head, and where the gaps are. It produces a Knowledge Map. You learn it in the Source chapter.
Design splits the work between humans and agents, role by role and handoff by handoff. It produces a Hybrid Accountability Chart (if you run EOS, this extends your Accountability Chart by adding agent seats and their human supervisors) and a Design Brief. You learn it in the Design chapters.
Build ships the working system: the prompts, integrations, knowledge layer, and observability that handle real work end to end. It produces a Build Spec and a Guardrails Checklist. You learn it in the Build chapter.
Deliver lands the system in how work actually gets done, so the team’s Monday looks different and not just the dashboard. It produces a per-role runbook and a Delivery Test measured against the cost Signal named. You learn it in the Deliver chapter.
Compound turns one Sprint into infrastructure the next Sprint runs on top of. It produces a Sprint Outcome Record and a re-ranked constraint queue. You learn it in the Compound chapter.
The two Phases: diagnose, then execute and compound
The Sequence groups into two Phases. The first is Diagnose: Signal and Source. The second is Execute & Compound: Design, Build, Deliver, Compound. Two stages, then four.
Diagnose is the abstract half. It takes more thought, its output is a constraint and a map rather than a working tool, and it’s the half most teams skip. It’s also where the payoff is. In a physical process, when something breaks you can usually see it. In an information process, a misclassified taxonomy in a knowledge base can send an agent to query the wrong data and hallucinate answers, and that stays invisible until the damage is done. Diagnose is where you find those problems before they reach execution. The two Phases are separate so each can be done well, and connected because most constraints worth a Sprint sit on top of an information problem.
When a Sprint stalls in Build, don’t troubleshoot the build. Go back to Signal, Source, and Design. The problem almost always lives in one of them, not in the implementation.
The Sprint Planning Canvas asks one question per stage
The Sprint Planning Canvas is the backbone of a Co-Operating Model. A Sprint’s plan starts scattered: the constraint lives in one person’s head, the systems in another’s, the half-formed fix in a third’s. The Canvas pulls all of it onto a single page the whole team can see and agree on, the way an EOS company gets its vision onto one V/TO. One constraint at the top, one question per stage of the Sequence beneath it, the team named, the review date locked. It’s the page the operation comes back to at every review.
You can’t answer every question yet. Each chapter ahead teaches you one, so by the last page you’ll have a complete Canvas for your first Sprint.
The six questions
One question per stage, each answered by its chapter:
- Signal — What’s the one constraint, and what does it cost? (the Signal chapter)
- Source — What does the organization know about it, and where does that knowledge live? (the Source chapter)
- Design — What does the human-and-agent workflow look like, and who owns what? (the Design chapters)
- Build — What gets built, and on what: off-the-shelf, low-code, or hand-built? (the Build chapter)
- Deliver — How do you know it worked, and what number moved? (the Deliver chapter)
- Compound — What did you learn, and what changes for the next Sprint? (the Compound chapter)
That’s the blank Canvas. A downloadable template is available at the book’s resources page.
A Sprint is bounded by scope, not by a fixed calendar. The narrowness is the discipline that prevents the failure mode every operator has seen: an AI project becoming a platform project, a platform project becoming a reorg, and eighteen months later nothing has shipped. One constraint, one documented outcome, one Sprint. Duration is set in Design and depends on the constraint. Some Sprints close in days, some run for weeks, the longest stretch across a quarter. What doesn’t stretch is the scope. The Canvas locks the constraint at the top, and the constraint is the boundary the rest of the work runs against.
The Canvas also names the people a Sprint runs on. The leadership sponsor is accountable for the outcome, not for doing the work. The Sprint Lead runs the Sprint day-to-day, owns the cadence, and holds the handoffs together; who fills it varies, often the sponsor in a small company, a delegated lead or an outside coach in a larger one.
The Human Orchestrator is the person whose role the Sprint redesigns: the upgraded worker who’ll run the new workflow and supervise its agents once it ships. They help design it during the Sprint and get trained to run it before it lands. Pull in subject-matter experts wherever the constraint’s knowledge lives; in a small shop one person often wears several of these hats. Book a review date, the quarterly session where the outcome gets measured, before Signal begins: a Sprint with no review has no deadline.
A completed Canvas looks like this
Here is what Meridian Manufacturing’s Sprint Planning Canvas looked like after they ran the full process. This is the finished artifact your own Canvas is working toward.
Run one Sprint. Then another.
The Framework is learned by running it; each stage produces something the next can’t work without, and that dependency only becomes real on one real constraint in your own company. Start a blank Canvas now if it helps, but the answers come from the work ahead.
One Sprint fixes one constraint. Run the next, then the one after, each on the back of the last: that’s the Rhythm, and it’s what turns one-off Sprints into compounding returns.
Every Sprint leaves infrastructure behind that makes the next cheaper and faster. The Hybrid Accountability Chart gains entries, the Knowledge Map gets richer, the team’s design judgment sharpens. The first Sprint is where your company learns to run the Framework. The Rhythm is what makes the change permanent.
Carry the Canvas forward.
Begin at Signal
The Sequence is the workflow. The next chapter is the first stage. Every Sprint begins at Signal, with one constraint named, quantified, and validated before anything else moves.
Reflection Questions
- The chapter opens with a CEO who wanted to “just build it.” Have you or your team jumped to Build before running Signal and Source? What did that cost in time, money, or a tool the team stopped using?
- Read the six questions on the Canvas. Which ones can you already speak to about your top constraint candidate, and which are blank? The blanks are a map of what the stage chapters still have to teach you.
- The Sequence splits into Diagnose (Signal, Source) and Execute & Compound (Design, Build, Deliver, Compound). If your last AI initiative stalled, which Phase did it fail in, and what was the specific stage where things went sideways?
- Who in your company would be the Human Orchestrator for your first Sprint, the person who owns execution rather than outcomes? Is that person’s name already written down, or is that seat still vacant?