Cobuild

Cobuild is a chat-driven workspace for building Honeyframe assets end-to-end. Inside one Cobuild session you can ask a planning agent to discover datasets, profile data quality, propose a recipe, generate a dashboard, run governance checks, and promote the result to live — without leaving the surface or stitching together the individual builder pages by hand.

Cobuild shipped in v0.0.62 (data model + planner + parallel workstreams + governance integration); the v0.0.63 release added a persistent right-rail dock so you can chat with Cobuild from any project page.

Concepts

A Cobuild session is a top-level workspace tied to a project. Sessions persist across reloads and across pages — the dock surfaces them on every project page.

A session can run multiple threads in parallel. Each thread is an independent workstream — its own agent loop, its own approval state, its own primary asset. You might spawn one thread to build the bookings dataset, another to build the revenue dashboard, and a third to set up the governance review, all from a single user prompt.

Each thread persists turn-by-turn messages: user prompts, assistant replies, the planner's intermediate tool calls, and any approval decisions.

session
├─ thread A — "build bookings dataset"     (status: completed)
├─ thread B — "build revenue dashboard"    (status: awaiting_approval)
└─ thread C — "set up governance review"   (status: running)

The planner agent

Cobuild's planner runs Honeyframe's standard agent loop with a curated toolset scoped to authoring tasks:

Tool	Purpose
catalog_discovery	Find matching datasets by name, tag, or layer.
profile_dataset	Get row count, column types, null counts, top-K distinct values, numeric summaries.
create_recipe	Generate a recipe (prepare / join / group_by / SQL) targeting a chosen dataset.
create_dashboard	Generate a dashboard with cards over a chosen recipe or dataset.
patch_recipe_step	Modify one step of an existing recipe (the first mutation tool on the chat surface).
run_governance_review	Fire a governance run on a recipe / dashboard / agent.
promote_to_live	Flip an asset's is_test=false, gated by a passing governance run.
spawn_workstreams	Fan out the current plan into multiple parallel threads.

The planner can call read-only tools freely. Mutation tools (anything that writes to the database — create, patch, promote) pause the loop and surface a PlanCard to the user: a friendly summary of what the LLM intends to do, with Approve and Reject buttons. Approval resumes the loop; rejection feeds the user's note back as context so the planner can revise.

Plan cards and approval gates

When the planner intends to call a mutation tool, the thread enters status='awaiting_approval' and the message surface renders a PlanCard:

┌─────────────────────────────────────────────────┐
│ 🛠️  Plan                                         │
│                                                 │
│ I'll run a governance review on your recipe:    │
│ • asset_resolved                                │
│ • has_executable_body                           │
│ • no_unmasked_pii                               │
│                                                 │
│         [ Reject ]      [ Approve ]             │
└─────────────────────────────────────────────────┘

Rejecting opens a note field — your comment is appended to the planner's context and the loop resumes with the chance to revise.

The Cobuild dock

The dock mounts as a right-rail surface on every project page. Collapsed, it shows an icon plus a session count and an unread badge when any thread anywhere needs approval. Expanded, it lists every session in the project with its threads and approval state.

Affordance	What it does
Click session row	Opens the chat surface inline in the dock — the project page underneath stays put.
Chevron toggle (multi-thread)	Expands the inline thread list. Each thread shows its title and an ↗ link to its primary asset.
Click thread title	Opens that thread deep-linked in the chat surface.
Click ↗	Jumps to the asset the thread produced (recipe / dashboard / agent).
Drag right edge	Resizes the dock from 280 to 600 px. Width persists per user.
Header ↗ full screen	Opens the session at /cobuild?session=N&thread=M for a focused authoring view.

A 30-second background poll keeps the badge and per-row indicators current — you'll see an approval-pending state without opening the dock first.

Parallel workstreams

The spawn_workstreams tool lets one user prompt fan out into multiple threads. The planner can decide to spawn three workstreams mid-loop (e.g. dataset, dashboard, governance review) and run them concurrently. Each spawned thread has its own agent loop with its own toolset; the parent thread's LiveTrace surfaces the fan-out so users see what's running.

Governance and promotion lifecycle

Cobuild sessions are the primary surface for the Governance and promote-to-live lifecycle introduced in v0.0.62:

1. The planner builds a recipe / dashboard / agent. New assets default to is_test=true — visible only to the creator + admins.
2. The user (or the planner itself) calls run_governance_review. The verdict — pass, warn, or fail — surfaces in a PlanCard along with the contributing checks.
3. If the verdict is pass, the planner can call promote_to_live, which flips is_test=false and makes the asset visible to everyone with the matching read permission.
4. If the verdict is warn or fail, the planner explains which checks didn't pass and (optionally) proposes a fix.

This is Honeyframe's draft → review → live lifecycle. Assets built in Cobuild stay in test mode until governance passes and the user explicitly promotes.

API surface

Endpoint	Description
POST /api/cobuild/sessions	Create a session.
GET /api/cobuild/sessions	List sessions in the project. Includes awaiting_approval_count per session.
GET /api/cobuild/sessions/{id}	Full session with threads.
DELETE /api/cobuild/sessions/{id}	Delete a session and its threads.
POST /api/cobuild/threads	Spawn a new thread within a session.
POST /api/cobuild/threads/{id}/run	Submit a user message and run the planner loop.
POST /api/cobuild/threads/{id}/resume	Resume a paused thread after an approval decision.
GET /api/cobuild/threads/{id}	Fetch thread state with all messages.

Permissions

Cobuild gates on the same per-resource permission strings as the rest of the platform — recipe.edit, dashboard.edit, agent.edit for the corresponding mutation tools. The session surface itself is open to any authenticated project member. See Permissions reference.

When to use Cobuild vs. the dashboard chat panel

Both surfaces share the same agent runtime under the hood. The split is about scope:

• Dashboard chat panel (in Build mode on a dashboard) — single-dashboard authoring. Add cards, swap card types, set filters, rebalance layout. Lives inside one dashboard's edit session.
• Cobuild — cross-asset authoring. Discover datasets, build a recipe, then a dashboard, then run governance, then promote. Spans multiple assets in one conversation.

When the work is "make this dashboard better", use the panel. When the work is "build me the X workflow from scratch", open Cobuild.