Mapping for agents
Your agent shipped exactly what the ticket said (and broke three things it didn't). CardBoard carries the context the ticket couldn't, so it builds what you meant.
Works with Claude, ChatGPT, Cursor, Copilot, and anything that speaks MCP. Free on every plan. Read the MCP reference.
Point your agent at a plan and most tools hand it a grid of pixels and a wall of text. So it guesses, and you clean up after it.
CardBoard maps are typed: the method is in the map. Your agent reads the rules before it acts, and gets held to them when it writes.
What's live, and what's next.
- Connect over MCP
Claude (Desktop, Code, and claude.ai), ChatGPT, Cursor, GitHub Copilot, or any client that speaks MCP. OAuth, scoped to what you can see. Free on every plan.
- Read the map
The map type's rules and anti-patterns, then the cards, connections, release slices, groups, comments, and which cards are synced to Jira or Azure DevOps. Search across your workspaces returns pointers, not a dump.
- Start a board
Your agent can create a new map from a map type or from Mermaid: a flowchart, mind map, or sequence diagram comes in laid out and connected. A sequence diagram becomes one runtime path, step by step.
- Propose any change
New cards (up to 50 at once, with new release slices on a story map), edits to title, description, acceptance criteria, status, type, and color, plus moves, deletes, connections, and groups. Every one arrives as a ghost.
- Summon it with @Claude
Mention your agent in a card comment. It picks up the summon, reads the card, replies in the thread, and proposes any changes as ghosts. Up to 25 per summon.
- On the record
Each ghost carries the agent's logo and the initials of the person driving it. Accepted work is credited to whoever accepted it.
- Immediate agent replies
Today a summon waits until your agent checks in, so a reply lands when your own agent next runs. Next, agents your workspace admin installs answer on their own: summon one on a card, it acknowledges within seconds, and its work shows up in the thread. The agent's vendor runs the model. CardBoard never does.
- Living architecture maps (C4)
C4 map types for your system's context, containers, and components, with the same typed rules as every other map. Your agent drafts them from the code and proposes changes as the code moves, so the architecture diagram stops being the one nobody trusts.
Mention it where the work is.
Type @Claude in a card comment and you've summoned your agent to that card. It doesn't need a prompt pasted in from somewhere else. The card, its neighbors, and the thread are the prompt.
Your own agent answers, connected under your name, so it can only read what you can. It replies once in the thread, and anything it wants to change on the map comes as ghosts. Only workspace members can summon an agent, not anyone holding a share link.
The map teaches your agent the method.
A story map isn't a grid of boxes. It's a grammar: activities on top, stories beneath, sequence left to right, release slices across. CardBoard hands that grammar over up front: how the board is shaped, and the mistakes people make on it.
So your agent proposes work the way someone who knows the method would, not a card dump.
And holds your agent to it.
Reading the rules is easy. Following them is the work.
Drop a card between two lanes or hang an experiment off an outcome, and it won't take. The rules your agent read are the rules it's checked against, because both come from one definition. A map type can't advertise one contract and enforce another.
Your agent reads the structure. It doesn't guess it.
No squinting at coordinates to guess what connects to what. The read is the real structure: the map type's rules, release slices and groups, connections, comments, and which cards are synced to a tracker. Ask about one card and it gets the card's parents, children, connections, and what's been proposed on it before.
Connect a canvas tool to an agent and it has to infer what your layout meant, and that inference frays as the board grows. CardBoard declares the structure instead, so there's nothing to infer.
That edge compounds as the work gets bigger.
Speech is the agent's. Structure is yours.
Agents draft cards, edits, moves, and deletes, and suggest where each one goes. Nothing on a map changes until you accept it. You stay the author; the agent just makes the next good idea cheap.
What the agent says is its own: its replies post in the thread under its name. Every proposal is on the record, stamped with the tool and the person who prompted it.
An agent can start a brand-new board for you. It can't change one you're working on without your say.
Found in 3 support threads and a Jira epic. Sits under Check out.
ghost · waiting for a human to add it
What you'd actually ask it.
“@Claude split this into stories we could ship this month.”
Your agent picks up the summon, reads the card and the map around it, and replies in the comment thread. The stories it suggests land as ghosts in the right lane. You add the ones you want.
“Map our onboarding flow as a new board.”
The agent writes the flow as Mermaid and creates the board itself. CardBoard reads the diagram type, picks the flow map type, and lays it out connected. Prefer to paste it yourself? The New board menu takes Mermaid too.
“Add descriptions and acceptance criteria to the cards on the sitemap.”
The agent reads the map and proposes edits on existing cards, reviewed as one batch. Accept all, reject all, or go card by card. It re-reads your changes before the next pass.
Point your agent at a map.
A board that already knows the rules.
Works with Claude, ChatGPT, Cursor, Copilot, and anything that speaks MCP. Free on every plan.