AI writes the code. Understanding is the work.
The living map of your systems.
One map, drawn from your code and docs and kept true as they change. Understand what you have, ask it anything in plain language, and change it with confidence. For architects, and everyone they work with.
Free during preview · No credit card · No AI provider required to start ·
The command center — a real board of a live system, from its own code.
The gap that's widening
Your systems change faster than anyone can explain them.
Known by a few
Generated by AI
Read by no one
Understanding was scarce before AI wrote a line of code. Now every sprint ships systems no one has read — and the gap compounds.
The explanation was never missing — it's in the code, waiting to be read.
You stop writing understanding and fighting to keep it current. The system explains itself — and stays explained as it changes.
The walkthrough
See what you have. Ask it anything. Keep it true.
One board, the whole loop — the systems you already run, the questions you ask them, and the changes that keep them true.
01 · Understand
Connect sources. Analyse. Sync.
Connect the sources behind every system — repos, documents, infrastructure. The platform consolidates them into one architecture: layered boards for the detail, contextual views for the question at hand, and a hub to manage the whole estate.
- 01Connect> Bind the board to its sources.
- 02Analyse> Turn the sources into an architecture of nodes and domains.
- 03Layer> Stack the detail into drill-down boards.
- 04Sync> Keep the map current, and flag what’s stale.
Your sources
/configure # connect
/analyze # map the repo
/sync # push the map
+24 nodes · +41 edges
→ runs locally — only the map is pushed
Every system on one current, layered map — with staleness visible and a hub to manage the whole architecture from one place.
02 · Query
Ask your architecture anything. Get a board.
Non-technical stakeholders shouldn't decode system diagrams. They should just ask — and get a diagram scoped to their question, built from the live architecture, not from whoever happens to remember.
“
Board generated
The failing path, traced to the root cause — the walkthrough explains every hop.
- 01Ask> Ask in plain language.
- 02Analyse> It reads the live architecture, scoped to the question.
- 03Board> The answer is a board, not a paragraph.
- 04Explain> The diagram comes with its walkthrough.
One question becomes a focused, shareable board that answers it — no waiting on an architect.
03 · Maintain
No change lands until a person says so — and the code proves it.
Board edits, production errors, spec requirements, and AI proposals all arrive as drafts in one queue. A person reviews and releases them, and the board verifies the result when the code ships.
- 01Signal> Every change lands in one queue as a draft.
- 02Triage> Each draft arrives scoped, with its origin attached.
- 03Decide> A person releases, defers, or rejects each one.
- 04Verify> Shipped changes are checked against the code.
/intents # pull queue
claimed rate-limit-api
/sync
+1 edge · verified
Every change to your architecture is reviewed by a person, traceable to its origin, and verified against the code when it ships.
One map, aimed at the job in front of you.
- Impact analysis
- Predict what a change will break — across every system it touches — before you ship it.
- Developer onboarding
- New engineers learn the system from the live map, not a stale wiki — days, not months.
- Migration planning
- Turn a validated dependency map into a move sequence, re-derived as you go.
- Decision capture
- Record architectural intent where the work happens — before the reasoning dies in Slack.
- Drift detection
- Know when the built system has diverged from its intended design, before it becomes debt.
Explore living architecture, published
A real board, mapped from code and kept in sync — pan and explore it right here, then browse more at contextdx.com/boards.
It's real, it fits your stack, and it's for everyone who ships.
We run on it.
The map at the top of this page is our own system. This change shipped through the loop and came back verified against the code.
They execute. We remember.
The plugin runs inside the coding session you already use — the agents execute; we own what should ship, and whether it did.
- Claude Code
- Codex
- Cursor
analysis stays local — only the map is pushed
The whole team drives.
Analysts, PMs, and engineers move changes safely inside your guardrails. You hold the pen on structure; nobody waits on a title.
bottleneck → multiplier
Not to be confused with
vs. coding agents
They execute and forget by the next session. We are their missing visual memory.
vs. EA tools
They describe systems. We operate them — fed by the code, closed against it.
vs. task trackers
A ticket has no idea what your system looks like. Ours is anchored to it.
vs. wikis & docs
Where understanding goes to die. Ours is the source work ships from.
Start with one repo
See it map your systems — then watch a change come back proven.
The loop earns the rest. Start free during the technical preview, or have us walk you through it on a real codebase.
No credit card · Analysis runs locally in your own session · Self-hosted available
Or for writing on architecture that stays true to the code.