Studio Pipeline Dashboard

A visual node-graph editor for AgentTeam workflows. The Studio Pipeline Dashboard turns the multi-agent studio's role graph from an opaque JSON file into a drag-to-connect canvas you can author, share, and replay.

This page documents BOTH the MVP that ships TODAY and the roadmap to the full visual dashboard. Today's preview is honest about what it isn't yet.

Status

Capability	Status
Data contract (`StudioGraph` / `StudioNode` / `StudioPort` / `StudioEdge`)	Production-ready
AgentTeam → `StudioGraph` converter	Working
In-Editor JSON-dump preview (`Window > Buril > Studio (preview)`)	Minimal — text only
`studio_export_graph` / `studio_list_teams` ITools	Working
React Flow renderer in a Next.js webview	Y1 Q3 2026
Node library for ScenarioTemplates + arbitrary ITools	Y1 Q4 2026
Collaborative editing (multi-user)	Y2 Q1 2026

What today's MVP gives you is the FOUNDATION: a stable wire format, a defensive converter that turns existing AgentTeam JSON into a renderable graph, and an in-Unity preview that lets you SEE what the dashboard will know — text dump for now, drag-to-connect when the renderer lands.

How to access (today)

Window > Buril > Studio (preview)...

The window shows:

A dropdown of every AgentTeam file Buril can find (scans Tests/AutoPlay/agent_teams/*.json plus the optional BurilSettings endpoint studio.team_folder).
A read-only JSON preview of the converted StudioGraph.
An Export graph JSON... button that writes the same JSON to a file you pick.
A Re-read selected file button to pick up edits made outside the Editor.

Architecture

Data contract — `StudioGraph`

A pipeline graph is a flat list of nodes plus a flat list of edges. The wire format is snake_case JSON (matches the rest of the bridge codebase) and is FROZEN — the future React Flow renderer running outside Unity will consume this exact shape.

{
  "name": "Game Dev Studio Team",
  "description": "Sequential workflow: Architect → Tester → QA_Lead",
  "nodes": [
    {
      "id": "<guid>",
      "type": "agent-role",
      "label": "Architect",
      "position": { "x": 0, "y": 0 },
      "config": {
        "role_name": "Architect",
        "order_index": 0,
        "system_prompt_addendum": "You are the Architect. ...",
        "description": "Designs system architecture, ...",
        "temperature_hint": 0.2,
        "preferred_tools": ["list_scene_hierarchy", "..."]
      },
      "input_ports":  [ { "id": "in",  "label": "context", "data_type": "json" } ],
      "output_ports": [ { "id": "out", "label": "handoff", "data_type": "json" } ]
    }
  ],
  "edges": [
    {
      "id": "<guid>",
      "source_node_id": "<node-1>",
      "source_port_id": "out",
      "target_node_id": "<node-2>",
      "target_port_id": "in"
    }
  ]
}

Recognised node types (today): agent-role, scenario-template, subgraph, input, output, error. The error type is the diagnostic sentinel the converter emits when it can't read a source file — it surfaces as a red error card on the canvas instead of a blank graph.

Converter — AgentTeam → `StudioGraph`

AgentTeamToGraphConverter.FromAgentTeamFile(path) builds a graph from one AgentTeam JSON file. The v1 mapping is simple and conservative:

Nodes: each role NAME in the team's roles array becomes one agent-role node. The node's Config is enriched from AgentTeamRegistry.Presets (system prompt addendum, description, temperature hint, preferred tools) so the dashboard has everything it needs to render a tooltip without re-reading the registry.
Edges: roles flow in declaration order. role[0].out → role[1].in, role[1].out → role[2].in, etc. The v1 contract is sequential — a future iteration will reconstruct the actual DAG from handoff_history.

The converter is contracted to NEVER throw. Every failure mode (missing path, file not found, malformed JSON, valid JSON with wrong shape) returns a single-node error graph instead of an exception. The dashboard surfaces the error label + message so you can fix the source file.

ITools surface

Two read-only ITools expose the converter to external agents (Claude Code via MCP, chat, headless mode):

ITool	Effect	Description
`studio_list_teams`	ReadOnly	List every AgentTeam JSON file Buril can find.
`studio_export_graph`	ReadOnly	Convert a specific AgentTeam JSON file to a `StudioGraph` JSON.

The future React Flow renderer (running OUTSIDE Unity) calls studio_export_graph to populate its canvas.

Roadmap

Y1 Q3 2026 — React Flow renderer

A Next.js webview embedded in the Buril editor (VS Code fork) and exposed as a panel inside Unity Editor. Drag-to-connect, multi-select, undo/redo, save/load to disk. The renderer reads the same StudioGraph JSON shape we ship today — no schema migration required.

This is the "visual" half of the dashboard. The data contract is already production-ready; what's missing is the React-side canvas + a bidirectional bridge so edits in the canvas write back to AgentTeam JSON.

Y1 Q4 2026 — Node library

A palette of scenario-template nodes (each scene_template_* ITool) and arbitrary ITools as nodes. Drag any ITool from the palette onto the canvas, wire its inputs, and the dashboard becomes a visual orchestration tool — not just an AgentTeam viewer.

Y2 Q1 2026 — Collaborative editing

Multi-user real-time editing via the NovaEdenFederation A2A transport. Two designers on the same graph see each other's cursors + edits in real time. Conflict resolution is OT-based (operational transforms) to keep the graph eventually-consistent across peers.

Open questions

Eight design questions are still open before the full dashboard ships. They are tracked separately at docs/internal/buril-studio-open-questions.md and will be resolved during the Y1 Q3 2026 build.

Status​

How to access (today)​

Architecture​

Data contract — StudioGraph​

Converter — AgentTeam → StudioGraph​

ITools surface​

Roadmap​

Y1 Q3 2026 — React Flow renderer​

Y1 Q4 2026 — Node library​

Y2 Q1 2026 — Collaborative editing​

Open questions​

Read next​