Skip to content
AI Developer Toolkit

Frameworks with audit trails and standards: AI-DLC, Agent OS, Tessl and Kiro-style specs

AI-DLC, AWS Labs’ AI-Driven Development Life Cycle, is the only framework in this group that pairs human approval gates with a committed, append-only audit trail of 105 event types, and it runs in Claude Code, Codex and Cursor. Agent OS v3 discovers and injects coding standards; Tessl, cc-sdd and Conductor add lighter spec-approval gates without an event log.

Your compliance officer asks a simple question about last month’s payments change: who approved the requirements, who approved the design, and did anyone skip a step? The agent wrote the code in two days, the pull request has one “LGTM”, and the only record of the decisions is a chat session that nobody saved. You need the next regulated change to leave evidence behind as a side effect of doing the work, not as a report someone writes afterwards.

This page is for the developer who runs the agent and the tech lead who has to answer that question. It runs one change through AI-DLC’s enterprise profile end to end, then shows where the lighter frameworks are enough.

What an audited agent workflow gives you

Section titled “What an audited agent workflow gives you”
  • A decision table: which of the five frameworks produces audit evidence and which only shapes behaviour.
  • An AI-DLC install for Claude Code, Codex or Cursor, including the Codex hook-trust step.
  • A regulated run in the enterprise profile, with the Guard Policy pinned to strict and a gate after every stage.
  • Committed audit shards, a required CI check on them, and a prompt that turns them into an approval ledger.
  • What a HUMAN_TURN event proves and what it does not.

Which framework gives you an audit trail, and which only gives you standards?

Section titled “Which framework gives you an audit trail, and which only gives you standards?”

Only one of the five writes a machine-readable log of decisions; the rest give you gates or standards, and git history is your only record.

