Last updated September 16, 2026
Getting Started — Plugin or Chat
This is the assisted path: answer questions about your systems and let the interview draw the landscape. Run it from Claude Code or Codex with the architect plugin, or from Chat in the portal. Then bind each repo, sync it, and ask the board a question. Prefer drawing it yourself? Use Getting Started — Hands-On.
What you will have at the end
A system landscape on your root board, an app board for every repo you own, one of them mapped and synced from its code, and a first answer from chat. Repeat the sync step per repo until every app board is filled.
Use it solo or as a team:
What you need
- A workspace and local clones of the repos you are mapping.
- For the plugin path: Claude Code or Codex. The architect plugin runs on both, not on Cursor yet. The code plugin runs on all three.
- For the chat path: nothing extra. Chat starts on your organization's trial credits. Connect a model provider (e.g. OpenRouter) under Settings → Connectors when they run out. The plugins need none.
The guide in the app
The Setup guide in the top bar tracks real setup state. Pick Let your AI assistant map it or Ask chat here. The guide then shows the four steps below, one at a time: set up your workspace, create your first app, connect the repo and sync, ask the board a question. Each step names the control to use with a chip that looks like it; click the chip or Show me and the real control pulses. A step completes when the thing happens (a board appears, a push arrives), not when you click "next".
The plugins you use
Each plugin has a different job:
Unsure what to run next in any of the plugins? /start shows the command groups, ranks the next steps for your state, and offers to run the first. Every command ends with an Outcome: what it did, what it left, and the next command with the reason.
Set up your workspace
The interview asks what your systems are, what each does, and what talks to what. Answer at the level you know; unclear areas do not block the rest. Choose where to run it.
Chat starts on your organization's trial credits. The first message you send offers to turn them on, and nothing needs configuring first.
Open Chat from the board bar. While nothing has been modelled yet, the new-thread panel offers Set up this workspace. Choose it: chat interviews you about the systems you run, draws the landscape on the root board, and creates an empty board for each app that has its own repository. Every board it creates or draws appears as a card in the conversation, and each change waits for your approval before it lands.
Once the workspace has content, that quick start disappears — from then on you add systems by asking, or with /new-app in the architect plugin.
After approval, your root board holds the system landscape, and every repo-backed system has an app board of its own.
- 1
Drill-down indicator
Opens the system into its own board layer — right-click any node and choose Create Subsystem Layer to add one.
- 2
Typed connections
Edges carry a description of the relationship, rather than an unlabeled line between systems.
Create your first app
Usually this step is already done: the interview created an app board for every repo-backed system, and the guide ticks it off. Check the root hub — every app board is listed there.
If a system you own has a layer but is not an app yet, open its board and choose Make this an app from the board menu. Pick the app type and sync branch. If it has no layer, right-click its node and choose Create Subsystem Layer first. You can also drag an app from the canvas Apps palette to create the child app board, source, and binding together. One rule applies either way: one app, one repo. The details are in Getting Started — Hands-On.
Connect the repo and sync it
The app boards are empty on purpose: content comes from code, not the interview. In each repo, install the code plugin from the same marketplace (pmap-code@provenmap; Cursor works too) and run:
/analyze runs inside your own coding session and maps services, APIs, databases, and queues. It needs no model provider. It writes to .provenmap/ and never edits your source. /sync pushes the result, and the landscape node for that system now opens into its real internals.
The guide watches two things here: that the app board is bound to a code source, and that its first push has arrived. No browser sign-in? Agent access on the app board's hub shows the binding token and snippets, and /configure sets up credentials by hand. Credentials are shown once when issued; Generate new secret in the binding's credentials dialog issues a fresh one without disturbing any machine already connected. Connecting Sources has the full setup sequence.
- 1
Breadcrumb
The app and the layer you are in — jump back up to the landscape from here.
- 2
Components as nodes
Each part of the stack becomes a node, connected by dependency edges — this is what a first /sync produces.
Repeat per repo. One binding maps one repo, so one repo change updates one board. On the plugin path, the architect plugin's closing Outcome carries this step as a Hand off line for each repo's developer.
Ask the board a question
Open Chat on the synced app board and ask about what arrived. Two questions worth trying:
- What depends on the database?
- Which services call the auth API?
Chat answers from the board and its sources, and can answer with a drawn board instead of text. If this is your first message, chat offers to turn on the organization's trial credits. Connect a model provider (e.g. OpenRouter) under Settings → Connectors when they run out.
That completes the setup guide. Chat covers what else it can do, and Org-Level Intelligence what opens up once several systems are mapped.
After setup
Once a repo is mapped and synced, /discover ranks the insights and context boards worth showing first. Pick from its menu or let it choose, then push the results to the board. In the architect plugin, the same command reads the whole workspace and can trace a request across apps.
The connect plugin attaches source signals such as errors, incidents, funnels, traces, or product analytics to the architecture elements they affect. Run it from Claude Code, Cowork, or Codex sessions where those source connections are available. It sends insights back to the platform on a schedule or when notable events occur. Architects create intents from those insights and hand them off, developers pull them with /intents, and the next /sync verifies structural changes against code.
If the architect sketched a target architecture before the repo connected, the first push does not erase it. Analysis compares the code to the sketch, and every disagreement appears as an intent.
Founding a product line instead
In the architect plugin, answer founding something new and the command stays strategic: product line, intended systems, and relationships. It generates no boards because there is nothing to map or bind yet.
When one of those planned systems becomes real, /new-app adds it to the existing landscape and continues from there.
You are done — checklist
- Set up the workspace with
/setup-workspaceor chat's Set up this workspace: landscape drawn, app boards created - Every repo-backed system is an app board
- In one repo: code plugin
/login→/analyze→/sync, and the push arrived - Asked the board a question in chat
- (Optional) Repeated the sync per repo, connected live source signals, authored a first intent
Where to go next
The Architect Workbench
The full lifecycle behind the interview: daily work, authoring, and reviewing.
Chat
Questions, drawn boards, reviews, and drafted intents from one conversation.
The Code Plugin
Every command, flag, and config field for filling a board.
The Connect Plugin
Correlating source signals with architecture elements and sending insights back to the platform.

