Why governed code

Feature Agent is not a coding agent. It is the governed pipeline that runs around whichever coding agent you choose — and makes every change it produces enforced, attributed, and auditable.

The problem AI created

AI now writes a large share of new code, and it broke the accountability chain software has always relied on. For human code that chain was implicit: a named engineer opened the PR, a named reviewer approved it, a manager owned the outcome. For AI-written code, the accountable human quietly detaches from the diff.

So the question every auditor, regulator, security team, and increasingly every enterprise customer now asks is:

"Who authorized this change — and can you prove it?"

Most organizations can't answer that for AI-generated code. Feature Agent is built to answer it, for the output of any agent.

The stack — where Feature Agent sits

It's a common mistake to slot Feature Agent beside a coding agent ("Feature Agent + Copilot"). It sits above them:

  Spec methodology        (what to build, structured)      e.g. spec-driven / Spec Kit
        │
  Coding agent / engine   (does the writing)               Claude Code · Copilot · Cursor · Gemini · OpenHands
        │
  ▶ Feature Agent         (governs the OUTPUT)             enforced gates · audit ledger · provenance · fleet

You keep your coding agent. Feature Agent governs what it ships — not which model does the writing. Because it doesn't sell a coding agent of its own, it can govern anyone's, neutrally.

What "governed" actually means (and what's enforced)

Governance here is not a dashboard you read after the fact — it is enforced at the boundary where code lands:

Control	What it does
Approval gates	full_auto · auto_safe (analyze + clarifying questions) · po_approval (explicit human sign-off before work begins). Modes are per-project policy.
Separation of duties	The submitter of a feature cannot approve it; in the autonomous loop the writer of a change never approves its own change.
Tamper-evident audit ledger	Every run emits hash-chained events with UNIQUE(feature_id, seq) integrity, exportable to your SIEM, with deterministic run-replay of exactly how a change was produced.
Provenance per change	What was requested, the spec that governed it, the engine + model that ran, the gates that passed, the cost — attached to every feature.
Adversarial review	A dedicated code reviewer and an admin-configured security reviewer gate the change before it can merge — a reviewer separate from the writer.
Governed delivery	Draft PRs, merge control, and merge-preflight checks — nothing reaches your main branch un-reviewed.

The difference this buys you: "an AI wrote this" is a liability; "every change the AI produced is governed, attributed, and enforced" is a control you can demonstrate to an auditor, a customer's security review, or a regulator.

Neutral, and yours to run

• Engine-agnostic. Role-based routing sends the work to whichever engine you declare — pin it to an org-controlled model endpoint (Bedrock, Vertex, Azure OpenAI, or self-hosted) so code never leaves your boundary. No single-vendor coding tool can offer this, because each one calls only its own model.
• Fleet-scale. One spec fans out across N repositories with a persistent cross-project queue, per-project policy, and unified cost + status — the multi-repo orchestration a single-session coding agent structurally can't provide.
• Runs in your cloud (BYOC). Deploy Feature Agent into your own cloud account — your keys, your identity provider, your model endpoints — so your source and credentials never reach a vendor. Or have it hosted. One core, two delivery models.

Where this is heading

Governance is not a checkbox bolted onto a coding tool — it is the product. As AI writes more of the code, the scarce, durable thing stops being the writing (the models commoditize that) and becomes the governance of what was written: provable, attributed, enforced. Feature Agent's direction is to make every stage of software production — requirements, plan, implementation, review, security, deployment, production verification — a governed, attributed step in one auditable chain, regardless of which agent does the work.

→ New here? Start with the Setup guide or the Tutorial.