Agentic Enterprise Architecture Platform
A technical white paper on executable enterprise architecture: TOGAF ADM + Open Agile Architecture + Loop Factory — architecture as a machine-readable, agent-executable, continuously-shipping system.
EYwALINK · 14 Sep 2026 · 19-page PDF · ~8 min read · v1.0
This whitepaper is published in English. 中文版本準備中 / Chinese version coming soon.
In this paper
1. Executive Summary
Enterprise architecture (EA) has a delivery problem. TOGAF ADM is the de-facto standard for architecture governance, but it produces artefacts that are documents, not executable programs. A 200-page transition architecture sits in a repository, gets stale within one quarter, and provides no machine-readable contract that a delivery pipeline can consume.
ArcKit EA solves this. It is a plugin architecture that makes enterprise architecture executable and AI-agentic:
- ▸
arckit-togaf-adm— 12 commands that turn TOGAF ADM into structured, traceable artefacts (16 doc-types) - ▸
arckit-oaa— 5 commands that turn Open Agile Architecture into sprint-level canvases (5 doc-types) - ▸ Loop Factory — a LangGraph state machine that consumes those artefacts and autonomously builds, tests, and ships the system they describe
2. The EA Problem
The Artefact Gap
Traditional EA tools produce diagrams and documents. The architecture document and the deployed system diverge immediately — there is no automated path from one to the other.
The Cadence Mismatch
TOGAF boards run quarterly. Agile delivery runs on 2-week sprints. The two never meet — by the time a board decision reaches a delivery team, three sprints have already moved the ground.
The Compliance Gap
Regulators require evidence, not policy. ArcKit's OAA plugin produces OASEC — compliance-as-code rules that are executable validation checks, not a PDF an auditor has to read and cross-reference.
Artefact gap, side by side
| Property | Traditional EA | ArcKit EA |
|---|---|---|
| Format | UML/SysML XML, PDF | Markdown (machine-readable) |
| Executable | No | Yes (feeds Loop Factory) |
| Traceable | Manually maintained | Auto-generated (TRAC) |
| Update cadence | Quarterly (best case) | Per-sprint |
| Consumed by CI/CD | No | Yes (LangGraph nodes) |
| Compliance evidence | Manual audit trail | Compliance-as-code rules |
3. ArcKit EA Architecture
3.1 Three-Layer Model
ArcKit EA is a compiler + CPU model: a strategic layer produces machine-readable artefacts, a tactical layer turns them into sprint-level specs, and an execution layer consumes the spec to build, test, and ship — autonomously.
3.2 Data Flow Between Plugins
The data contract between layers is the TRAC (Traceability) matrix — a machine-generated
cross-reference from every OAA requirement ID back to the TOGAF requirement it satisfies, enforced by the
arckit:traceability post-build hook.
3.3 Artefact Naming Convention
All artefacts follow ARC-NNN-TYPE-vN.N.md. This is critical for Loop Factory's
ingestion — the state machine parses artefact filenames to determine what to consume at each phase.
| Doc-type | Plugin | Description |
|---|---|---|
| ADMP | togaf-adm | Architecture Development Method Preliminary |
| BPCM | togaf-adm | Business Capability Map |
| REQ | shared (core) | Requirements Register |
| APP | togaf-adm | Application Inventory |
| APPR | togaf-adm | Application Rationalization |
| GAPA | togaf-adm | Gap Analysis |
| TRANS | togaf-adm | Transition Architecture |
| BORD | togaf-adm | Architecture Board Minutes |
| ACHG | togaf-adm | Architecture Change Request |
| REPO | togaf-adm | Architecture Repository |
| DISC | togaf-adm | Discovery — current-state inventory & baseline |
| DATA | togaf-adm | Data model, classification, GDPR mapping |
| TECH | togaf-adm | Technology stack, cloud topology, GPU sizing |
| PRIN | shared (core) | Architectural principles |
| STKE | shared (core) | Stakeholder map & register |
| STRAT | shared (core) | Strategy (org + digital) |
| OAAL | oaa | OAA Sprint Map (5-sprint plan) |
| OAPR | oaa | Product & Team Ownership |
| OASTR | oaa | Strategy Canvas (dual transformation) |
| OASEC | oaa | Security & Compliance (per sprint) |
| OAGOV | oaa | Governance Cadence |
| TRAC | shared | Traceability Matrix (auto-generated) |
4. Plugin Reference
4.1 arckit-togaf-adm — 12 commands, 2 recipes
| Command | Output | Use |
|---|---|---|
| arckit:adm-preliminary | ADMP | Scope, assumptions, constraints, stakeholder map |
| arckit:business-capability-map | BPCM | Capability map with maturity scores |
| arckit:discovery | DISC | Current-state inventory & baseline |
| arckit:application-inventory | APP | Current-state application inventory |
| arckit:application-rationalization | APPR | Consolidate/retire/replace decisions |
| arckit:data-architecture | DATA | Data model, classification, GDPR mapping |
| arckit:technology-architecture | TECH | Technology stack, cloud topology, GPU sizing |
| arckit:gap-analysis | GAPA | Current → target gap, risk register |
| arckit:transition-architecture | TRANS | Migration waves, strangle pattern, rollback |
| arckit:architecture-board | BORD | Board minutes, sign-off chain |
| arckit:architecture-change | ACHG | Change request (OAA → TOGAF ratification) |
| arckit:architecture-repository | REPO | Living repository index |
Recipes: togaf-adm-full (9 phases,
standard TOGAF) · togaf-agent-full (adds AAGI, AAGR, AAOV, AASE, AAIN, AAMT agent artefacts).
Default for EyWALink engagements: togaf-agent-full.
4.2 arckit-oaa — 5 commands, 1 recipe
| Command | Output | Use |
|---|---|---|
| arckit:oaa-adm-lite | OAAL | 5-sprint execution plan (OAA ADM Lite) |
| arckit:product-architecture | OAPR | Product & team ownership, RACI |
| arckit:agile-security | OASEC | Per-sprint security stories + compliance-as-code rules |
| arckit:agile-governance | OAGOV | Sprint governance cadence, architecture debt ledger |
| arckit:agile-strategy | OASTR | Dual transformation strategy canvas |
4.3 Decision Framework
| Scenario | Recommended | Rationale |
|---|---|---|
| Regulator-mandated enterprise baseline | togaf-adm alone | Defensibility, full traceability matrix |
| Greenfield AI product, < 8-week deadline | oaa alone | Sprint velocity, embedded security |
| Legacy estate modernization, 12-month programme | togaf-adm alone | Application rationalization depth |
| Cross-border multi-jurisdiction deployment | both | TOGAF baseline + OAA execution |
| Agentic AI platform (agent fleets) | togaf-agent-full | AAGI/AAGR/AAOV/AASE/AAIN artefacts |
| Continuous delivery, self-improving | both → Loop Factory | OAA outputs are Loop Factory fuel |
5. Walkthrough: Cross-Border Agentic Underwriting
Scenario: APAC insurance client. Agentic AI underwriting platform. APRA CPS 230 + GDPR dual jurisdiction. 12-week hard deadline. 6 engineers.
Week 3 · OAA Sprint Map
| Sprint | Focus | Cited TOGAF reqs |
|---|---|---|
| S0 (Vision) | AI workload type, data classification, jurisdiction, latency targets | REQ-001, REQ-015 |
| S1 (Biz + Data) | Capability gaps, value streams with SLAs, data asset inventory | REQ-012, REQ-015, REQ-023 |
| S2 (Tech) | Model serving, vector store, GPU cluster sizing, network topology | REQ-015, REQ-023 |
| S3 (Transition) | Migration waves, strangle pattern, dependency sequencing, rollback | REQ-012 |
| S4+ (Governance) | Ongoing review gates, change velocity thresholds, compliance evidence | REQ-012 |
Continuous · Loop Factory Execution
OAA sprints never edit TOGAF artefacts directly. Changes flow as ACHG
(architecture change request) → ratified by the TOGAF board → version increment.
This preserves the baseline's integrity.
The ARCH_REVIEW node is a human gate — architecture approval is not automated.
Everything else is autonomous.
Each sprint's artefacts feed Loop Factory's LangGraph state machine — eight phases:
6. Use Case Library
Australian Sovereign AI (APP/APRA)
APP Privacy Act or APRA CPS 230 compliance requirement for AI workloads.
Key artefacts: AAGI (agent inventory mapped to APP principles), AASE (agent security per APP 11.1), OASEC (compliance-as-code rules for APP 11.2)
Compliance-as-code rules are executable validation checks, not PDF policy documents. Auditors get a machine-verifiable evidence trail.
Cross-Border APAC Deployment
Multi-jurisdiction AI deployment (AU + SG + JP, etc.)
Key artefacts: REQ (dual-jurisdiction requirement IDs), OASEC (per-jurisdiction compliance rules), TRANS (strangle-pattern migration with jurisdiction-specific rollback)
Single source of truth for regulatory requirements (REQ artefact). Change the regulation → all downstream artefacts and compliance rules update automatically.
Legacy Estate Rationalization
Consolidation/retire/replace programme across 50+ applications.
Key artefacts: APP (inventory), APPR (rationalization decisions), TRANS (migration waves), ACHG (change requests for in-flight work)
APPR is machine-readable — delivery teams can query “which applications are in wave 3?” without parsing a 200-page PDF.
Greenfield Agentic AI Product
New AI product, < 8-week deadline, agile team.
Key artefacts: OAAL (sprint map), OAPR (ownership), OASEC (security per sprint), OAGOV (lightweight governance)
Time-to-first-sprint: 1–2 weeks. No quarterly board overhead. Security is embedded per sprint, not bolted on at the end.
7. Comparison: ArcKit EA vs. Traditional EA Tooling
| Dimension | Sparx EA / ARIS / Bizz | ArcKit EA ✓ |
|---|---|---|
| Artefact format | UML/SysML XML, PDF | Markdown (git-native, machine-readable) |
| Executable | No | Yes (Loop Factory consumes artefacts) |
| AI-assisted authoring | Limited (Sparx AI) | Full (agent-driven, guided intake) |
| Traceability | Manual (spend hours maintaining) | Auto-generated (TRAC matrix, per-sprint) |
| Compliance evidence | Policy PDF + manual audit | Compliance-as-code (executable rules) |
| Update cadence | Quarterly | Per-sprint (OAA) |
| Delivery integration | None (separate tool) | Native (LangGraph state machine) |
| Open source | No | Yes (Apache 2.0) |
| Cost | $50–200/user/month | $0 (open source) |
| Learning curve | 2–4 weeks (model editor) | < 1 day (markdown + CLI commands) |
Where traditional tools still win: formal UML/SysML diagram rendering, built-in stakeholder management workflows, and regulatory reporting templates. ArcKit uses PlantUML for deployment/sequence diagrams and generates raw artefacts — formatting for specific regulatory submissions remains a manual step.
8. Implementation Roadmap
-
Phase 1 · Foundation
Weeks 1–2- · Install ArcKit: arckit init or Claude Code plugin
- · Run togaf-adm-full (or togaf-agent-full) for baseline
- · Output: 16 doc-types, stakeholder map, capability map, requirements register
◆ GATE: Architecture board sign-off on ADMP + REQ -
Phase 2 · Tactical Planning
Week 3- · Run oaa-adm-lite against TOGAF baseline
- · Output: OAAL (5-sprint map), OAPR (ownership)
◆ GATE: Product owner approves sprint map -
Phase 3 · Sprint Execution
Weeks 3–12- · Run oaa-full per sprint
- · Output: OASEC (security), OAGOV (governance) per sprint
- · Run arckit:traceability after each sprint
◆ GATE: Per-sprint compliance verification (OASEC rules pass) -
Phase 4 · Continuous Execution
Weeks 3+- · Feed OAA artefacts into Loop Factory
- · Loop Factory runs: DISCOVER → REFLECT autonomously
- · ARCH_REVIEW = human gate (architecture approval)
◆ GATE: UAT + compliance verification per sprint -
Phase 5 · Operational Maturity
Ongoing- · REFLECT pattern storage feeds knowledge graph
- · arckit:health monitors architecture drift
- · Quarterly TOGAF board reviews accumulated OAA evidence
- · ACHG flow for any out-of-cycle changes
◆ GATE: Continuous drift monitoring
9. References
- · ArcKit source: github.com/terrygzhou/arc-kit
- ·
arckit-togaf-admplugin:plugins/arckit-togaf-adm/(12 commands, 2 recipes) - ·
arckit-oaaplugin:plugins/arckit-oaa/(5 commands, 1 recipe) - · Loop Factory: github.com/terrygzhou/loop_engineering_factory (LangGraph state machine)
- · TOGAF ADM: opengroup.org/togaf
- · OAA C208 standard: pubs.opengroup.org
Appendix A · Artefact Quick Reference
| File | Type | Plugin | Machine-consumed |
|---|---|---|---|
| ARC-001-ADMP-v1.0.md | ADMP | togaf-adm | Loop DISCOVER |
| ARC-001-BPCM-v1.0.md | BPCM | togaf-adm | Loop PLAN |
| ARC-001-REQ-v1.0.md | REQ | togaf-adm | Loop DISCOVER |
| ARC-001-OAAL-v1.0.md | OAAL | oaa | Loop DISCOVER/PLAN |
| ARC-001-OAPR-v1.0.md | OAPR | oaa | Loop DEFINE |
| ARC-001-OASEC-v1.0.md | OASEC | oaa | Loop BUILD/VERIFY |
| ARC-001-OAGOV-v1.0.md | OAGOV | oaa | Loop VERIFY/SHIP |
| ARC-001-TRAC-v1.0.md | TRAC | shared | Loop REFLECT |
Appendix B · PlantUML Diagram Sources
- ·
arckit-ea-layered-architecture.puml→arckit-ea-layered-architecture.svg - ·
arckit-ea-plugin-dataflow.puml→arckit-ea-plugin-dataflow.svg - Render:
python3 scripts/plantuml_render.py <name>.puml(via PlantUML server, no Java required)
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.
Get started with ArcKit
Both plugins: 12 TOGAF + 5 OAA commands, recipes, OASEC rules — Apache 2.0.
arckit initScaffold a machine-readable baseline in one command — walk through the interactive resource.
We'll map a 6–10 week pilot on your architecture — first shippable product within two sprints.
Want ArcKit on your architecture? Contact us — we'll map a 6–10 week pilot.