
The throughput your customer experiences is determined by the slowest stage in the chain — not the fastest. Speed up the middle and leave the upstream and downstream stages unchanged, and work queues at both ends. The AI investment produces local velocity, not systemic value.
This is not a new insight. It is the bottleneck principle — applied to software delivery. What is new is where the bottleneck now lives — and what it takes to move it.
The pattern is now documented at scale. A 2025 study by Faros AI tracking over 10,000 developers across 1,255 engineering teams found that teams with high AI adoption completed 21% more tasks and merged 98% more pull requests — yet PR review time increased by 91%, PR size grew by 154%, and DORA metrics showed no measurable improvement at the organizational level. The coding step accelerated. The review and validation steps, already the constraint, became worse. Google’s 2025 DORA report confirmed the same pattern independently: AI adoption correlates positively with throughput, but “continues to have a negative relationship with software delivery stability.”
Kief Morris, a cloud technology specialist at Thoughtworks, puts the mechanism plainly in a March 2026 article on martinfowler.com: when humans try to stay closely involved in every step of the agent’s output, “agents can generate code faster than humans can manually inspect it… we become a bottleneck.” His analysis distinguishes three positions: outside the loop (vibe coding), in the loop (human reviews every artifact — creates the review bottleneck), and on the loop (human designs the harness the agent runs inside). The third position — on the loop — is what the Axon AI operating model is built for.

The bottleneck moves. It never disappears.
AI adoption in software delivery follows a predictable pattern. It starts where the pain is most visible and the tooling is most mature: Build. Coding agents are productive from day one. The velocity gain is real — 39 percent across 14 squads, measured over real sprints. Teams reach for them first, and they should.
But AI cannot be contained to one phase. The moment Build accelerates, the system around it reacts. This is not a risk of AI adoption. It is a property of any system where one stage accelerates while adjacent stages do not. The bottleneck moves.
This happens in every scenario.
When AI is adopted only in Build and Verify: the adjacent phases — Define upstream, Operate downstream — run at human pace. Specs are not ready fast enough. UAT cannot absorb the output. The velocity gain in Build produces queue buildup at both ends. The customer feels none of the improvement.
When AI is introduced into adjacent phases without the Axon AI operating model: agents run in Define and Operate without configured Skills, without a set Harness, without defined human gates. They drift. They produce unreliable output. They erode trust. Speed without a functioning operating model is not an improvement — it is a different failure mode. Adam Field, Chief AI Officer at Tungsten Automation, names the risk precisely in CIO magazine (June 2026): “Traditional software fails obviously. Agents fail silently, confidently, at scale.” The bottleneck shifts from capacity to quality.
When AI is introduced with the Axon AI operating model: governed agents run in each phase. Skills are loaded and versioned. The Harness is configured for the phase — read-only in Define, gated execution in Build, autonomous within pre-approved guardrails in Operate. Human gates sit at the right points. The bottleneck moves again — to the next phase where the operating model has not yet been applied. That is not a failure. It is the next step.
The Axon AI operating model is the knowledge of how to make that evolution safe at each step: which agent to run, which Skills to load, how to configure the Harness, where to place the human gate. Without it, every new phase AI enters is ungoverned. With it, every phase AI enters produces reliable, auditable, improvable output.
The third scenario is now viable at production scale because of a shift that occurred in late 2025. A practitioner experiment published in June 2026 by software architect David Tielke identifies the enabling condition: models from late 2025 onward follow guidelines and guardrails with a fidelity that makes governed agentic development viable at production scale. Before that threshold, even a well-designed operating model could not be trusted at L3/L4. Now it can. The question is no longer whether AI agents can be governed reliably. It is whether organizations apply that operating model before or after the failure modes appear.
The bottleneck is not a staffing problem or a process problem. It is a signal: the Axon AI operating model has not been extended into that phase yet. The five upstream practices in this article are how that extension happens in Define and Design.
Axon Active already operates across the full delivery flow — Define (POs as a service, sharpening backlogs), Design (solution architects, reviewing architecture options and producing decision records), Build and Verify, and Operate. The extension described here is not a scope expansion. It is the systematic application of the Axon AI operating model to the phases where AI is now present but not yet fully governed — and the service Axon brings to customers who are managing those phases themselves.
The upstream fix: structured artifacts agents can consume
The solution to the upstream bottleneck is not more developers, faster standups, or better Jira hygiene. It is a set of practices that produce structured artifacts — documents with a defined shape that AI agents can read, reference, and build from reliably.
Five practices do this work. Each addresses a different dimension of the upstream gap. Each produces an artifact that becomes an input to the next stage. Together they form the quality layer AI agent governance depends on, running from the first conversation with a customer to the moment code review begins.

