AI writes the code. Understanding is the work.
The living map of your systems.
One map, drawn from your sources 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 an entire architecture, mapped 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 hand-drawing the diagrams, then fighting to keep them from going stale. The system explains itself — and stays explained as it changes.
The walkthrough
See your systems whole — then change them from the same map.
One board, the whole loop: understand what you already run from its sources, ask it anything in plain language, and change it with intents that ship into your systems — and come back verified.
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
Layers
The board has real depth. Open any node to drop into its child layer — from the whole system down to a single component.
“How do our systems connect?”
“What's inside the billing service?”
“What does this component do?”
Every system on one current, layered map — with staleness visible and a hub to manage the whole architecture from one place.
02 · Ask
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 · Evolve
The map you can read is the map you can change.
Author the change right on the board — pick the systems, layers, and elements involved and say what should happen to each in plain language. It becomes an intent: precise, anchored instructions your developers pull into their coding sessions, implement in the repo, and send it back verified. A one-line fix or a whole feature travels the same loop.
- 01Construct> Pick the elements; say what should change.
- 02Release> You release it — machines propose, people commit.
- 03Implement> Developers pull it with /intents into the repo.
- 04Verify> /sync pushes the change back; the map proves it.
/intents # pull queue
claimed rate-limit-api
/sync
+1 edge · verified
Your architecture evolves on the map you already trust — every change authored in context, shipped into your systems, and verified against them when it lands.
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 verified dependency map into a migration order, 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. A change to it 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, and verified 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 makes the case. 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.