Last updated July 20, 2026
Chat
Chat is your AI pair-architect. Instead of manually placing every node and drawing every edge, you open a conversation, describe what you need, and chat builds, analyzes, and evolves your boards through a multi-step agent workflow. Think of it as having a senior architect on call who knows your entire system context.
Opening a conversation
Chat is available on every screen of a board — the canvas, the hub, and each facet — not just the diagram. Click the Chat toggle at the top right of the board and the conversation slides in beside whatever you're looking at; the screen behind stays fully usable. A pulsing dot on the toggle means chat is still working on an answer, visible from any screen.
Start your first chat conversation
- Open any board screen and click the Chat toggle (top right)
- You're in a conversation — type your goal or question
- Hit send and watch the agent reason through the problem
- Review any board changes chat makes in real-time
- Switch screens freely — the conversation follows you
Each board has its own conversation group. Your history is preserved across sessions and across screens, so you can pick up where you left off.
Conversation scope
Every conversation has a scope — what it's about — shown as a chip on the composer. The scope does two jobs: it tells chat what to focus on, and it fences writes — chat can read anything in the workspace, but it can only change what's inside the scope.
- This board — the default: chat focuses on the board you're viewing and may only modify it.
- A facet — open chat from the specs, intents, aspects, or skills screen and it scopes to that facet automatically.
- Selected elements — select a node or edge on the canvas and the chip offers it as a one-click scope: "talk about this".
- Whole tree — on a command center, chat scopes to every board in the tree. Tree conversations are read-and-rollup only; they never modify a single board.
- Workspace — the unfenced legacy default, still available from the chip.
Click the chip to change scope mid-thread. Past threads in your history carry a scope badge, so "the intents triage chat" and "the checkout-selection chat" are distinguishable at a glance.
What you can ask
Chat is board-aware — it knows your nodes, edges, sources, and any insight results. Some things you might ask:
- "What happens if the auth service goes down?"
- "Explain the current architecture to a new developer"
- "What are the critical dependencies for the payment flow?"
- "Summarize the blast radius if we deprecate the legacy API"
Chat can read your connected sources, call external tools (including MCP servers), and modify your board — all within the conversation flow.
How the agent works
Chat follows a Reason + Act loop — it reasons about what you've asked, picks a tool if needed, observes the result, and reasons again:
- Context loading — your message, board state, conversation history, and available tools are assembled
- LLM reasoning — the model decides whether to respond directly or call a tool
- Tool execution — the selected tool runs and returns results
- Iteration — the model can call multiple tools in sequence, reasoning after each result
- Finalization — produces the final response, optionally including board modifications
Under the hood
Chat tracks rich state across turns:
- Conversation history — full message thread with role attribution
- Tool selection — which tools were resolved and made available for this turn
- Execution results — structured output from each tool call
- Iteration count — the agent can loop through reason-act cycles multiple times before finalizing
- Board modifications — any nodes, edges, or layers created or updated during execution are tracked and applied atomically
A configurable iteration limit prevents runaway loops. Each iteration adds to the conversation state, so the LLM has full context of what it's already tried.
Available tools
Tool categories
Chat has access to tools organized by capability:
Board tools
- Create, update, and delete nodes and edges
- Create and navigate layers (nested boards)
- Modify board metadata and layout settings
Facet tools
- Intents — list and read the queue, create an intent, create intents from insight findings, transition and assign. Every intent chat creates asks for your approval first and lands unreleased for review — chat proposes, you decide. See Intents.
- Insights — list past runs, read findings and suggestions, browse the available insight skills.
- Aspects, skills, sources — read a board's database tables, API endpoints, pages, event channels, and authorization registry; its compiled-skills profile; its source bindings — all read-only.
- Board tree & hub status — map the whole tree and get the "what needs attention?" rollup (intent counts, latest insight run, binding health) in one call.
Source tools
- Query connected sources for live data
- Read a bound reference document whole, on demand — pin the sources a conversation should use, or let chat pull any bound document (a PRD, an ADR) while it works
- Fetch repo structure, file contents, and metadata
- Read infrastructure configs and API specs
MCP tools
- Any tools exposed by your registered MCP servers
- Dynamically resolved based on server capabilities
- See MCP Servers for setup
The platform picks the tool set for each turn from your response format and conversation scope — a tree-scoped conversation gets rollup and read tools but no single-board writes, and intent tools appear only on boards that have intents. Anything that changes your model (a new intent, a board edit) either asks for approval in the chat or lands unreleased for your review — never a silent commit.
Conversation rooms and groups
Conversations are organized into groups with participant management:
- Resolve a group — open or create a conversation group for a board
- Invite participants — add team members to a conversation group
- Join/Leave — participants can join or leave active groups
- Thread history — browse previous conversation threads within a group
This makes chat useful for team collaboration, not just solo architecture work.
Watching execution
As chat works, you can observe:
- Tool calls — see which tools are being invoked and with what inputs
- Intermediate results — watch data flow back from tool executions
- Board changes — nodes and edges appear on your board in real-time as the agent modifies them
- Turn summaries — each conversation turn is summarized for quick reference
Chat respects your board's permissions. It can only modify boards you have edit access to, and it operates within your workspace context.
Response styles
Before you send a message, pick a response format in the composer. The format decides what kind of answer comes back — and which tools chat gets for the turn. A thread remembers its format, so a reopened conversation picks up in the same mode you left it.
Standard dialogue mode — great for Q&A, exploration, and open-ended discussion. Chat responds with text, optionally referencing specific nodes or edges, and can edit the board you're on through its board tools (every change asks for approval or lands staged for review).
Best for:
- Asking questions about your architecture
- Getting explanations for new team members
- Exploring "what if" scenarios
Some formats need a matching scope — a structured board response needs a single-board conversation, so incompatible options are disabled while a tree or facet scope is active. You can also set preferences for response style (detailed, concise, technical). Hand-curating individual tools is available only in the conversational format — every other format binds its own fixed tool set, because the format is the toolset.