I. I was right, and it stopped mattering
The model as it stood in early 2025 — three layers, five phases, one cycle for everything.
Eighteen months ago I was telling every organization I worked with the same thing: you don’t have an innovation problem, you have a feedback problem. The creative capacity is already in the building. It’s in the sales engineer watching prospects walk away over a missing integration. It’s in the support analyst emailing the same workaround fifty times a month. It’s in the consultant writing the same playbook page for every new engagement.
What was missing wasn’t ideas. What was missing was the wire — from those observations to the people who could act on them, and back again to the observer.
I built a whole framework around that claim. I wrote the first version of it in early 2025 and spent the next eighteen months revising it against real organizations — three architectural layers, five operating phases, feedback loops as the operating medium rather than a final stage. The diagram above is that version, unretouched. I still think the diagnosis was correct.
I also think it has a shelf life of about another year.
Because the wire is being installed, and nobody had to run a culture change program to do it. An agent that reads every support ticket, every call transcript, every telemetry anomaly, and turns them into structured, deduplicated, cross-linked signals is not a research project anymore. It is a weekend of integration work and a monthly bill. The thing I spent eighteen months arguing organizations should build, they are now getting as a side effect of buying tools.
This is the uncomfortable part of being early: you get to watch your hard problem turn into somebody’s feature.
So the honest question is not whether the feedback framework was right. It’s what happens next — because a bottleneck that disappears doesn’t leave a smooth road behind it. It leaves the next bottleneck, which was always there, standing in plain view with nothing in front of it.
II. What actually dissolved
I keep a list of the eight obstacles that framework was designed to defeat. It is worth going through it honestly, because five of them are simply gone, and the three survivors tell you where the work moved.
Siloed feedback collection across teams. Solved — but not the way anyone planned. We assumed the fix was consolidation: one platform, one process, everyone submits in the same place. The actual fix is extraction. You don’t unify the silos, you read them. Agents don’t care that support uses Zendesk, sales lives in Gong and product analytics sits somewhere else entirely. Consolidation was a workaround for the fact that reading everything was expensive. It isn’t anymore.
No unified aggregation platform. Dissolved with the previous one. Aggregation is a pipeline now, not a platform program. The build-versus-buy debate that used to consume a quarter simply doesn’t have stakes worth arguing about.
Difficulty correlating feedback across personas. Solved, and this one stings a little, because finding non-obvious connections across domains was supposed to be the hard, human, insight-generating part of the job. Cross-domain similarity is precisely what embedding models are good at. The thing I described as an institutional Zettelkasten that organizations had to cultivate is now something they can provision.
Technical integration complexity. Largely solved by standardized connectors. What remains is a permissions and privacy problem, which is real, but it is a different problem with different owners.
Limited resources for infrastructure. Dissolved. The sensing loop is a two-week build, not a funded program. The cost moved from construction to operation.
Five for five. Now the survivors.
Resistance to change didn’t go away, it changed shape. Nobody is resisting a new intake form anymore. They’re resisting an agent that listens to their customer calls. That is not process friction — it’s a surveillance question, and it deserves a real answer rather than a change-management workshop.
Culture not aligned with continuous feedback is not just unsolved, it got harder. “You said, we’re doing” was always the fuel of the system: the originator who hears back is the originator who writes the next signal. But the moment that reply is visibly machine-generated, it stops being an acknowledgment and becomes a receipt. Automated closure of the loop is not closure of the loop. We have made it trivially cheap to produce the form of being heard, which means the substance of being heard is now harder to signal, not easier.
Stakeholder skepticism about ROI moved rather than resolved. The question is no longer “what does this platform get us.” It is “how much autonomous execution are we willing to be accountable for.” That is a risk conversation wearing an efficiency conversation’s clothes, and executives can smell the difference.
Five technical problems evaporated. Three trust problems remain. That ratio is the whole story of the last eighteen months, and not just in this domain.
III. The bottleneck moved twice
The first piece in this series argued that the bottleneck moved from building to intent. IT Revolution’s new Enterprise Technology Leadership Journal puts a number on the first half of that claim: in the illustrative value stream Cochran, Finster, Ottersburg, Prugh and Willard walk through, coding accounts for 32 of 281 days. Take it to zero and almost everything that made you wait is still there — much of it in the fuzzy front end.
What I want to add is the step in between. For a brief window, the bottleneck was sensing: once you could ship weekly, the limit was knowing what to ship. That’s the window my feedback framework was built for, and it’s the window that just closed. What remains is intent — deciding what should exist, and saying it precisely enough that humans and agents can execute it without loss.
This is not a new observation in the abstract — “garbage in, garbage out” is older than any of us. What’s new is the amplification factor. When implementation was slow, ambiguity was cheap, because the friction of building gave you a dozen chances to catch it. Someone would hit an unclear requirement on Tuesday and ask about it. The estimate would come back absurd and force a conversation. Code review would surface the misunderstanding. The slowness of the system was, among other things, an error-correction mechanism nobody designed and everybody relied on.
John Cutler recently gave this a better name: positive friction — the moments where a human had to stop, interpret and decide. His warning is the right one: remove it without replacement and you get “AI flattening layered on AI flattening, with no thread back to reality.”
An agent does not ask on Tuesday. An agent does not find the requirement absurd. It takes your ambiguity and converts it, at speed, into a coherent, well-tested, beautifully documented implementation of the wrong thing.
Which produces the defining economic fact of this era: velocity without clarity is more expensive than slowness. Not less valuable — more expensive. You now pay full price for the wrong thing, faster, with better documentation explaining why it was correct.
IV. Three things that didn’t survive contact with agents
I rebuilt the model. Before describing what replaced it, here’s what broke, because the failures are more instructive than the fix.
The funnel broke. Every innovation framework, including mine, assumed a funnel: many signals in, few things out, filtering as the core value-adding activity. Filtering was valuable because building was expensive — you had to be right before you started. When a working prototype costs four hours, the funnel inverts. For a large class of questions, building the thing is now cheaper than the meeting about whether to build the thing. Any process that forces both is charging you twice.
The queue broke. Phases implied handoffs, handoffs implied queues, and queues were where work went to die — but at least they served a purpose: they rationed a scarce resource. With that resource no longer scarce, a queue is pure cost.
The single loop broke. My old model had one cycle. Everything entered at Capture and traveled the same road. That was always a simplification, but a tolerable one, because everything moved at roughly the same speed. Now a prototype iterates in an afternoon while a pricing decision takes six weeks of legal review. Forcing both through one cadence means either governing experiments to death or shipping irreversible decisions like experiments. Most organizations, in my experience, manage to do both simultaneously.
V. The Intent Lifecycle
So: seven nodes, three loops, four enablers. Let me be specific, because the detail is where the argument lives.
The nodes
1 · Capture — what we perceive. Agents extract structured, atomic signals from calls, tickets, telemetry, repositories, reviews. Humans keep writing signals too, deliberately, because a person choosing to report something carries intent that telemetry never does. Volume is now free; the human channel exists for the thing volume can’t buy.
2 · Connect — what belongs together. Clustering, deduplication, cross-domain linking: almost entirely machine work now. What stays human is interpretation — deciding which pattern is a problem and which is merely a correlation. The model will happily find both and present them with identical confidence.
3 · Frame — what the actual problem is. This is a new node, and the most important one. A cluster is not an intent. Turning “forty-three signals about onboarding” into “enterprise tenants above fifty users cannot self-serve DNS configuration, which costs us roughly eleven days of implementation time per deal” is a different act, and it is where the leverage now sits. An agent can draft a frame. A human decides which framing governs. That decision is not delegable, because it is the single point in the system where a wrong answer is both invisible and compounding. This is where I part ways with the most practical agent-era delivery playbook I’ve read this year. Cochran et al. name the failure mode exactly — the agent that builds the wrong thing quickly — and address it by having AI synthesize requirements and acceptance criteria. That works once someone has decided what the requirement is. Frame is the step before. A frame worth committing to carries at least two options and what each would cost us.
4 · Commit — what we take responsibility for. Notice what changed here. Commit used to be primarily about cost: we can’t build everything, so we choose. Building is no longer the constraint. What remains scarce is what you can operate, support, secure, explain to a regulator and live with. Commit is now a filter for consequence, not for capacity. A bet that doesn’t name the options it rejected isn’t a choice. It’s momentum with a signature.
5 · Specify — how intent becomes executable. The second new node. Specification used to be documentation: a description of something a human would then build, valuable mainly as communication. Now it is the interface through which you program the system. Stories, acceptance criteria, edge cases, non-functional requirements, explicit out-of-scope — or, for non-deterministic features, an eval set that defines what good looks like instead of what the thing does. The spec is written once and consumed six times: engineering scope, QA plan, security review, launch criteria, documentation, and agent context. That sixfold reuse is the entire answer to “we don’t have time for specs.”
6 · Deliver — what actually comes into existence. Multi-track delivery — product and enablement and documentation and migration and go-to-market — was the promise every framework made and none kept, because the non-product tracks never had budget. Generated from a shared spec, they are close to free. The ambition wasn’t wrong. It was just unaffordable.
7 · Learn — what it changed. Outcome review, not output review. The new part: learning writes back into the shared context, so the next cycle starts smarter. This is the only mechanism in the whole model that produces compounding rather than throughput.
The three loops
This is the structural claim, and the part I’d defend hardest:
The Sensing Loop (Capture ↔ Connect ↔ Learn) runs continuously and mostly autonomously. It produces situational awareness, not decisions.
The Fast Loop (Frame → Specify → Deliver → Learn → Frame) runs in hours or days, for cheaply reversible work. It deliberately bypasses Commit. It bypasses the committee, not the friction. The friction moves into Frame — which is why Frame stays human even here.
The Governance Loop (Connect → Frame → Commit → Specify → Deliver → Learn) runs in weeks or months, for work that is expensive or impossible to undo.
Which loop applies is decided by reversibility, not by hierarchy or budget size. Classify work three ways — cheaply reversible, expensively reversible, irreversible — and route accordingly.
Reversibility as a decision criterion isn’t mine. Amazon has run on one-way and two-way doors for two decades, and I spent years inside an organisation where that vocabulary was ambient — you learn to ask can we undo this before you ask who signs off. What’s new here is where it gets applied. In the human version, reversibility tells a leader how much deliberation a decision deserves. In an agentic system it becomes a routing rule: it decides which loop the work enters, and how much autonomy an agent is permitted inside it. The same question, load-bearing in a place it was never designed for.
Run this audit on your own portfolio. Take the last twenty initiatives and classify them. In every organization where I’ve done this, roughly seventy percent land in “cheaply reversible” — and all of them went through a governance process designed for the other thirty. That number is usually more persuasive than any framework diagram I can draw.
The four enablers
Running horizontally across every node:
Context Substrate — the shared, versioned store of signals, frames, decisions, specs, evals, telemetry and codified skills. This is what agents actually work from, and it is the real asset. Not the software. The knowledge about the product. Every derived artifact — cluster, frame, spec — links back to the signals it came from, and says how much of it a machine wrote. That thread to reality is what separates a substrate from a very confident summary.
Agent Fabric — orchestration, a charter and a regression set per agent, observability, cost control. Past roughly three production agents, fleet management becomes its own discipline whether you staff it or not.
Platform & Flow — golden paths, self-service, bottleneck removal. Agentic capability is an overlay across your existing platform layers, not a fourth platform.
Trust & Accountability — human-in-the-loop design, the non-delegability of accountability, governance, and visible, credible closure of the loop.
Three of those four got cheaper in the last two years. The fourth got more expensive. Guess which one determines whether this works.
VI. What humans keep
The practical question every leader asks at this point is where the humans go. The answer is more specific than “in the loop,” and it’s better expressed as a matrix than a slogan: for each node, at each reversibility class, what autonomy level is permitted?
Run that exercise honestly and a shape appears. The edges of the process — perceiving, measuring, and yes, building — tolerate high autonomy. The middle does not. Frame and Commit sit at low autonomy across every reversibility class, including the cheap one.
That’s not caution. It’s the job description. Humans decide what holds; agents execute what holds.
Which means the widely-forecast obsolescence of product roles is only half right, and the useful half is the distinction people keep skipping. What’s genuinely threatened is the process role: collecting requirements, writing tickets, grooming the backlog, shepherding handoffs. That work was always a tax on the slowness of the system, and the system isn’t slow anymore.
What’s not threatened is the capacity to look at forty-three noisy signals and say: this is the problem, this is what we believe will change if we solve it, this is how we’ll know, and here’s what we are explicitly not doing. That skill just became the control surface for the entire production system. The people who have it are about to find out they were underpriced.
Kent Beck, Cornelia Davis and their co-authors arrive at the same profile from the talent side, in the same journal: what organizations now need are “architects of intent.” They also name the uncomfortable corollary. The process work I just called a tax was, for many people, where they learned to frame in the first place. Remove it, and the struggle has to be built back in on purpose — they call it synthetic struggle — or the underpriced skill simply stops being produced.
The matrix also gives you something rarer than a philosophy: a progress metric. Every cell you can raise one level without your correction rate rising is coordination work you’ve permanently removed. Maturity becomes measurable — how many cells sit how high, at what error rate — instead of a slide with five stages and a rocket on it.
VII. The part that doesn’t get automated
Let me come back to the three survivors, because I don’t want to end on the engineering.
An organization can install every node in this model, wire up a competent fleet, and still fail — for exactly the reason my original framework identified, and which none of this technology touches. Feedback collected and not acted on is worse than no feedback at all. An open loop costs more than silence, because it teaches people that speaking up is theater.
Agents raise the stakes on that in a specific and slightly perverse way. They make it trivially cheap to generate the appearance of closure: personalized replies, status updates, tidy summaries explaining how valuable everyone’s input was. Volume of acknowledgment goes up while its information content goes to zero — and people are remarkably good at detecting this, usually faster than the person sending it expects.
So the discipline that mattered before matters more now, and it costs the one thing that hasn’t gotten cheaper: a named human being spending attention. Someone who says, in their own words, we read your signal, here’s what we decided, here’s why, and here’s what happened. Including the ones where the answer was no. Especially those.
That is not a nostalgic flourish. It is the input-scaling mechanism of the entire system. Every node downstream depends on signal volume that depends on people believing the wire works.
The same applies to the surveillance question. If an agent reads your team’s customer conversations, the people in those conversations should know it, see what was extracted, and be able to correct it. Not because a regulation requires it — though one probably does — but because the alternative produces a sensing layer that people learn to route around. And a signal system people route around is worse than none, because you’ll trust it.
VIII. Where to start
Not with agents. With two weeks and three questions.
Take five things customers have told you repeatedly over the past six months. Who heard each one first, when, and how long until a decision followed? The answer is usually a three-digit number of days, or “never.” That number has a name now: Cochran et al. list time from idea to clear intent as a leading indicator — and never unpack it. This question is how you start measuring it.
Take your three largest initiatives this year. Where is the intent written down? If the answer is a slide deck, it isn’t.
Take the last twenty initiatives and classify them by reversibility. Compare that distribution to the governance every one of them passed through.
Three numbers. They will be uncomfortable, and that’s the point: they establish that you have a problem in the middle of your process, not at the ends, before anyone spends money at the ends. From there the sequence is boring and it works — one value stream, three sources, sensing loop first; then a shared context substrate and a fortnightly ritual whose only question is “is there an intent here”; then specification discipline in one team; and only then the fleet.
If you start with the fleet, you will automate your silos and call it transformation. I have watched this happen. The demo is always excellent.
IX. Three sentences to take with you
The bottleneck moved from building to sensing to intent — and it moved twice while most organizations were still optimizing for the first one.
Velocity without clarity is more expensive than slowness, because you now pay full price for the wrong thing and get a comprehensive test suite proving it works.
What compounds is context; what doesn’t scale is being heard by a human — and that is now the scarcest input in the system.
Sources: Enterprise Technology Leadership Journal, Fall 2026, IT Revolution — licensed CC BY-NC-SA 4.0. · John Cutler, TBM 441.