Impact Mapping — why before what
Before a spec can be written, someone must answer why the feature exists. Impact Mapping connects a business goal to the actors affected, the impacts those actors need to experience, and only then to the deliverables that produce those impacts. Done well, it prevents the most expensive mistake in software delivery: building the right thing for the wrong reason.
An agent can draft an Impact Map from a customer brief, an interview transcript, or a product vision document. A BA reviews and adjusts. The map becomes the first structured artifact in the chain — the anchor that keeps every downstream decision connected to business intent.
Spec-Driven Development — intent before generation
SDD is the core practice. Write the specification before any agent touches the keyboard. A well-formed spec has six sections: Purpose (why this exists), Scenarios (the user’s path with real values), Requirements (testable rules), Constraints and edge cases (what is deliberately out of scope), Success criteria (what closes the ticket without argument), and Open questions (honest gaps that reviewers fill before code starts).
The spec is not documentation. It is the agent’s memory. Without a spec, every prompt is a fresh attempt to reconstruct intent. With one, every agent in the chain — coding, testing, review — reads from the same source of truth.
A good spec is not written from a blank page — it is built by questioning. There is a name for the step: grilling — before any spec is drafted, the agent questions the human about expected behavior, surfacing the gaps the human would otherwise leave for the agent to fill with its own assumptions during implementation. The Open questions section of the spec is the record of that grilling — the gaps found early, while they were still cheap to close.
SDD breaks the most common failure mode in AI-powered development: context decay. In an unstructured session, intent drifts with every exchange — the developer and the agent progressively diverge in their picture of what success looks like, and neither holds the original. The spec eliminates that drift at the source.
Bezael Pérez, in Spec Driven Development: Build With AI Without Losing Control (Leanpub, May 2026), names the three visible symptoms of uncontrolled AI development that spec-first addresses: the agent contradicts itself across sessions because nothing anchors its decisions; project knowledge lives only in one person’s head; and context preparation consumes more time than code generation. He adds a fourth symptom that is invisible until it surfaces in production: uncontrolled AI-powered development produces security findings at ten times the rate of structured development, even while generating commits three to four times faster. Speed amplifies the problem without the spec’s constraint section making security requirements explicit.
His framing of the spec is precise: “It is a contract. You define the expected behavior. The agent implements something that fulfills that behavior. When it finishes, you verify whether what it built matches what you specified.” With a spec, a failed result is not “I don’t like the result” but “criterion X is not met.” The agent can work with the second. It cannot work with the first.
The academic framing is concise. Piskala’s “Spec-Driven Development: From Code to Contract in the Age of AI Coding Assistants” (arXiv:2602.00180, submitted to AIWare 2026) states the problem directly: “AI models are excellent at pattern completion but poor at mind reading.” SDD resolves this by making the specification the source of truth from which code is derived or verified — not the other way around. The paper defines three levels: spec-first, spec-anchored, and spec-as-source.
The most instructive evidence comes from practitioners who arrived at spec-first through production failure, not theory. David Tielke’s enterprise experiment (June 2026) — 45 workdays of effort spread over roughly six months — documents five phases of agentic development: ungoverned prompting, quality-driven with a Harness, spec-driven, test-driven, and finally voice-driven autonomous development. He did not start with SDD. He evolved to it because ungoverned prompting produced inappropriate architecture suggestions and constant correction cycles at scale. Spec-driven development — where the agent breaks a specification autonomously into tasks before writing a line of code — was the phase that unlocked reliable production output.
A Manning MEAP title — Designing AI Agents (2026) — frames the same shift as “design inversion”: the specification is no longer documentation of the code — the code is an execution of the specification. The agent is a compiler; spec quality determines output quality. Context Engineering, defined across multiple 2026 practitioner texts as the discipline of delivering the right context to an LLM so its intelligence can be fully utilized, is not a prompt-writing skill. It is a systems design discipline. The spec is its primary artifact.
This is not a proprietary Axon practice. Eden Marco’s Agentic Coding with Claude Code (Packt, 2025) describes planning mode as “a foundational principle in agentic coding workflows” in which the agent “is restricted to read-only operations and is responsible for producing a specification or implementation plan before any code changes are made.” The author notes that this mode “mirrors senior software engineering workflows” — research first, plan second, execute only after review. The validation is not confined to one vendor: Amazon’s Kiro is one example — reported in iX 6/2026, it is an IDE built around spec-driven development — specifications are the central artifact, written in a formal requirements syntax (EARS, the Easy Approach to Requirements Syntax), held in versioned markdown files that define APIs, deployment patterns and architecture decisions, with automated hooks that generate tests and run security checks against them. A major vendor productizing the discipline shows spec-first is being adopted industry-wide, not merely advocated — even as the tooling around it is still maturing.
The most rigorous public assessment of SDD tooling was published on martinfowler.com in October 2025 by Birgitta Böckeler, a Distinguished Engineer at Thoughtworks. Her conclusion: “The general principle of spec-first is definitely valuable in many situations.” Her critique is worth engaging directly. She observes that current SDD tools produce too many markdown artifacts, that agents do not reliably follow all spec instructions, and that over-elaborate workflows can create a false sense of control. She draws a parallel to model-driven development, which never scaled for business applications.
Böckeler’s critique describes exactly the problem the Axon AI operating model is designed to solve. The failure mode she documents — agents ignoring spec instructions, generating duplicates — occurs in ungoverned, ad-hoc setups. Reviewed, versioned Skills narrow the agent’s operating space deliberately. Her over-ceremony objection is answered by the Definition of Ready gate: not every story needs the full upstream chain. The DoR check determines which tasks need full SDD treatment and which do not.
Architecture Decision Records — auditable design rationale
ADRs document architecture decisions in a structured format: context, decision, alternatives considered, and rationale. They answer the question auditors, new joiners, and future agents all ask: why was this built this way? An agent drafts the ADR from design conversations or architecture review sessions. A solution architect signs off. The record persists alongside the code.
For customers in regulated industries — banks and insurers supervised by FINMA, or organizations preparing for the EU AI Act — auditors expect evidence that key technical decisions were made deliberately, by a human with relevant expertise. ADRs provide exactly that evidence. An agent that produces ADRs as a byproduct of design work turns documentation effort into a natural artifact of delivery.
Acceptance Test Driven Development — tests before code
ATDD generates acceptance tests from specification criteria before implementation begins. The spec’s Success Criteria section is machine-readable: each criterion becomes a test case. A Test Agent processes the spec and produces a test suite. Developers write code against a test suite that already exists.
The result is that Build and Verify are no longer sequential. Testing begins at definition. The feedback loop that normally runs weeks after a story is written compresses to hours. Rework — the hidden cost that erodes velocity gains — shrinks.
AI agent governance: the governed agent chain
Google DORA 2025: “successful AI adoption is a systems problem, not a tools problem.” The value of AI is unlocked not by the tools themselves but by the surrounding technical practices and operating model. The Axon AI operating model’s agent chain is the operational expression of that principle applied to delivery.
When each practice is encoded as a Skill in the Axon AI operating model, agents can run the workflow continuously — with human gates at the points where judgment is required. The spec becomes the single thread of intent that connects every agent in the chain.

