Last updated July 24, 2026
Org-Level Intelligence
You've mapped repos into boards. You've layered them, bound docs alongside code, run insights. Each board is sharp on its own. The next move is to treat all of them as one thing: an organizational landscape your whole team can question in plain language.
That's what this page is about — turning a pile of boards and sources into something anyone can ask, and something the right people can publish, govern, and trust.
Audience: architects and technical leaders. If you haven't built a landscape yet, start with Getting Started first.
The idea
Every board you build adds to the same picture. The Root Board is your system at L0; layers drill into services; separate repos come in as separate bindings, each its own board. Code-derived structure and reference docs sit side by side.
Chat is the interface to all of it. Instead of a stakeholder hunting through boards, they ask a question — and the agent reads the landscape to answer.
The boards are the durable map. Chat is how people without architecture fluency get value from it.
Connect a model provider
The plugin path — /analyze → /sync → /insights → publish — needs no model connection. But everything on this page runs through Chat, and Chat requires a connected model provider. So before you go further, connect one. It's a one-time, org-wide setup.
- Go to Settings → Integrations in the portal (org-level).
- Find the OpenRouter card under LLM Provider and click Connect.
- Authorize on OpenRouter's consent screen — the platform uses OAuth 2.0 PKCE, so there's no client secret to paste.
- On redirect, the connection completes. The card should read Connected.
One connection is shared across the whole org — set it up once and every workspace can use Chat.
This powers the platform's AI features (Chat, in-app insight generation). It's separate from the ContextDX plugins (Cdx Code, Cdx Work), which run their analysis locally in your editor and never call a model on the server's behalf.
Ask your architecture anything. Get a board.
This is the headline, so let's be concrete.
A CTO opens Chat and types:
"Walk me through why customer orders keep failing, and tell me what we'd simplify."
The agent reads the landscape — the relevant boards, their nodes and edges, the bound sources — and instead of a wall of text, it generates a focused context board on the fly: say, "Customer Order Failure Investigation." It pulls in only the nodes that matter to that question, draws the path the failure travels, and explains it in the conversation alongside.
The CTO never touched a diagram tool. They asked; they got a board scoped to exactly what they asked.
A context board is generated to answer a question. It's different from the permanent layered boards the plugin builds from code — those are your durable map; a context board is a focused view drawn from it.
Response formats
Chat shapes its answer to the question. Pick the format that fits:
| Format | What you get |
|---|---|
| Conversational | A direct natural-language answer. Quick exploration. |
| Structured Board | A context board generated from the response. |
| With Insights | The answer plus insight overlays on the board. |
| Insights + Research | Deep analysis with citations pulled from bound sources. |
With Insights and Insights + Research generate insights live through the agent, so they need a connected model provider. This is distinct from the Insights Bar in the portal, which only displays insights already on a board.
Deep dive: Chat
Reasoning over the landscape
When you ask a question, the agent grounds its answer in real structure — it reads the source and landscape boards, the archetypes that classify each node, and the bound sources. It isn't guessing from a model's training; it's reasoning over your map.
The richer the landscape, the better the answers. A board with governing code structure and reference docs lets the agent explain both the what and the why — neither alone gives you that.
Here's the honest line on scope:
Chat already reasons across boards to answer a question. What's still being optimized is holding that context over a long, multi-turn conversation — so answers are sharpest in shorter exchanges today.
Value by role
One landscape, many lenses — the same boards and sources answer very different people, each picking the response format that fits the job.
| Role | Ask it something like | Best format |
|---|---|---|
| CTOs & engineering leaders | "We handled 10K daily orders. What breaks at 100K, and what would we simplify?" | Insights + Research |
| Engineers & platform teams | "We're integrating Avalara for tax — how does it wire into checkout, and what might break?" | Conversational |
| Product managers & analysts | "A subscription-box feature — what systems does it touch, and what's the scope?" | With Insights |
| Enterprise architects | "Which services don't follow our API-versioning standard?" | Structured Board |
Beyond format, Chat's response styles tune how technical or concise each answer comes back — set them in the same composer. And the people who'd rather not ask at all? They self-serve from a published board — next.
Publish and share org-wide
A board's value multiplies the moment a non-technical stakeholder can read it without asking you. Publishing turns a board into a read-only, interactive snapshot anyone can open — navigation, insight overlays, and doc sections included. No login required, depending on visibility.
Control who can see it per board:
| Visibility | Who can view |
|---|---|
| Public | Anyone with the URL |
| Unlisted | Only people with the direct link |
| Protected | Requires a password or token |
Re-publish to update — the URL stays stable, the content reflects your latest sync. This is the "stakeholders just self-serve" story: a PM checks the order flow, a new hire reads the auth path, a CTO reviews the landscape — none of them wait on an architect.
Deep dive: Publishing Boards
Govern
Org-level intelligence is only as trustworthy as its governance. Set these up once and the whole org benefits.
Custom archetypes
Define first-class concepts for your domain (Adapter, Saga, Plugin) with their own icons, colors, and relationship rules — so every board reads consistently.
Insight-skill authoring
Author the /insights skills your team runs — security checks, dependency audits, migration readiness — as reusable, workspace-defined templates.
Permissions & access
Org roles set how far an account is trusted; per-board access decides who reads and edits each board. Two layers, one place to reason about them.
Organization settings
Org-wide config — model provider, archetype catalogue, members and roles — all in one place.
Set the vocabulary and the guardrails once, and every board your team builds reads consistently against them.
Checklist
- Connected a model provider (org-level, one-time)
- Asked Chat a real question and got a context board back
- Tried the response formats — Conversational, Structured Board, With Insights
- Published a board and shared the link with a non-technical stakeholder
- Set up custom archetypes and authored at least one insight skill
- Reviewed permissions so the right people can edit, view, and publish
What's next
Chat
Go deeper on response formats, agent personalities, and how Chat reasons over a board.
Publishing Boards
Visibility controls, the stakeholder viewer, and keeping published boards current.
Organization Settings
Custom archetypes, members, roles, and the org-wide model connection.
Permissions & Access
Org roles, per-board access, and published visibility — and how the three combine.