frameworkagile-v skills release3.9.0 licenseCC-BY-SA-4.0 statuscurrent + previews

Agile V™

Verifiable AI-Augmented Engineering

Open skills and documented controls for traceable AI-assisted software, firmware, and hardware engineering, with independent review and explicit human decisions throughout the lifecycle.

Skills v3.9.0 Installation Profiles Tutorials Discussions Compliance Posture
v3.9.0 Skills Library
45 Cataloged Skills
18 Schemas
348 Deterministic Tests
4 Supported Editors

AI Agents Fail in Predictable Ways

AI coding tools can accelerate engineering, but their outputs still require review and evidence. Agile V™ addresses recurring failure modes without claiming to eliminate model errors.

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.

Evidence Gaps

Regulated and safety-related work may require traceable evidence that ad hoc AI-assisted workflows do not provide.

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 important — it lacks intrinsic mechanisms for traceable quality at scale.

The traditional V-Model provides rigor and traceability but remains rigid and project-bound. Agile V™ combines iterative delivery with V-Model traceability in a human-led workflow. It can support evidence generation for software, firmware, and hardware work, including regulated or safety-related contexts, but use of the framework does not establish certification, regulatory approval, safety, or conformity.

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. The canonical sequence is: reviewed draft → independent findings → Human Gate 1 → frozen baseline → implementation plus independent test design → independent verification → intended-use validation when required → Human Gate 2.

Left Side — Intent & Decomposition

  • Input: Human provides high-level "Product Intent".
  • Reviewed draft: Candidate requirements receive formal REQ-XXXX IDs and revision references.
  • Independent findings: The Logic Gatekeeper reports ambiguity and constraint findings without approving its own input.
  • Human Gate 1: A human reviews the draft and findings; approval creates the frozen baseline used downstream.

Apex — Synthesis

  • Build Agent: Produces implementation artifacts from the frozen baseline.
  • Independent Test Designer: Derives verification tests from the same baseline, independently of the implementation.

Right Side — Verification & Validation

  • Independent verification: The Red Team Verifier assesses specified outputs and records findings in VERIFICATION_SUMMARY.md.
  • Intended-use validation: When required, the Validation Agent separately assesses representative use and produces VALIDATION_REPORT.md. Verification evidence is not intended-use validation.
  • Human Gate 2: A human reviews the evidence bundle and decides whether to proceed.
Agile V™ Skills — v3.9.0

Agent Skills for Every Stage of the Loop

The Skills library provides 45 cataloged instruction contracts, 18 schemas, and 348 deterministic tests. Installation profiles support Claude Code, Cursor, VS Code, and GitHub Copilot. The agile-v-aibom and business/C-suite contracts are preview and require local review before use.

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 GitHub Copilot Standards mappings Human gates
Agile-V/agile_v_skills
Agentic Agile V — Python scaffold

A Companion Operational Repository

The Agentic Agile V repository explores operational tooling for task briefs, evidence bundles, risk-based controls, and event records. Its latest packaged GitHub release is v2.2.0; consult the repository for implementation status. This release tag is not presented here as a runtime or package version, nor as a suitability claim.

Task Brief Enforcement

The model starts work from a reviewed, versioned task brief rather than relying only on chat history. Actual enforcement depends on the installed tooling and configuration.

reviewed brief → frozen baseline → evidence

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

The repository describes cryptographically linked event records for requirements, artifacts, tests, and gate decisions. Such records can support an audit process but do not by themselves establish compliance or audit acceptance.

REQ → ART + TC → VER → human decision

Multi-Domain Support

Software, firmware, and PCB/hardware live in the same framework. Repository documentation covers software, firmware, and PCB/hardware workflows; verify each integration and toolchain against your intended environment.

Python 3.11+ OpenHands KiCad 8 GitHub Actions OpenWiki
Agile-V/agentic_agile_v Packaged Release v2.2.0

The Agile V™ Manifesto

We are practitioners who build software, firmware, and hardware with AI-assisted tools, and we need a shared approach to traceability and human oversight. 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

Capture evidence during the workflow for assessment against applicable obligations.

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 Support: Traceability and evidence may support compliance work; they do not establish certification, regulatory approval, safety, or conformity.
  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: Capture the rationale behind material decisions for later review.
  10. Sustainable Rigor: Defined controls help teams identify shortcuts that could create 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