Open Standard · CC BY-SA 4.0

Agile V™

Verifiable AI-Augmented Engineering

Stop AI hallucinations. Ship software, firmware, and hardware with formal traceability, autonomous quality gates, and human oversight built directly into every task.

Get the Skills Read the Paper
v3.5 Skills Library
20+ Agent Skills
L0–L4 Risk Levels
ISO 9001 · 27001 · GxP

AI Agents Fail in Predictable Ways

Today's AI coding tools are great for demos. They are unreliable for real products. Without a verified engineering framework, you get the same six failure modes every time.

Orphaned Code

Code generated with no link to any requirement. Nobody knows what it does or why it exists.

Silent Assumptions

The agent fills in ambiguous intent with its own guesses — and never tells you.

Self-Grading Bias

The same agent that wrote the code also writes the tests — and they only cover what the code does, not what it should do.

Deployment Disasters

Agents push to production without approval gates, rollback plans, or human review.

Untraceable Bugs

When something breaks, there is no audit trail. No way to know what changed, when, or why.

Compliance Nightmares

Regulated industries — medical, aerospace, automotive — need traceable evidence. AI-generated code has none.

What is Agile V™?

Agile V™ is a significant shift from "Agile vs. V-Model" to a unified approach. Classical Scrum, while effective for human-scale product development, optimizes for adaptability through time-boxed ceremonies and team-level feedback loops. In the AI era — where continuous change, autonomous execution, and system-level assurance are required — it lacks intrinsic mechanisms for verifiable, auditable quality at scale.

The traditional V-Model provides rigor and traceability but remains rigid and project-bound. Agile V™ unifies both into an Autonomous Quality Management System (AQMS): continuous, verifiable, auditable, and human-led. Whether you ship software, firmware, or hardware in regulated or safety-critical domains, the same structure applies.

Agile V™ is published as an open standard under CC BY-SA 4.0.

The Agile V™ Workflow: The Infinity Loop

In this model, the "V" isn't a one-time journey — it's a high-frequency vibration. The framework enforces the V structure at the task level, not just the project level. Every task goes through intent, synthesis, and verification before it can close.

Left Side — Intent & Decomposition

  • Input: Human provides high-level "Product Intent".
  • Requirement Agent: Generates PRDs and traceable user stories with formal REQ-XXXX IDs.
  • Logic Gatekeeper: Checks every requirement for ambiguity or hardware constraint violations — e.g., "Are these GPIO pins available on the chosen MCU?"
  • Human Gate 1: You review and approve the "Blueprint" before any code is written.

Apex — Synthesis

  • Build Agent: Generates artifacts — code, PCB schematics, HDL, or firmware — exclusively from the approved requirements.
  • Test Designer (parallel): Reads the requirements, not the code, to build the verification suite. This eliminates "success bias" where tests only check what the code happens to do.

Right Side — Verification & Compliance

  • Red Team Verifier: An independent agent — fresh context, never the Build Agent — challenges every artifact and assumption.
  • Compliance Auditor: Records the full chain of decisions: why a component was chosen, how it was tested. Generates ISO 9001 / GxP-ready logs automatically.
  • Human Gate 2: You review the Evidence Bundle before anything ships.
Agile V™ Skills — v3.5.0

Agent Skills for Every Stage of the Loop

The Skills library encodes every Agile V™ principle directly into your AI coding tool. Drop them into Claude Code, Cursor, VS Code Copilot, or any agent tool — and your AI immediately gains formal traceability, human gate enforcement, and compliance-ready artifact generation.

Left Side

Requirements & Decomposition

  • requirement-architect — intent → formal REQ-XXXX stories
  • logic-gatekeeper — ambiguity detection, hardware constraint checks
  • discovery-analyst — user research → candidate requirements
  • ux-spec-author — UX specs with accessibility constraints
  • threat-modeler — STRIDE analysis, privacy impact
Apex

Build & Test Synthesis

  • build-agent — language-agnostic code generation from requirements
  • build-agent-python — FastAPI, Flask, Django, ML pipelines
  • build-agent-js — React, Next.js, Node.js, TypeScript
  • build-agent-embedded — C/C++, RTOS, MISRA-C, safety-critical
  • test-designer — verification suite built from requirements only
  • schematic-generator — schematics, netlists, HDL
