Governance paperwork is multiplying and AI made it worse — DPIAs, AI impact assessments and architecture reviews scattered across a dozen tools. AIAP collapses them into one living, machine-readable architecture that every assessment fills from, and that Claude and other agents read, extend and build over MCP.
Enterprises are drowning in design and governance artifacts — and AI just poured fuel on the fire. The documents that are supposed to prove your systems are safe and compliant are scattered across a dozen tools, drifting out of date the moment they're saved.
Solution designs, architecture reviews, DPIAs, EU AI Act screenings, ISO 42001 and SOC 2 evidence — every initiative now ships with a stack of governance paperwork to fill in and keep current.
Each AI system drags its own compliance tail — model cards, AI Impact Assessments, risk reviews. The faster you ship AI, the faster the documentation backlog grows.
It all lives in slides, wikis, spreadsheets, tickets and drives — disconnected from the system it describes. Nobody can prove coverage, and every audit becomes an archaeology project.
AIAP collapses the sprawl into one living graph. Design the system once; every assessment and governance form fills from the same machine-readable source of truth — versioned, audited, and ready for an agent or an auditor.
AIAP makes enterprise architecture a first-class engineering artifact — structured, versioned, reusable, and consumable by AI. Not a picture of the system; the source of truth that builds it. Cards marked Soon are on the roadmap — including ideation, governed catalogues and gated reviews.
Model systems as a typed node-graph — services, agents, models, datastores — mapped to architecture layers. The diagram renders the data; the data is the truth.
Auto-save the working copy, then publish named versions with changelogs you can diff and restore. Enterprise architecture with release discipline.
Reuse a component from another project, pinned to a version. When the source ships, dependents get an update prompt — provenance, never a silent break.
Start from curated reference architectures, drop in shared org components, and publish your own. Reuse with lineage instead of copy-paste.
Every architecture is a live Model Context Protocol endpoint. Agents read full context and propose changes through validated, audited tools.
An in-canvas assistant grounded in your project — it proposes components and connections as structured, reviewable diffs you approve.
Spin up a free-form space to explore options and trade-offs with AI before committing anything to a governed canvas.
A governed registry of approved models, providers and AI services — so every project builds on vetted, compliant building blocks.
Curated reference architectures and solution patterns, ready to instantiate into a new project with lineage intact.
Track personal-data flows, lawful bases and DPIAs in one place, linked to the components that actually process the data.
Route significant changes through a lightweight CAB with impact analysis and approvals — governance without the gridlock.
Require sign-off gates — architecture, security, DPIA — before a version can ship, configured per org and per risk level.
We keep the rigor enterprise architects rely on — the four TOGAF domains, capability mapping, and governance — and shed the ceremony. Every component carries its layer, capabilities and metadata, so designs stay coherent as they scale and as agents extend them.
Capability tags, versioned snapshots and a full activity log give you TOGAF-grade traceability and reuse — best practices enforced by the tool, not a binder.
Drag typed components onto the canvas, connect them with labeled edges, and capture goals, capabilities and decisions inline.
Publish snapshots, link components across projects, and pull from the shared library so nothing is re-drawn from scratch.
Point Claude or any MCP client at the project. The agent reads the full graph and implements — no separate brief, no lost context.
Diagramming tools and wikis give you pictures and prose that go stale. AIAP makes the architecture structured data — so governance, reuse and AI all work from the same place.
Generate a scoped token and any MCP client — Claude Code, Claude Desktop — connects to your project endpoint. Reads return the full architecture; writes go through validated tools. Every change is schema-checked, scoped to your membership, and recorded in the activity log.
Get your endpointBegin solo at no cost, grow into a per-seat team workspace, and add governance when you need it. Agents reading your architecture are always free.
For individual architects exploring the platform.
For teams designing and shipping AI systems together.
For organizations with governance and scale needs.
Indicative pricing for the v1 roadmap — final plans may change as features ship.
Design your system once, version it like software, and hand it to AI to build.