FrameworkWhat it enforcesDurable evidenceGatesClaude Code / Codex / CursorPick it when
AI-DLC (AWS Labs)5 phases, 33 stages, 11 workflow profilesaidlc-state.md plus append-only audit/ shards, 105 event typesAfter every stage except initializationYes / Yes ($aidlc, Codex 0.145.0 or later) / YesYou must show an auditor who approved what, in order
Agent OS v3 (Builder Methods)Your house conventions, injected on demandagent-os/standards/ and an index fileYou confirm each discovered standardYes / not documented / claimed in the READMEAgents ignore your conventions, and you already have a delivery process
Tessl spec-driven-development tile“Never begin implementation without an approved spec”specs/*.spec.md linked to tests with [@test]Spec approvalPer Tessl’s docs (secondary)You want versioned, evaluated context packages from a registry
cc-sdd (gotalab)Kiro-style requirements, design and tasksbrief.md, requirements, design and tasks.md per specBetween spec phasesStable / stable / betaYou like Kiro’s spec shape but work in Claude Code, Codex or Cursor
Conductor (Google, gemini-cli-extensions org)Context, then spec and plan, then implementconductor/ files and tracks/<id>/{spec,plan}.mdPlan approval before codeYes / not documented / not documentedYou want durable project context and git-aware revert with little ceremony

Kiro builds the same requirements, design and tasks flow into its own IDE and CLI (secondary: kiro.dev search snippets); it is not something you install into another agent, so cc-sdd is how you get that shape elsewhere. Kiro’s own flow is on the Kiro page.

The rule this page follows: if the question is “who approved it”, use AI-DLC. If it is “why does the agent keep ignoring our conventions”, use Agent OS or AI-DLC’s knowledge folder. If it is “did anyone agree on the behaviour before the code”, any spec framework is enough; the wider comparison is on spec-driven frameworks compared.

Install AI-DLC in Claude Code, Codex or Cursor

Section titled “Install AI-DLC in Claude Code, Codex or Cursor”

AI-DLC ships as a native aidlc command plus a runtime for each supported agent. Only the --harness value, the invocation character and one trust step differ between tools.

  1. Install the aidlc command. The one-line installer pipes a script into your shell, so on a managed machine download install.sh from the latest release, read it, then run it.

    Terminal window
    # terminal, macOS / Linux / WSL
    curl -fsSL https://github.com/awslabs/aidlc-workflows/releases/latest/download/install.sh | sh

    On Windows PowerShell the README uses irm https://github.com/awslabs/aidlc-workflows/releases/latest/download/install.ps1 | iex. Neither Bun nor Node.js is required.

  2. Configure the project for your agent and run the health check from the repository root.

    Terminal window
    cd ~/src/payments-service
    aidlc config --harness claude
    aidlc doctor
    claude

    In the session, start work with /aidlc.

    Other --harness values are kiro, kiro-ide, opencode and copilot. aidlc config with no flag starts an interactive setup.

  3. Commit what the configuration wrote. aidlc-state.md, the audit/*.md shards and every stage artifact belong in git; the per-machine files that AI-DLC’s managed .gitignore block lists (.aidlc-engine/, the per-clone marker, the active-space and active-intent cursors) stay ignored. Add aidlc/diagnostics/ to .gitignore too, so a debugging bundle never lands next to the evidence.

AI-DLC is not a Claude Code plugin, so claude plugin details does not report its context cost; compare a session’s context usage before and after aidlc config on your own repository before a team rollout.

Run a regulated change with approval gates and an audit export

Section titled “Run a regulated change with approval gates and an audit export”

The example takes “add an approval step for refunds above EUR 10,000” through the enterprise profile: all 33 stages at Comprehensive depth and test strategy, with the Guard Policy defaulting to strict (as in security-patch and infra; seven profiles default to relaxed, express to off).

  1. Load your standards before the first stage. Every agent loads the Markdown under aidlc/spaces/default/knowledge/aidlc-shared/: put coding standards, architecture principles and compliance rules there, not in .claude/knowledge/, which upgrades overwrite. Conventions that exist only in code can be extracted with Agent OS.

  2. Pin the Guard Policy to strict for the whole repository. Otherwise anyone can type /aidlc --guard-policy relaxed, which lets the Plan Approval and review-freeze fences stand aside. Add a ## Guard Policy section (or use the one already there) to aidlc/spaces/default/memory/org.md, with one line:

    ## Guard Policy
    

    Mode: strict

    A memory strict wins over every profile default and refuses --guard-policy relaxed, --guard-policy off and /aidlc config set guard.<fence> off. Protect the file with CODEOWNERS. An environment kill switch still overrides it and still writes GUARD_STOOD_ASIDE rows, which the CI check below catches.

  3. Start the workflow in the enterprise profile. Name the profile explicitly. With only a description, AI-DLC matches keywords to a profile and asks you to confirm; you want enterprise on record from the first event, not a later SCOPE_CHANGED row.

  4. Treat every gate as a sign-off, not a formality. Each stage ends with Approve or Request Changes. Approve records GATE_APPROVED and advances; Request Changes records GATE_REJECTED, moves the stage to [R] and re-opens the gate after the revision. Decide in advance who approves what (product owner: requirements; tech lead: design; security: threat and compliance artifacts), and read the artifact, not the chat summary.

  5. Approve the verification command once, and keep checkpoints gated. In Construction you approve the check AI-DLC reruns at every unit checkpoint, for example npm test && npm run typecheck; a failing check halts the run, so pick one that fails for the behaviours in your requirements. Choose Review each checkpoint over Continue automatically; it records gated in an AUTONOMY_MODE_SET row.

  6. Check status without advancing anything. Read-only /aidlc --status shows the stage, the Guard Policy with its source, and a Fences: line. You want Guard Policy: strict (from org.md).

  7. Export the audit trail with the pull request. The trail lives in aidlc/spaces/<space>/intents/<YYMMDD>-<label>/audit/, one shard per clone (<host>-<clone>.md), so parallel worktrees never conflict. Each entry has a tool-stamped ISO 8601 timestamp and an **Event**: line; agents cannot write a shard directly. The export is the commit that ships the code with its state file, artifacts and shards. aidlc engine audit history prints the same events as JSON, but AI-DLC calls the aidlc engine routes harness machinery rather than a stable interface, so build CI on the committed shards.

/aidlc --doctor --export is a different thing: it writes a redacted .tar.gz to aidlc/diagnostics/ containing report.md and report.json with a workflow timeline (stage durations, gates, revisions, gaps). It hashes intent IDs, redacts paths and excludes raw audit files and artifact bodies, so it is for the AI-DLC maintainers, not your auditor.

Fail the pull request when a guard was lowered

Section titled “Fail the pull request when a guard was lowered”

This job reads only committed files and needs no secrets, so it is safe on pull requests from forks. It runs on every pull request, not only those touching aidlc/, because the change most worth catching is regulated code with no trail at all. Set REGULATED_PATHS to your own directories and make audit-gate a required status check in branch protection; a check that is not required only reports.

.github/workflows/aidlc-audit-gate.yml
name: aidlc-audit-gate
on:
  pull_request:
    types: [opened, synchronize, reopened, labeled, unlabeled]
permissions:
  contents: read
jobs:
  audit-gate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
          persist-credentials: false
      - name: Check the AI-DLC audit trail
        env:
          BASE_REF: ${{ github.base_ref }}
          REGULATED_PATHS: src/payments src/refunds
          GUARD_JUSTIFIED: ${{ contains(github.event.pull_request.labels.*.name, 'aidlc-guard-justified') }}
        run: |
          range="origin/$BASE_REF...HEAD"
          grep -q -x 'Mode: strict' aidlc/spaces/default/memory/org.md || {
            echo "Guard Policy pin missing from aidlc/spaces/default/memory/org.md"; exit 1; }
          deleted=$(git diff --diff-filter=D --name-only "$range" -- 'aidlc/**/audit/*.md')
          if [ -n "$deleted" ]; then echo "Audit shard deleted: $deleted"; exit 1; fi
          regulated=$(git diff --name-only "$range" -- $REGULATED_PATHS)
          shards=$(git diff --diff-filter=AM --name-only "$range" -- 'aidlc/spaces/*/intents/*/audit/*.md')
          if [ -z "$shards" ]; then
            if [ -n "$regulated" ]; then echo "Regulated change without an AI-DLC audit trail"; exit 1; fi
            exit 0
          fi
          grep -q -h -E '\*\*Event\*\*: GATE_APPROVED' $shards || { echo "No approved gate on record"; exit 1; }
          if grep -H -E '\*\*Event\*\*: (GUARD_STOOD_ASIDE|GUARD_DISABLED|CHANGE_ACCEPTED|PLAN_APPROVAL_OVERRIDDEN)' $shards; then
            justification=$(git diff --diff-filter=AM --name-only "$range" -- 'docs/compliance/*-justification.md')
            if [ "$GUARD_JUSTIFIED" = "true" ] && [ -n "$justification" ]; then
              echo "Lowered guard accepted with justification: $justification"
            else
              echo "A guard was lowered or a plan approval overridden: commit docs/compliance/<intent>-justification.md and add the aidlc-guard-justified label"; exit 1
            fi
          fi

The patterns match the **Event**: <NAME> line of AI-DLC’s audit format (audit-format.md, v2.10.0). Only added or modified shards are grepped; a deleted shard fails on its own, because removing evidence is what a reviewer must see.

Stand-aside rows can never leave a shard, so the lowered-guard step has an escape hatch that leaves its own evidence: the aidlc-guard-justified label and a docs/compliance/<intent>-justification.md committed in the same pull request. Put docs/compliance/ and aidlc/** under CODEOWNERS with required review; the labeled and unlabeled types re-run the job when the label changes.

How do you prove AI-DLC’s output without reading every line?

Section titled “How do you prove AI-DLC’s output without reading every line?”

The gates prove that a human looked at each artifact, not that the code is right. That evidence comes from four places, none of them a person reading the diff:

EvidenceWhere it comes fromWho signs off
Requirements and design were approved before codeGATE_APPROVED rows for each Inception stageProduct owner, tech lead
Tests encode the approved behaviourComprehensive test strategy plus the recorded verification command at every unit checkpointThe engineer who approved the command
The reviewed code is the shipped codeSource-bound review receipts: a source-manifest.json and fingerprint per unit; completion is refused if source changed after reviewAI-DLC’s two reviewer agents, then CI
Nobody quietly lowered a guardMode: strict in memory and the required CI check aboveTech lead, via CODEOWNERS on aidlc/**

Keep your usual gates on top: type checks, lint, the test suite and your evidence bundle on the pull request. AI-DLC records that decisions were made in order; your tests and CI prove that the result behaves.

Add house standards without a pipeline: Agent OS v3

Section titled “Add house standards without a pipeline: Agent OS v3”

Agent OS v3 (2026-01-20) dropped its implementation phases (“Spec creation now defers to Plan Mode”) and kept five commands: discover, index and inject standards, shape a spec in plan mode, and plan-product for the product mission. Use it when the problem is conventions, not audit.

The per-project script scripts/project-install.sh is verified in the repository and copies commands into .claude/commands/agent-os/. The base-install line comes from a search snippet of the official installation page, so check it there first:

Terminal window
# base install (secondary: buildermethods.com installation page)
rm -rf ~/agent-os && git clone https://github.com/buildermethods/agent-os.git ~/agent-os && rm -rf ~/agent-os/.git
# per project (script verified in the repository)
cd ~/src/payments-service && ~/agent-os/scripts/project-install.sh

In Claude Code the commands appear under the agent-os namespace:

/agent-os:discover-standards api     proposes concise standards from existing API code; you confirm each one
/agent-os:index-standards            writes the index of agent-os/standards/
/agent-os:shape-spec                 run in plan mode; asks targeted questions and weighs your standards
/agent-os:inject-standards           pulls the relevant standards into the current context

The README documents no Codex install. For Codex and Cursor, reference the standards folder from AGENTS.md or your Cursor rules, or copy it into AI-DLC’s aidlc-shared/; see rules sync.

Tessl, cc-sdd and Conductor: lighter spec gates

Section titled “Tessl, cc-sdd and Conductor: lighter spec gates”

These three give you an approved spec before code, with far less ceremony and no event log; git history is your record.

Tessl’s spec-driven-development tile

Section titled “Tessl’s spec-driven-development tile”

Tessl is a registry for agent context packages (“tiles”). The tile tessl-labs/spec-driven-development ships four skills (requirement-gathering, spec-writer, spec-verification, work-review) and two always-on rules, spec-before-code and one-question-at-a-time. Specs land in specs/ as .spec.md files with [@test] links to the tests that prove them.

Terminal window
npx @tessl/cli install tessl-labs/spec-driven-development   # no global install
# or: npm i -g @tessl/cli && tessl init && tessl install tessl-labs/spec-driven-development

Then add “Use spec-driven development.” to the request; the agent interviews you, writes the spec and waits for approval. The agents tessl init detects (Claude Code, Cursor, Gemini, Codex, Copilot) come from Tessl’s docs (secondary). The npm package downloads a proprietary native binary, so a zero-vendor policy rules it out.

cc-sdd: Kiro-style specs in Claude Code, Codex and Cursor

Section titled “cc-sdd: Kiro-style specs in Claude Code, Codex and Cursor”

cc-sdd installs 17 Agent Skills that reproduce Kiro’s requirements, design and tasks flow, and its README states that existing Kiro specs stay compatible.

Terminal window
npx cc-sdd@latest

A new feature runs /kiro-discovery <idea> → /kiro-spec-init <name> → /kiro-spec-requirements → /kiro-spec-design → /kiro-spec-tasks → /kiro-impl; on an existing system, run /kiro-steering first.

Conductor

Section titled “Conductor”

Conductor’s current README documents Antigravity and Claude Code only. In Claude Code:

/plugin marketplace add gemini-cli-extensions/conductor
/plugin install conductor
/conductor:conductor-setup
/conductor:conductor-new-track "Add a second approver for refunds above EUR 10,000"
/conductor:conductor-implement
/conductor:conductor-review

/conductor:conductor-revert undoes a track, phase or task along logical boundaries rather than raw commits.

What does each framework cost in ceremony?

Section titled “What does each framework cost in ceremony?”
FrameworkCeremony on a normal changeContext cost you can measureWorth it for
AI-DLC enterprise33 stages, a gate after eachCompare context before and after aidlc configRegulated work, where “the cost of an undocumented decision is higher than the cost of the additional ceremony” (profile guide); never a copy change
AI-DLC bugfix / refactor / security-patch9 (bugfix) or 10 (refactor, security-patch) of 33 stages at Minimal depthSame installFocused changes in a regulated repository; the memory pin keeps them strict
Agent OS v3None beyond confirming standards onceCommands only, loaded when invokedConventions, not audit
Tessl tileOne interview, one spec approvalTwo always-on rules plus four skillsA spec gate with registry-managed context
cc-sddThree spec approvals per feature17 skills, loaded on demandKiro-shaped specs outside Kiro
ConductorOne setup, one plan approval per trackAbout 302 always-on tokens (claude plugin details, 2.1.283)Durable project context

What breaks when you run an audited agent workflow?

Section titled “What breaks when you run an audited agent workflow?”

The gates never appear in Codex or Cursor. The hooks did not run: in Codex, the project hooks were never trusted. Run aidlc doctor, trust the hooks and start a new session; after an upgrade, a new session also loads the refreshed skills.

aidlc is not found after installing. Apply the PATH line the installer printed or open a new shell. On runtime/CLI version skew, finish the active workflow, then rerun aidlc config.

Approval is refused even though you typed “approve”. The gate needs a HUMAN_TURN since the last gate resolution; if the agent’s question picker does not record one, type “approve” as a normal prompt.

The workflow will not advance. Run /aidlc --status: [?] means a gate is waiting for you, [R] means a revision is in progress. /aidlc --doctor lists findings such as gate-unresolved and runtime-graph-stale. aidlc-state.md can be rebuilt from the STAGE_STARTED and STAGE_COMPLETED events in the shards.

Completion is refused after you touched the code. A source path changed after review without a claim. Revert the change or take AI-DLC’s stale-unit recovery; never set AIDLC_SKIP_SOURCE_FRESHNESS=1 in a regulated intent, because it switches off the check your auditor cares about.

The CI step “A guard was lowered or a plan approval overridden” fails. Something lowered a fence, usually an environment kill switch (AIDLC_DISABLE_PLAN_APPROVAL_GUARD, AIDLC_DISABLE_REVIEW_FREEZE_HOOK, AIDLC_DISABLE_REVIEWER_SCOPE_HOOK); the Fences: line of /aidlc --status names the source. Remove it for future runs; the rows already written stay in the trail. To pass this pull request, commit docs/compliance/<intent>-justification.md, get it approved by its CODEOWNERS, and add the aidlc-guard-justified label.

The CI step fails with “Regulated change without an AI-DLC audit trail”. Code under REGULATED_PATHS changed but no shard did. Run the change through /aidlc and commit the shards.

The team drowns in ceremony. A 33-stage run on a small change teaches people to click Approve without reading. Reserve enterprise for audit-sensitive work.

Where to go next with audited delivery

Section titled “Where to go next with audited delivery”

Written by

See what's new on the platform.

Privacy Policy Terms of Service Cookie settings