Open Source · ArcKit

Enterprise Architecture That Ships

Your enterprise architecture is a 200-page PDF — six months behind the roadmap that produced it. The problem is rarely the strategy. It's the machinery that turns strategy into work. Executable EA takes the TOGAF ADM and the Open Group's Open Agile Architecture standard, and turns them into machine-executable, auditable, repeatable workflows that your AI agents can run — no EA team or six-figure consulting budget required.

Two Overlays, One Toolkit

The Baseline and the Velocity

arckit-togaf-adm is the map. arckit-oaa is the driving instruction. They are complementary, not competing.

TOGAF ADM

arckit-togaf-adm

The full TOGAF ADM cycle — Preliminary through Phase H plus a cross-project Architecture Repository — implemented as structured, traceable slash commands and build recipes. Use it when you need a defensible, enterprise-wide baseline: regulatory audits, large architecture boards, multi-year migration programmes.

Command	Phase	Produces
/arckit:adm-preliminary	Preliminary	Architecture vision, scope boundaries, drivers, constraints, success criteria
/arckit:business-capability-map	A — Business	Capability hierarchy, value streams, maturity levels
/arckit:application-inventory	C — Application	Portfolio catalog with strategic fit scoring, dependencies, lifecycle status
/arckit:application-rationalization	C — Application	Keep / merge / replace / retire decisions per application
/arckit:gap-analysis	E — Opportunities	Capability matrix, gap severity scoring, workstream mapping
/arckit:transition-architecture	F — Migration	Work packages, migration waves, resource plans, acceptance criteria
/arckit:architecture-board	G — Governance	Board charter, compliance scorecard, governance process
/arckit:architecture-change	H — Change	Change requests with impact assessment, ADM cycle re-entry
/arckit:architecture-repository	Continuous	Patterns library, standards register, reusable blocks across projects

Read the full story: Executable Enterprise Architecture — Agentic TOGAF ADM →

O-AA · C208

arckit-oaa

The Open Group's Open Agile Architecture (C208) as a sprint execution engine for the same baseline: product teams, sprints, and value streams instead of quarterly boards. A complete architecture sprint in under a day, not a quarter.

Command	Focus	Produces
/arckit-oaa:oaa-adm-lite	Sprint rhythm	Maps the ADM cycle to 2–4 week sprints — Sprint 0 vision through Sprint 4+ governance gates
/arckit-oaa:product-architecture	Product	Product-centric architecture: team composition, outcome KPIs, backlog items, value stream
/arckit-oaa:agile-strategy	Strategy	Dual transformation canvas — legacy modernization + greenfield innovation, operating model shift
/arckit-oaa:agile-security	Security	Threat model per sprint, compliance-as-code, AI bias checks embedded in the sprint rhythm
/arckit-oaa:agile-governance	Governance	Lightweight governance: pre/post-sprint checklists, architecture debt register, quarterly health score

Read the full story in the arc-kit repo →

Decision

When to Use Which

Regulatory, audit-driven programme with 50+ stakeholders and a multi-year horizon → TOGAF ADM. Product team with a hard eight-week deadline and an agile culture → O-AA. Most enterprises: run TOGAF ADM to set the baseline, then feed its capabilities into O-AA sprints.

Dimension	arckit-togaf-adm	arckit-oaa
Standard	TOGAF ADM (traditional)	Open Agile Architecture C208
Cadence	Quarterly architecture boards	2–4 week sprint windows
Artefacts	Full 200-page deliverable cycle	1–2 page canvases, max 2 per sprint
Delivery	Stage-gate (Preliminary → Phase H)	Backlog-driven, iterative
Organisation	Enterprise-wide, component-focused	Product-centric, cross-functional teams
Governance	Formal architecture board	Sprint review panels, lightweight evidence
Pick it when	Regulatory audit, 50+ stakeholder gates, multi-year horizon	Hard deadline under 8 weeks, agile culture

Trust by Construction

The Agent Is the Author — the Standard Is the Gate

AI agents change the math: a 200-page TOGAF deliverable becomes an overnight batch run. But the agent is the author now, not the EA. Four layers keep hallucinated content out of generated documents.

Structured intake interview

A guided interview runs against each Open Group / TOGAF template's field schema — required sections, enum choices, cross-references — before the agent writes a single line. Incomplete fields fail; they don't quietly get invented.

Recipes

oaa-full and togaf-adm recipes encode required phase order and dependencies. Foundation commands (principles, requirements, stakeholders) must run first — the agent can't skip a stage.

Schema-validated templates

Every artefact (OASTR, OAPR, OAAL, ARC-* documents) has a strict shape. Intake ensures completeness before rendering; schema validation catches it after.

Per-phase validation gates

Each phase ships its own completeness checks — required sections, cross-references, consistency with the previous phase's output. The gate is the control; the agent is the worker.

The agent can make it faster. It can't make it structurally wrong.

Quick Start

Three Ways to Run It

ArcKit supports Claude Code, Codex, Copilot, Gemini, and OpenCode — and bring-your-own-LLM against any local OpenAI-compatible endpoint.

Claude Code plugin

/plugin marketplace add terrygzhou/arc-kit
claude plugin install arckit arckit-togaf-adm arckit-oaa

/arckit:principles Create principles for a financial services company

Codex CLI

codex plugin marketplace add terrygzhou/arckit-codex
$arckit-principles Create principles for a financial services company

ArcKit CLI (BYO LLM)

pip install git+https://github.com/terrygzhou/arc-kit.git
arckit build recipes/togaf-adm/full.yaml \
  --model=deepseek-v4 --api-base=http://localhost:3082/v1

Frameworks Stop Being Theoretical When They're Executable

Both overlays are open source, auditable, and community-driven — the rules, templates, and validation logic are fully inspectable. No vendor lock-in.

Star arc-kit on GitHub Contact for Details