Governed AI delivery

Let the model write the code. Keep the guarantees.

{ai} engineering drops a deterministic governance layer into any repo — specs, gates, and a hash-chained audit log, all as versioned local files you own.

Install in under a minuteRead the source on GitHub

No hosted control plane · no telemetry · no lock-in

ai-eng — zsh
uv recommended
$ uv tool install ai-engineering
$ ai-eng install .
$ ai-eng doctor
  [PASS] hooks · mirrors · manifest · tools
$ 
$ pipx install ai-engineering
$ ai-eng install .
$ ai-eng doctor
  [PASS] hooks · mirrors · manifest · tools
$ 
$ pip install ai-engineering
$ ai-eng install .
$ ai-eng doctor
  [PASS] hooks · mirrors · manifest · tools
$

Not a prompt pack. A governed delivery system.

Why governance

A deterministic plane that gates the probabilistic one

LLMs are fast and fallible.

{ai} engineering puts a deterministic layer underneath them — hooks, gates, a hash-chained audit log, and a spec-lifecycle state machine — so creative work stays probabilistic while everything that reaches a merge is checked, owned, and reproducible.

The judgment is yours; the guarantees are the framework's.

Held to its own gates — checked in public:

  • PyPI version
  • Python 3.11+
  • CI
  • Quality Gate
  • Coverage
  • Snyk security
  • License: MIT

Everything below is how that holds — the flow, the enforcement, the toolkit.

The governed flow

One chain. Intent to merge, gated at every step.

You drive the intent and approve each handoff. Deterministic gates block the rest — no secret, broken doc, or untested change reaches a merge.

the governed workflow
The governed workflow: /ai-brainstorm to /ai-plan to /ai-build or /ai-autopilot to /ai-pr, with you approving each step and automatic checks — clean diff, tests, docs, review — gating the merge

One command in. A governed session out.

Press play: a real session installs the CLI, clears ai-eng doctorwith a [PASS], then runs the governed flow end to end — gates and all.

demo — ai-eng
One real session — install to [PASS] to the governed flow. Plays as it scrolls into view; click to pause, and it stays static if you prefer reduced motion.

Governance that is enforced, not suggested.

Enforced by gates, not honoured by convention — the rules hold whether or not anyone is watching the PR.

  • What you approved is what shipped

    A brainstorm gate and a spec state-machine keep every change anchored to the spec you approved — so spec and code never drift apart.

  • Every tool call is screened first

    A deterministic guard checks every edit, write, and shell command — and stops the risky ones before they run.

  • Every bypass has an owner and an expiry

    No # noqa, no @ts-ignore. Each suppression is refactored or formally risk-accepted with a severity-based TTL.

  • An audit trail you own

    Every AI action appends to a hash-chained log you can verify offline. No telemetry by default.

Beyond governance

Built to ship the whole project, not just gate it.

For regulated teams, a solo developer, or a company whose agents ship code themselves — the same gates, entirely on your machine. No control plane, no lock-in.

  • Security-first — proven on itself

    The framework builds itself under its own gates.

    • dogfooded gates
    • SonarCloud gate
    • Snyk
    • gitleaks
    • semgrep
    • SBOM
    • SHA-pinned
    • signed provenance

  • Context-efficient

    • 16 KB output offload
    • top-5 skill loading
    • isolated subagents
    • hot-path cache

  • Built for engineering

    • simplify
    • explain
    • onboard
    • debug
    • review
    • verify

  • Beyond code

    • design
    • slides
    • visual
    • animation
    • media
    • prose

  • Works where you work

    • 6 IDE surfaces
    • MCP-native
    • GitHub
    • Azure DevOps

  • Yours to extend

    • composable skills
    • Engram memory (optional)
    • no control plane
    • no lock-in

The toolkit

Fifty-four skills, nine agents, one flow.

Every capability is a /ai- command on an isolated agent context. Learn it once — it travels with the repo, identical on every surface.

  • 54skills
  • 9agents
  • 6surfaces
  • 1governed flow

  • Plan & build

    brainstorm · plan · build · autopilot

  • Ship safely

    review · verify · test · security

  • Design & docs

    design · visual · slides · docs

  • Research & learn

    research · explore · explain · note

Same flow, every surface

  • Claude Code
  • GitHub Copilot
  • Codex
  • Antigravity
  • OpenCode
  • Cursor

Get started

Up and running in four steps.

Two in your terminal, two in your editor — every step shows you exactly where you are, so nothing runs in the wrong place.

  1. Your terminalonce per machine

    Install the CLI

    $ uv tool install ai-engineering

    Prefer pipx or pip? Both work too.

  2. Your terminalinside your repo

    Add governance to your project

    $ cd your-project
$ ai-eng install .
$ ai-eng doctor
  [PASS] hooks · mirrors · manifest · tools

    Governance is now versioned local files in your repo.

  3. In your editorClaude Code · Cursor · Codex · Copilot…

    Open your editor and start a session

    › /ai-start
  [ready] context loaded · gates armed · audit live

    Ease in — start observe-only and switch gates on as they earn it.

  4. In your editoryou approve each handoff

    Ship through the governed chain

    › /ai-brainstorm → /ai-plan → /ai-build → /ai-pr

    You drive the intent; deterministic gates catch the rest before merge.

Install once. Approve each step. Ship governed.

It is yours — versioned local files, no hosted control plane, no lock-in. ai-eng update to upgrade; delete the directory to leave. That is the whole exit cost.

Get it on PyPIRead the docs