PROTOTYPE — brand-styled mock of the GovKit page. Placeholder SVGs mark assets A–H for Design. Copy is verbatim from the spec.
Open Source · Pip-installable · Apache-2.0

Govern Your AI Coding Agent — Before It Drifts

GovKit puts your AI coding agent inside a governed system where your architecture contracts, acceptance criteria, and evaluation thresholds are the source of truth — not the model's training data.

# install, apply, calibrate
pip install govkit
govkit apply --agent claude-code --target .
govkit calibrate

Works with Claude Code, GitHub Copilot, and OpenAI Codex · Any language — Python, C#, Java, Go, TypeScript · Python 3.11+ dev-tool requirement only, never a project dependency.

The Problem

Powerful Agents, No Guardrails

AI coding agents are powerful — but without constraints, they drift. They invent architecture, skip tests, ignore NFRs, and make decisions that belong to your team. GovKit replaces "trust the model" with a governed workflow: your contracts, specs, and CI gates decide what good looks like — every feature, every time.

Invented architecture — patterns from training data, not your boundaries.
Skipped tests & ignored NFRs — left as "TBD."
Team decisions made by a model — changes that should need an ADR.

↑ ASSET B — "Drift vs. Governed" icon trio goes here (drift arrow · spec page · CI shield).

What GovKit Does

Governance Your Agent Actually Reads

Governed agent rules

Path-scoped rules load automatically as the agent edits each layer — api, services, ports, adapters, security. It reads your architecture contracts on every turn, not its own assumptions.

Spec-driven feature contracts (L4+)

Every feature lives under features/<name>/ with five required artifacts: Gherkin acceptance criteria, fully-populated NFRs, schema-validated eval criteria, a plan, and an architecture preflight.

Architecture & evaluation skills

Ships agent skills — /architecture-preflight, /spec-planning, /implementation-plan, /adr-author — that validate features against your contracts and predict FIRST + 7-Virtue scores before any code is written.

CI gates that enforce, not suggest

govkit doctor checks whether installed governance still fits your repo; govkit validate checks whether features meet the contract. Both run in CI: schema validation, NFR coverage, boundary enforcement, prediction thresholds.

Multi-agent, multi-stack, monorepo

One toolkit for Claude Code, Copilot, and Codex, across FastAPI, .NET, Spring Boot, Fastify, Gin, dbt, and Databricks overlays. Monorepo-aware — one govkit apply per app subdirectory.

GenAI operations (L5)

For LLM features, add governed model routing (LiteLLM), observability (OpenLLMetry + Langfuse), and evaluation/safety gates (DeepEval, Promptfoo, RAGAS, NeMo Guardrails, Guardrails AI).

↑ ASSET C — six capability glyphs (shown as placeholders) to be delivered as one icon family.

Get Started in 4 Steps

Install, Apply, Calibrate, Commit

You need Python 3.11+ on your machine (GovKit is a dev tool, never a project dependency) and an AI coding agent — Claude Code, GitHub Copilot, or OpenAI Codex. GovKit ships the governance configuration; you bring the agent.

1
Install
2
Apply
3
Calibrate
4
Commit
# 1 — install
pip install govkit

# 2 — from your project root
govkit apply --agent claude-code --target .

# 3 — make the generic defaults match your repo
govkit calibrate

# 4 — commit your governance baseline
git add .govkit CLAUDE.md docs/ governance/ ci/
git commit -m "chore: add govkit governance baseline"
This step is not optional. The files GovKit installs are sound generic defaults — and your agent treats them as law. If you skip calibration, the agent governs your project against someone else's architecture decisions. govkit calibrate walks you through a 9-step review; prefer to review with the team first? Run govkit calibrate --non-interactive to write a checklist file instead.

Upgrading later? pip install --upgrade govkit && govkit upgrade --target . refreshes the files GovKit owns without touching the contracts you've customized.

See It in Use

From Spec to Governed Feature

Scaffold a feature, then govern it

govkit init my_feature --target .

Creates features/my_feature/ from the appropriate starter (Level 4+). At L3 this errors with a pointer to --level 4 — Foundations ships rules and contracts only.

Drive the agent through the lifecycle (Claude Code)

/architecture-preflight my_feature
/adr-author my_feature
/spec-planning my_feature
/implementation-plan my_feature

The agent produces architecture_preflight.md, plan.md, and eval_criteria.yaml — and will not proceed if predicted FIRST or 7-Virtue averages fall below 4.0.

StepClaude CodeCopilotCodex
Architecture preflight/architecture-preflight my_feature/architecture-preflight$architecture-preflight my_feature
Spec planning/spec-planning my_feature/spec-planning$spec-planning my_feature

Copilot infers the feature from context; Codex invokes skills with a $ prefix.

Validate compliance in CI

govkit validate --target .

Level-aware per-feature compliance — artifact existence, Gherkin structure, NFR coverage, eval-criteria schema, prediction thresholds. No-op at L3.

Who It's For

Built for Teams Shipping With AI Agents

L3 — Foundations

Governed agent rules + architecture contracts. No codebase restructuring. Your agent follows your hexagonal boundaries from day one.

L4 — Spec-Driven

Spec-first, test-first delivery: the five-artifact feature contract, feature-coupled skills, and governance CI jobs that gate every PR.

L5 — GenAI Operations

Governed model routing, LLM observability, and evaluation/safety gates so your LLM features are routed, evaluated, and guarded by contract.

Backend APIs, CLIs, React or Angular UIs, and governed dbt / Databricks data projects — across Claude Code, GitHub Copilot, and OpenAI Codex. Any project language; GovKit copies Markdown specs, YAML configs, and Gherkin files into your repo.

Open Source

Free, Apache-2.0, and Yours to Inspect

PyPI v0.13.0Python 3.11+License: Apache-2.0CI: passing

↑ ASSET G — badge strip (live shields.io or brand chips). TODO: confirm default branch for raw links.

Put Your AI Agent on Rails

Install GovKit, apply it to your repo, and let your contracts — not the model — decide what good looks like.

pip install govkit

Free and open source. Want help rolling governed AI delivery out across your teams? Talk to Accelerated Innovation.