The chain works because the spec is stable. An Impact Agent drafts the map; a BA approves it. A Spec Agent drafts the spec from the approved map; a PO approves it. A Test Agent generates acceptance tests from the approved spec. A Coding Agent builds against the spec and the tests. A developer reviews before merge.
The operating model level per phase is deliberate, not uniform. Discover and Define run at L2 — Knowledge loaded, Harness read-only, a human reviews each step before anything proceeds. Design also runs at L2 — suggestions only, no writes, architect review on every output. Build and Verify step up to L3 — reviewed Skills required, every step gated, CI integration in Verify. Operate moves to L3/L4 depending on the task: production monitoring runs on pre-approved guardrails with humans on watch; incident response stays gated.
The operating unit is not the runtime. It is the Knowledge + Harness pair. The same Claude Code instance behaves fundamentally differently in Define (read-only, suggestions) than in Build (gated execution, every step approved) because the Skills loaded and the Harness configuration are different. That is what the Axon AI operating model provides — not a tool license, but a configuration that is reviewed, versioned, and propagated.
What this means in practice has been formalized by Birgitta Böckeler in “Harness Engineering for Coding Agent Users” (martinfowler.com, April 2026). She defines the harness as guides (feedforward controls that steer before the agent acts) and sensors (feedback controls that allow self-correction after). Her key admission: “Correctness is outside any sensor’s remit if the human didn’t clearly specify what they wanted in the first place.” No harness, however well-engineered, can compensate for absent intent. The spec is the feedforward guide that carries intent.
Designing AI Agents (Manning, 2026) observes that every leading agent harness — Claude Code, OpenAI Codex CLI, Aider, OpenHands — has converged on the same architectural components: a declarative skills layer, a permission gate, a compactable memory, and a complexity router. The conclusion: “The market has voted: the harness, not the model, decides whether your agent ships.” The operating model configuration — Skills, Harness, trust level — is not a differentiating opinion. It is where the industry has landed.
Tielke’s 45-workday experiment confirms this independently. His conclusion was unambiguous: “This quality was only possible through my deep architecture knowledge and a highly precise Harness.” His 880 NDepend rules and environment-differentiated permissions — full Docker access in Dev, logs-only in Prod — are a Skills layer and Harness configuration built independently, without knowledge of the Axon model, arriving at the same architecture.
Morris’s “on the loop” model and Böckeler’s harness engineering framework together define the human’s role precisely: not reviewing every artifact (that creates the bottleneck), and not stepping back entirely (that loses correctness). The human designs, steers, and continuously improves the harness. That is what Axon Active’s AI Coaches do, and what the Skills layer encodes.
Arsanjani and Bustos’ Agentic Architectural Patterns (Packt, 2026) formally names “Human Delegates to Agent” and “Agent Calls Human” as established architectural patterns with defined contexts, implementation guidance, and production code examples. The principle of delegating work while retaining human decision authority is not Axon doctrine — it is an emerging industry standard.
Delegate work, not responsibility. The agent generates. The human decides. That principle does not change as the chain extends. What changes is where generation happens — earlier in the flow, with more of the delivery system covered.
What this means for Axon Active customers
The bottleneck shift is now documented in Axon Active’s own delivery data and confirmed by independent external research: Build and Verify are ~39% faster, but the slow points are before and after those phases. Those slow points are not the customer’s fault. They were always there. AI made them visible by removing the tolerance that absorbed them.
The upstream practices described here are how Axon Active extends its AI-first software engineering approach to Define and Design — bringing AI agent governance to the upstream phases: governed agents, explicit Skills, and human gates at known points.
What the customer gets in practice:

