🤖 AI

Agile V: A Compliance-Ready Framework for AI-Augmented Engineering -- From Concept to Audit-Ready Delivery

This paper introduces Agile V, a compliance-ready framework that integrates AI agents with human approval gates to merge Agile and V-Model methodologies, demonstrating through a case study that it can automatically generate audit-ready artifacts, achieve 100% requirement-level verification, and significantly reduce development costs with minimal human intervention.

Original authors: Christopher Koch, Joshua Andreas Wellbrock

Published 2026-02-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Christopher Koch, Joshua Andreas Wellbrock

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: The "Speed vs. Safety" Trap

Imagine you are building a custom car.

Old Way (The V-Model): You draw the blueprints, build the engine, test it, and then write the manual. It's very safe and follows strict rules, but it takes forever.
New Way (Standard AI Coding): You ask a super-fast robot to build the car. It finishes in minutes! But, the robot just made it up as it went along. It didn't write a manual, it didn't keep a log of why it chose red paint instead of blue, and it didn't double-check if the brakes actually work. If an inspector shows up, you're in trouble because you have no proof the car is safe.

The Paper's Solution: "Agile V"
The authors created a new framework called Agile V. Think of it as a super-charged assembly line with a built-in "Quality Control Twin."

Instead of building first and checking later, Agile V forces the robot to build the car and the safety report at the exact same time, with a human boss checking the work at specific checkpoints.

How It Works: The "Infinity Loop"

Imagine a circular racetrack called the Infinity Loop. Every single task the AI does goes around this track, never stopping. Here is the lap:

The Plan (Definition): A human boss says, "Build a test system for this device." The AI breaks this down into tiny, clear steps (like a recipe).
The Split (Synthesis): This is the magic trick. The AI splits into two different robots:
- Robot A (The Builder): Builds the code.
- Robot B (The Tester): Reads the recipe (requirements) and writes a test plan without looking at Robot A's code.
- Why? If Robot B looked at Robot A's code, it might just copy the mistakes. By keeping them separate, Robot B acts like a "Red Team" (a group of hackers trying to break the system) to find flaws.
The Check (Validation): Robot B runs the tests. If the car passes, a human boss gives a thumbs up. If it fails, the loop goes back to the start to fix it.
The Paperwork (Compliance): While all this happens, a third robot (The Compliance Auditor) is quietly writing the official "Safety Manual" and "Decision Log" automatically. You don't have to stop and write it later; it's generated as a by-product of the work.

The "Human in the Loop"

You might think, "So the AI does everything?"
No. The human is the Pilot, and the AI is the Autopilot.

The AI flies the plane (writes code, runs tests).
The Human Pilot only needs to press a button to say "Go" or "Stop" at the checkpoints.
In the study, the human only had to type 6 short prompts (like "Start," "Check this," "Approve") to get a fully working, verified system.

The Results: The "Magic Numbers"

The authors tested this on a small project (a system to test electronic devices). Here is what they found:

Speed & Cost: They estimated that doing this the old way would cost $15,600 and take 2.5 weeks. Using Agile V, it cost about $600 and took 4 hours. That's a 25x to 50x improvement!
Quality: The system passed 100% of the required tests.
The "By-Product" Surprise: The most important part? The official audit documents (which usually take days to write) were created automatically while the code was being built. No extra work was needed.

Why This Matters (The "So What?")

In industries like medicine, aviation, or finance, you can't just ship code and hope it works. You need proof that it works, and you need a paper trail showing who decided what and why.

Before: AI was like a wild horse—fast but dangerous to ride in a regulated city.
Now: Agile V puts a saddle, reins, and a GPS on that horse. It keeps the speed but adds the safety and paperwork needed to get a license.

The Catch (Limitations)

The authors are honest about the limits:

They only tested this on a small, simple project. We don't know yet if it works for building a massive operating system or a complex spaceship.
They tested it themselves (like a chef tasting their own soup). Independent experts need to try it to be sure.
It works best when the rules are clear. If the requirements are vague ("Make it cool"), the AI might get confused.

The Bottom Line

Agile V is a new rulebook that teaches AI how to build software that is fast, cheap, and legally safe. It proves that you don't have to choose between speed and safety; you just need the right "Infinity Loop" workflow to keep them running together.

The takeaway: The future of engineering isn't just about who can write code the fastest; it's about who can verify and ship the fastest. Agile V helps teams do exactly that.

1. Problem Statement

Current AI-assisted engineering workflows face a critical structural gap: while AI agents can generate code, tests, and documentation at "machine speed," they lack built-in mechanisms for task-level verification and regulatory traceability.

The Risk: In regulated industries (e.g., medical devices, automotive, aerospace), organizations face audit failures when development artifacts lack traceability. Deferring compliance work creates "compliance debt" that surfaces during certification.
The Paradigm Conflict:
- Agile/Scrum: Optimizes for speed and adaptability but lacks built-in verification and regulatory documentation.
- V-Model: Provides rigorous traceability and verification but is too slow, phase-gated, and project-bound for continuous AI-driven delivery.
The Gap: There is no existing framework that merges the speed of AI/Agile with the rigor of the V-Model to produce audit-ready artifacts as a by-product of development.

