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 Quick Start and Advanced 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.

Rendering diagram...

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.

1. Go to Settings → Integrations in the portal (org-level).
2. Find the OpenRouter card under LLM Provider and click Connect.
3. Authorize on OpenRouter's consent screen — the platform uses OAuth 2.0 PKCE, so there's no client secret to paste.
4. 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.

Deep dive: Integrations Reference — connect a model provider (e.g. OpenRouter)

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:

Deep dive: Chat concept | Chat guide

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.

Here's the honest line on scope:

What ships and works today: multiple boards and sources in one workspace, the agent reading the source and landscape boards to ground answers, on-the-fly context boards, publishing, and org governance. That's a lot — and it's real.

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:

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.

The architect stays in control; the organization gets architectural clarity. That's the whole point.

Where this is going

We document what ships and mark what's coming — no roadmap dressed up as a feature.

Here today:

• Multiple boards and sources per workspace, each repo its own binding.
• Chat grounded in the source and landscape boards plus archetypes.
• On-the-fly context boards from any question.
• Publish-and-share with no-login viewing and per-board visibility.
• Org governance: custom archetypes, insight-skill authoring, permissions.

The expanding frontier:

• Cross-repo correlation — synthesizing findings across many independent boards and bindings in a single turn.
• Cross-source chat — reasoning fluidly over code, docs, infra, and observability together as one queryable whole.

When these land, this page updates. Until then, the honesty callout above is the real boundary — and it's wide enough to be genuinely useful now.

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