- In Discover: AI literacy training, operating model literacy and artifact sharing, feasibility checks. Axon advises and trains; the customer retains strategic ownership. L2 — read-only, no writes, advisory posture.
- In Define: a Spec Agent configured with SDD Skills specific to their domain, DoR enforcement automated, BA-as-a-service reviewing every output. Stories that arrive at Build are ready to build. L2 — read-only, every step reviewed.
- In Design: a Design Agent producing ADRs and architecture options, solution architect review gate, Impact Mapping facilitated by an AI Coach. Architecture decisions are documented and auditable. L2 — suggestions only, architect approval on every output.
- In Build + Verify: developers and AI Coach at L3 — reviewed Skills required, every step gated. Test Agent generates from spec criteria. CI Agent scans and checks. Rework caught before merge, not after.
- In Operate: AI-native SRE and operating model auditor at L3/L4. Production monitors and anomaly alerts run on pre-approved guardrails; humans step in on exceptions. Periodic Axon AI operating model reviews close the feedback loop.
The Skills layer is what makes this governable at scale. Anyone can run Claude Code and call it a Spec Agent. What the Axon AI operating model provides is Skills that are reviewed, versioned, and propagated across all squads and all customers — fixed once, consistent everywhere. Hilary Packer, EVP and Head of Enterprise Data and AI at American Express, identifies the scaling failure that results from the alternative: teams “rebuilding the same capabilities repeatedly — identity management, access controls, monitoring, and observability” for every agent pilot. That is exactly what reviewed, versioned Skills propagated across squads prevent. That is the difference between a tool and a service.
For customers in Swiss and German regulated industries, the operating model dimension matters additionally. Every agent in the chain operates at the level appropriate to the phase — read-only or gated — with defined human approval points before anything reaches production. The model is designed to support the traceability and human-oversight principles found in the EU AI Act and in FINMA’s expectations for operational risk management. The question an auditor asks — what did the agent do, from what input, reviewed by whom — has a documented answer at every step.
The honest tradeoffs
These practices add process upstream. That is not cost-free. Four failure modes are worth naming directly.
Spec rot
A spec written at story creation and never updated becomes a liability. An agent reading a stale spec builds to the spec, not to what the codebase actually does. The fix Pérez names in Spec Driven Development is the Living Spec — a specification the system keeps in step with the code as the code changes, rather than a document that ages the moment it is written. The Axon AI operating model implements this through spec versioning inside the Skills review cycle: drift between spec and code becomes a reviewable signal, not a silent decay. The discipline is not “write the spec once” — it is “keep the spec the source of truth.”
Over-ceremony
Not every story needs an Impact Map and an ADR. Böckeler’s assessment on martinfowler.com documents this risk in practice: SDD tooling applied to a small bug “quickly became clear that the workflow was like using a sledgehammer to crack a nut.” The practices described here scale with task complexity. The Definition of Ready check is the gate that determines which stories need full upstream treatment and which do not.
Waterfall in disguise
Upstream practices can calcify into sequential phase gates if they are not designed with iteration in mind. The spec is a guide, not a frozen requirement. Open questions in the spec are invitations for early feedback, not blockers. The agent chain should shorten feedback loops, not lengthen them.
The hybrid people constraint
The binding constraint on scaling this model is not customer demand. It is the availability of hybrid people — those with both domain depth and AI capability. The same scarce profile that makes a good AI Coach is what the new upstream and Operate roles require. Delivery core stays flat; growth is at the ends. Those ends can only grow as fast as the pipeline of hybrid-capable people allows.
The response is deliberate: keep junior engineers on review and supervised (L3) work even when an agent could generate it. The goal is not to minimize human involvement — it is to build the next generation of AI Coaches and hybrid practitioners. The growth plan and the skills-pipeline plan are the same plan.
What comes next
The bottleneck will move again. It always does. Every time the Axon AI operating model is applied to a phase, the adjacent phase becomes the next constraint. That is not a problem to solve. It is the nature of AI adoption as an ongoing evolution, not a one-time project.
The five upstream practices in this article address the current constraint: Define and Design phases where AI is present but the operating model has not yet been fully applied. Structured artifacts — Impact Maps, Event Storming outputs, SDD specs, ADRs, ATDD test suites — are what make AI agent governance operable in those phases. Without them, agents in upstream phases are ungoverned. With them, every agent in the chain reads from the same source of intent.
This matters in both directions. When Axon Active handles only Build and Verify, the upstream practices are the service that extends the Axon AI operating model into the customer’s own Define and Design phases — because the system demands it, not because Axon is expanding scope. When Axon Active handles the full flow, the same practices are the internal discipline that makes AI acceleration in Build actually reach the customer.
The Axon AI operating model — Skills, Harness, human gates — is what makes each stage of the evolution safe. Not the tools. The same tools are available to everyone. What Axon brings is the knowledge of how to run them.
Where to start. If your teams already use coding agents but delivery still feels stuck at the specs or at UAT, the constraint has likely moved upstream or downstream. Axon Active’s AI-First Software Engineering services apply the Axon AI operating model across your delivery flow — from structured specs and governed agent chains to the AI Coaches who run them alongside your teams. We start by finding where your bottleneck sits today, then extend governance into that phase first.
Sources
• METR — Randomized Controlled Trial of AI Tools on Real Codebases (2025) — 16 experienced developers; experienced developers 19% slower with AI while believing they were 20% faster — they had forecast 24% before the study began
• Faros AI — The AI Productivity Paradox Report (2025) — 10,000+ developers, 1,255 teams: 98% more PRs, 91% longer review time, DORA metrics flat at org level
• Google DORA — 2025 State of AI-assisted Software Development — ~5,000 professionals; “systems problem not tools problem”; AI negative relationship with stability
• Grant Gross — Why agentic architecture is still so puzzling (CIO, June 2026) — Hilary Packer (American Express) on operating model challenge; Adam Field on agents failing silently at scale
• David Tielke — Der Moment der die Softwareentwicklung geändert hat (YouTube, June 2026) — 45-workday enterprise experiment (spread over roughly six months); 5-phase evolution to spec-driven; quality only possible through deep architecture knowledge and precise Harness; 93× speed factor vs human team — Tielke scales this to 25× under stricter estimating assumptions
• Birgitta Böckeler — Understanding Spec-Driven Development: Kiro, spec-kit, and Tessl (martinfowler.com, Oct 2025) — rigorous practitioner assessment; spec-first principle validated; ungoverned tooling risks documented
• Eden Marco — Agentic Coding with Claude Code (Packt, 2025) — planning mode as foundational principle; spec-before-code mirrors senior engineering workflows
• Bezael Pérez — Spec Driven Development: Build With AI Without Losing Control (Leanpub, May 2026) — three symptoms of uncontrolled AI dev; spec as contract; 10× security findings without structured constraints; grilling, the Living Spec
• iX 6/2026 (Heise) — Spec-getriebene Entwicklung mit Amazon Kiro; Agentic AIOps — reguliert und auditierbar (May & Sultanow) — Amazon Kiro as spec-driven IDE using EARS syntax; reference architecture for auditable regulated agents (Run-ID, model digest, policy hash; NIS2, EU AI Act Art. 12/14)
• Kief Morris — Humans and Agents in Software Engineering Loops (martinfowler.com, Mar 2026) — outside/in/on the loop framework; “in the loop” human as bottleneck; “on the loop” as correct position
• Deepak Babu Piskala — Spec-Driven Development: From Code to Contract (arXiv:2602.00180, Jan 2026) — academic paper submitted to AIWare 2026; “AI models are excellent at pattern completion but poor at mind reading”
• Birgitta Böckeler — Harness Engineering for Coding Agent Users (martinfowler.com, Apr 2026) — guides (feedforward) and sensors (feedback); correctness requires human-specified intent
• Designing AI Agents: Principles, patterns, and best practices (Manning MEAP, 2026) — design inversion; “the harness, not the model, decides whether your agent ships”; industry convergence on skills layer + permission gate
• Younghee Song & Jungjun Hur — Build an AI Agent From Scratch (Manning MEAP, 2026) — Context Engineering as “the discipline that determines whether an agent succeeds or fails”
• Arsanjani & Bustos — Agentic Architectural Patterns (Packt, 2026) — Human Delegates to Agent and Agent Calls Human as established architectural patterns
• IEEE-ISTAS 2025 — Security Degradation in Iterative AI Code Generation (arXiv:2506.11022) — 37.6% increase in critical vulnerabilities after five iterations; essential role of human expertise in the loop
• EU AI Act — Official Text (2024) — regulatory framework for AI systems in EU/Swiss regulated industries
• FADP — Swiss Federal Act on Data Protection (September 2023) — applicable Swiss data protection framework
• Eliyahu M. Goldratt & Jeff Cox — The Goal: A Process of Ongoing Improvement (North River Press; first published 1984) — the book that makes the constraint argument: a system’s throughput is set by its constraint, so speeding up any non-constraint stage leaves total output unchanged. Goldratt named and formalized it as the Theory of Constraints in 1990
• Sergio Rattner — What is the Theory of Constraints, and How Does it Compare to Lean Thinking? (Lean Enterprise Institute, Sep 2006) — independent summary of Goldratt’s five focusing steps and the chain model: a chain is only as strong as its weakest link
Frequently Asked Questions
Why doesn't faster AI coding make delivery faster?
Because the throughput your customer experiences is determined by the slowest stage in the chain, not the fastest — Goldratt’s Theory of Constraints applied to software delivery. Accelerating Build while Define and Operate run at human pace produces queues at both ends: local velocity, not systemic value.
What are the upstream practices in AI agent governance?
Five practices — Impact Mapping, Event Storming, Spec-Driven Development, Architecture Decision Records, and Acceptance Test Driven Development — each producing a structured artifact that AI agents can read, reference, and build from reliably.
What is spec-driven development (SDD)?
Writing the specification before any agent touches the keyboard. The spec is a contract: you define the expected behavior, the agent implements something that fulfills it, and you verify whether what it built matches what you specified — eliminating context decay at the source.
Where does the human sit in a governed agent chain?
On the loop, not in it: rather than reviewing every artifact (which creates the bottleneck), the human designs, steers, and continuously improves the harness. Human gates sit at the points where judgment is required, and nothing ships without approval.
Does this work in regulated industries?
It is designed for them. Every agent action has a documented answer to the questions an auditor asks — what did the agent do, from what input, reviewed by whom. Human approval gates and versioned Skills support the traceability and oversight principles of the EU AI Act and FINMA’s operational risk expectations. Specific compliance obligations always depend on the customer’s regulatory context and are assessed per engagement.