2. Methodology: The Agile V Framework

Agile V is an open standard (CC BY-SA 4.0) that merges Agile iteration with V-Model verification into a continuous "Infinity Loop." It operationalizes this through a library of composable AI agent skills governed by mandatory human approval gates.

Core Principles

Verified Iteration: Every AI-generated artifact is tested before advancing; speed is a by-product of confidence.
Traceable Agency: The audit trail records who (human or AI) made decisions and why, satisfying ISO 9001 and GxP accountability.
Living Compliance: Regulatory documentation is generated automatically during the workflow, eliminating post-hoc documentation sprints.
Human Curation: Engineers direct intent and approve releases; AI handles execution.

The Infinity Loop Workflow

The workflow replaces sequential phases with a repeatable cycle executed per task:

Definition (Intent & Decomposition): An engineer provides high-level intent. A Requirement Architect agent decomposes this into atomic, traceable requirements with acceptance criteria. A Logic Gatekeeper validates feasibility. Human Gate 1 approves the scope.
Apex (Synthesis): Two agents work in parallel to prevent confirmation bias:
- Build Agent: Generates deliverables (code, schematics).
- Test Designer: Generates a verification suite strictly from requirements (never from code), ensuring structural independence.
Validation (Verification & Compliance):
- Red Team Verifier: Executes the test suite against the build and produces an objective pass/fail report.
- Compliance Auditor: Captures decision rationale and generates structured audit logs in real-time.
- Human Gate 2: The responsible engineer gives final approval before release.

Context Engineering & Memory

To address context window degradation in LLMs, Agile V aligns context boundaries with V-Model positions. Agents operate in fresh, isolated contexts (e.g., the Test Designer never sees the Build Agent's code context). A persistent, version-controlled memory store (.agile-v/) maintains high-signal project knowledge (invariants, decision rationales) without bloating active sessions.

3. Key Contributions

Conceptual Framework: A unified model merging Agile and V-Model into a continuous loop, specifically designed for AI-augmented engineering.
The "Red Team Protocol": A structural mechanism ensuring test independence by having the Test Designer generate tests from requirements only, preventing the "success bias" where tests merely verify what the code happens to do.
Automated Audit Evidence: The framework generates the six core artifacts required for ISO 9001/GxP (requirements spec, traceability matrix, test logs, decision rationale, risk register, validation summary) as a direct by-product of the workflow.
Feasibility Case Study: A rigorous evaluation on a Hardware-in-the-Loop (HIL) system demonstrating the framework's application in a real-world industrial context.

4. Results: HIL Case Study

The authors applied Agile V to a Python-based HIL test system for a Saleae Logic Analyzer (approx. 500 LOC, 8 requirements). The study spanned two Infinity Loop cycles.

Hypothesis Evaluation

H1 (Audit-Evidence By-Product): Supported. The Compliance Auditor automatically generated all six required artifact types (requirements, traceability matrix, test logs, etc.) without a separate documentation phase.
H2 (Verification Pass Rate): Supported. The system achieved a 100% requirement-level pass rate (8/8 requirements) with 54 automated tests. The Red Team Protocol successfully identified 10 defects (6 Major, 4 Minor) in Cycle 2, which were resolved in a single rework iteration.
H3 (Minimal Human Interaction): Supported. Each cycle required only 6 human prompts (Intent, Gate 1 approval, Synthesis direction, Gate 2 approval). The engineer contributed ~10% of architecture decisions; the rest was agent-generated.

Operational Metrics

Cost Reduction: Estimated 10–50× reduction compared to a COCOMO II baseline.
- Baseline: ~$15,600 (2.5 weeks effort).
- Agile V: ~ $600–$ 605 per cycle (4 hours human effort + negligible AI compute).
Time-to-Delivery: Estimated 25× acceleration (2.5 weeks vs. 4 hours per cycle).
Traceability: Full traceability was maintained across cycles, with every test result and log entry carrying a cycle identifier (C1, C2).

5. Significance and Implications

Regulatory Compliance: Agile V maps structurally to ISO 9001:2015, ISO 13485:2016, GAMP 5, and 21 CFR Part 11. It provides the "separation of duties" and "design controls" required by regulators, even when AI is used.
Shift in Engineering Economics: The framework proves that high-compliance engineering can be achieved at a fraction of the traditional cost, shifting the bottleneck from "writing code" to "directing intent" and "approving verification."
Scalability of AI: By decoupling the build and test contexts and using persistent memory, the framework addresses the limitations of current LLM context windows, making it viable for complex, multi-cycle projects.
Future Outlook: The authors note that as AI inference costs continue to drop (Wright's Law), the cost advantage will widen further, potentially allowing for even more rigorous verification cycles per task.

Limitations: The study is based on a single, bounded project evaluated by the framework's creators. Generalizability to large-scale, ambiguous systems requires independent replication. Additionally, the 100% pass rate refers to requirement-level coverage; mutation testing and formal verification were not included.

Conclusion: Agile V demonstrates that it is possible to achieve "machine-speed" delivery while maintaining "audit-ready" compliance, provided that verification is embedded structurally into the workflow rather than applied as an overlay.