Back to Articles ArcKit TOGAF ADM hero showing ADM phases as versioned ArcKit artefacts with 9 command document codes and the togaf-adm-full recipe
1 July 2026

arckit-togaf-adm turns the TOGAF Architecture Development Method into versioned ArcKit artefacts. It ships nine commands and the togaf-adm-full build recipe for ADM preliminary work, capability mapping, application inventory, rationalization, gap analysis, transition architecture, implementation governance, change management, and architecture repository synthesis.

Why TOGAF belongs in the harness

Many enterprise architecture teams already use TOGAF language. They talk about preliminary work, architecture vision, business architecture, application architecture, opportunities and solutions, migration planning, implementation governance, architecture change, and the architecture repository.

The problem is not the vocabulary. The problem is how easily the work turns into disconnected documents.

A capability map sits in one deck. An application inventory lives in a spreadsheet. A gap analysis becomes a workshop note. Transition architecture gets copied into a roadmap. Architecture board decisions are recorded somewhere else. Lessons learned may never reach the repository.

arckit-togaf-adm brings those ADM-shaped outputs into the ArcKit project model: versioned files, document control, provenance, traceability, templates, health checks, and repeatable naming.

What the overlay adds

The plugin adds nine slash commands:

  • /arckit:adm-preliminary for preliminary phase, scope, drivers, constraints, and architecture vision.
  • /arckit:business-capability-map for strategy, capabilities, value chains, and business architecture.
  • /arckit:application-inventory for application portfolio assessment, lifecycle, ownership, and integration patterns.
  • /arckit:application-rationalization for consolidate, retire, replace, or retain decisions.
  • /arckit:gap-analysis for target-state gaps, workload prioritization, and opportunities and solutions.
  • /arckit:transition-architecture for migration planning, transition states, work packages, and sequencing.
  • /arckit:architecture-board for implementation governance, board cadence, compliance review, and decision tracking.
  • /arckit:architecture-change for change requests, impact, approvals, and ADM re-entry.
  • /arckit:architecture-repository for patterns, standards, reference architectures, reusable decisions, and lessons learned.

The document codes are ADMP, BPCM, APP, APPR, GAPA, TRANS, BORD, ACHG, and REPO.

That means TOGAF ADM work becomes ordinary ArcKit output:

projects/003-modernisation/
  ARC-003-ADMP-v1.0.md    # ADM Preliminary / Architecture Vision
  ARC-003-BPCM-v1.0.md    # Business Capability Map
  ARC-003-APP-v1.0.md     # Application Inventory
  ARC-003-APPR-v1.0.md    # Application Rationalization
  ARC-003-GAPA-v1.0.md    # Gap Analysis
  ARC-003-TRANS-v1.0.md   # Transition Architecture
  ARC-003-BORD-v1.0.md    # Architecture Board

Global repository synthesis can live where cross-project knowledge belongs:

projects/000-global/ARC-000-REPO-v1.0.md

ADM without a parallel document universe

The useful part is composability.

/arckit:adm-preliminary can read principles, stakeholders, and strategy. /arckit:business-capability-map can connect back to requirements and drivers. /arckit:application-inventory gives gap analysis and rationalization a real portfolio baseline. transition-architecture depends on the gap analysis. architecture-board ties implementation governance back to principles and ADM preliminary work. architecture-repository synthesizes reusable knowledge from completed artefacts.

That keeps ADM work from becoming a parallel universe. It is part of the same governed architecture project as requirements, risks, ADRs, diagrams, business cases, procurement notes, and assurance evidence.

The togaf-adm-full recipe

The overlay includes the togaf-adm-full build recipe.

The recipe starts with core ArcKit foundations:

principles
  -> requirements + stakeholders
  -> strategy

It then builds the ADM flow:

adm preliminary
  -> business capability map
  -> application inventory
  -> application rationalization
  -> gap analysis
  -> transition architecture
  -> architecture board
  -> optional architecture change
  -> optional architecture repository
  -> health + traceability

The optional targets matter. Not every architecture cycle needs an immediate change request. Not every project should synthesize the global architecture repository on every run. The recipe makes those choices explicit.

Working with the agent architecture overlay

arckit-togaf-adm is useful on its own, but it also composes with arckit-agent-architecture.

That is why the TOGAF plugin includes togaf-agent-full. It combines ADM delivery with the agent inventory, design, governance, integration, security, and optional maturity outputs from the agent overlay.

Use that combined recipe when the enterprise architecture question and the agent question are the same delivery problem. For example, a team modernising a casework platform may also be introducing triage, summarisation, research, and workflow agents. The capability map, application inventory, transition architecture, agent design, integration contracts, security posture, and architecture board need to agree with each other.

The separate agent architecture article covers that overlay in detail. The key point for TOGAF users is simpler: ADM remains the frame, and agent governance can sit inside it.

Getting started

The plugin depends on the core arckit Claude Code plugin:

claude plugin install arckit arckit-togaf-adm

Then run the commands directly:

/arckit:adm-preliminary "Casework modernisation"
/arckit:business-capability-map 003
/arckit:application-inventory 003
/arckit:application-rationalization 003
/arckit:gap-analysis 003
/arckit:transition-architecture 003
/arckit:architecture-board 003
/arckit:architecture-change 003
/arckit:architecture-repository 000

Or use the build harness:

/arckit:build 003 --recipe togaf-adm-full --plan
/arckit:build 003 --recipe togaf-adm-full

If the agent overlay is also installed, use the combined recipe:

claude plugin install arckit arckit-togaf-adm arckit-agent-architecture
/arckit:build 003 --recipe togaf-agent-full --plan

Scope

This first release covers the ADM cycle and the architecture repository: Preliminary, phases A through H, plus repository synthesis.

It does not attempt to implement the full TOGAF content framework meta-model. It does not replace organization-specific ADM tailoring guidance. Those are candidates for future extension work. The initial goal is narrower and more useful: make ADM-shaped architecture delivery fit ArcKit's governed artefact model.

Why this matters

TOGAF is often treated as a method outside the delivery system. ArcKit works best when the method is inside the work: commands, templates, generated artefacts, document IDs, dependencies, checks, and traceability.

arckit-togaf-adm makes that possible for teams that already speak ADM. It does not ask them to abandon the method. It gives the method a working surface.

That is the practical value: less ceremony drifting across files, more architecture work that can be inspected, versioned, challenged, reused, and connected to the decisions a programme is actually making.

arckit-togaf-adm is an MIT-licensed community overlay for Claude Code. It requires the core arckit plugin.

Join the ArcKit Community