Right Side

Verification & Compliance

  • red-team-verifier — independent verification, never the build agent
  • compliance-auditor — decision logging, traceability matrix, VSR
  • documentation-agent — ISO 9001 / V-Model / ISO 27001 artifacts
  • release-manager — rollout plans, rollback, deployment gates
  • observability-planner — metrics, dashboards, alerts, SLOs
Claude Code Cursor VS Code Copilot ISO 9001 ISO 27001 GxP / GAMP 5 AS9100D
Agile-V/agile_v_skills
Agentic Agile V — v0.1.0 Alpha

The Python Runtime That Enforces It All

The Agentic Agile V scaffold is a production-ready Python infrastructure layer that makes the framework programmable. Every task gets a versioned brief, every artifact gets an evidence bundle, every decision gets a SHA-256-chained audit trail. No brief, no build.

Task Brief Enforcement

Agents cannot implement from a long chat history. Every task starts from a reviewed, versioned .md brief with a unique AAV-XXXX ID. The CLI scaffolds it, the runtime enforces it.

agilev new --title "Add auth" --risk L2

Risk-Based Evidence Gates

Five risk levels (L0–L4) map directly to required evidence: unit tests, integration tests, security checks, rollback plans, independent verification, and hardware-in-the-loop testing.

L0Docs, trivial — brief + reviewer note
L1Low-risk internal — tests or rationale, lint
L2Normal feature — unit + integration tests, CI, reviewer gate
L3Security / customer-visible — regression, security check, approval
L4Safety / firmware / regulated — HIL, traceability matrix, independent verification

SHA-256 Audit Chain

Every event — requirement created, code generated, test run, gate approved — is appended to a cryptographically linked event ledger. Tamper-evident. GxP and ISO 27001 audit-ready out of the box.

agilev validate --task AAV-0042

Multi-Domain Support

Software, firmware, and PCB/hardware live in the same framework. KiCad ERC validation, MISRA-C enforcement, and OpenHands autonomous execution are all first-class integrations.

Python 3.11+ OpenHands KiCad 8 GitHub Actions OpenWiki
Agile-V/agentic_agile_v

The Agile V™ Manifesto

We are practitioners who build software, firmware, and hardware with AI-assisted tools, and we need a shared standard for doing it safely and auditably. Through this work we have come to value:

We prefer the left over the right.

Verified Iteration

over

Unchecked Velocity

Speed is a byproduct of confidence — verify every step before moving to the next.

Traceable Agency

over

Opaque Autonomy

Maintain a clear audit trail of who — human or agent — made which decision.

Living Compliance

over

Static Documentation

Compliance must be an inherent outcome of the workflow, not a post-hoc chore.

Human Curation

over

Human Execution

Humans lead intent, design, and review. Execution is assisted or automated.

That is, while there is value in the items on the right, we value the items on the left more.

The 12 Principles of Agile V™

  1. Continuous Validation: Testing is not a phase; it is the shadow of development.
  2. Single Source of Truth: Requirements, code, and tests are formally linked so AI agents can keep them consistent.
  3. Human-in-the-Loop: Humans shift from "Doers" to "Designers and Auditors."
  4. Hardware-Aware Software: AI agents validate physical constraints (PCB, firmware) as early as code logic.
  5. Regulatory Readiness: Compliance is a byproduct of the workflow, not a frantic effort at the end.
  6. Decompositional Clarity: No artifact is built until the AI and Human agree on its Definition of Done.
  7. The Red Team Protocol: Every build agent is independently challenged by a verification agent with a fresh context.
  8. Minimalist Meetings: Sprint ceremonies are replaced by asynchronous Agent-to-Human reviews.
  9. Decision Logging: Every "Why" is captured in real-time for ISO and GxP integrity.
  10. Sustainable Rigor: The system prevents shortcuts that lead to technical or regulatory debt.
  11. Cross-Domain Synthesis: Bridging electrical, mechanical, and software agents so system-level behaviour is consistent.
  12. Simplicity: Maximizing the amount of busy work not done — so humans focus on design and judgment, not repetitive tasks.

Start With One Principle

Apply one Agile V™ principle in your next iteration and let us know how it goes — your feedback shapes the evolving open standard.

Get the Skills Explore the Runtime