Workflows

Viberia ships three multi-agent workflows — coordinated patterns where more than one agent works on the same problem in a structured way: PRD handoffs, Drafter-Reviewer Loops, and Councils.

Why this matters

A single agent answering a single question is the easy case. Real work isn’t like that. You want a plan written, then implemented, then reviewed. Or you want a draft critiqued and rewritten until it’s tight. Or you want three different models to argue about a hard decision before you commit.

These are different shapes of collaboration. Viberia gives each one a named workflow with a starting slash command, predictable agent roles, and visible tracking in the UI. You don’t have to script the choreography yourself — you trigger it, and the agents follow the pattern.

The three workflows cover most of what you’ll want to do beyond single-agent chat. They’re also the easiest way to learn how Viberia’s delegation actually works, because each one runs through familiar steps with visible handoffs.

The model

Workflow 1: PRD Handoff

The pattern: Planner drafts → Developer implements → Reviewer reviews.

This is the engineering loop inside the CodeForge building. You describe what you want; the Planner produces a written PRD; the Developer implements it; the Reviewer audits the result. Each step is a discrete handoff between agents inside the same building.

The relevant skills (slash commands):

Skill	Where to invoke it	What it does
`/draft-a-prd`	In the Planner’s chat	Walks the Planner through writing a PRD for whatever you describe.
`/handoff-prd-to-developer`	In the Planner’s chat (after drafting)	Sends the approved PRD to the Developer with optional model/thinking overrides.
`/implement-the-prd`	In the Developer’s chat	Implements the PRD in your project’s folder.
`/implement-the-prd-in-worktree`	In the Developer’s chat	Same, but in an isolated git worktree (useful for parallel work).
`/send-to-review`	In the Developer’s chat (after implementing)	Hands the implementation off to the Reviewer.
`/review-pr` / `/run-code-review`	In the Reviewer’s chat	Reviewer audits the change.

The handoff is real — the Planner doesn’t pretend to be the Developer; it actually messages the Developer agent and pauses. The Developer picks up the queued message, does the work, and hands off again. You can watch this play out in the AB Window as activity indicators light up on each agent in turn.

Workflow 2: Drafter-Reviewer Loop

The pattern: Drafter writes → Reviewer critiques → Drafter revises → repeat until good.

A Drafter-Reviewer Loop runs in the specialized LoopReview building. The Loop Orchestrator manages the cycle. The Drafter produces output (a doc, a design, a piece of code, anything text-shaped). The Reviewer critiques it. The Drafter incorporates the critique. The cycle continues for up to five rounds.

Skill	What it does
`/iterate`	Starts a loop on a topic you describe. The orchestrator spawns or reuses Drafter and Reviewer agents and runs round 1.

Each round produces a versioned draft. You can watch the loop in the Loop Tracker panel (toggle with Cmd+Shift+L, or open it from the bottom HudShelf). The panel shows:

Active loops with their topic.
Current round number (1 through 5).
Which agent is currently active (drafting vs. reviewing).
A button to create a new loop.

You can intervene at any round. Stop the loop when the draft is good enough; let it run to round 5 if you want maximum polish. The orchestrator stops automatically at round 5 even if it isn’t perfect — loops are not infinite.

Loops are useful for writing, design iteration, refining tricky code, naming things — anywhere you’d benefit from a second pass.

Workflow 3: Council

The pattern: Multiple models deliberate in parallel → one orchestrator synthesizes.

A Council runs in the specialized Council building. The Council Orchestrator poses a question. Three Council Members (typically running on different models — for example one Claude, one Codex, one Gemini) each independently produce a response in parallel. The Orchestrator then reads all three and writes a synthesized answer.

Skill	What it does
`/convene`	Convenes a council on a topic. Spawns or reuses the Council building, dispatches the question to all members at once, waits for replies, synthesizes.

The parallel structure is the whole point. Single-agent answers tend to converge on one perspective. Three different models often disagree in productive ways — surfacing edge cases, alternative approaches, or hidden assumptions that one model alone would miss. The Orchestrator’s synthesis is your one-stop summary, but the individual member responses are visible too if you want to drill in.

Councils are useful for decisions, architecture choices, naming, “which approach is better,” and anything where you want diverse takes before committing.

How you interact with it

Picking the right workflow

Situation	Reach for
You want a feature built end-to-end	PRD Handoff in CodeForge
You have a draft that needs polish	Drafter-Reviewer Loop via `/iterate`
You’re stuck on a decision	Council via `/convene`
You want a one-off answer to a quick question	Skip workflows; talk to a single agent
You don’t know what you want yet	Talk to the Chief of Staff in the CoS Overlay first

Starting a workflow

All three workflows start the same way: open the relevant agent’s chat, type the slash command, and answer the prompts. The agent takes it from there and routes to the others as needed.

PRD Handoff: Open the Planner in CodeForge, run /draft-a-prd.
Loop: Open the Loop Orchestrator (or any agent that supports it), run /iterate.
Council: Open the Council Orchestrator, run /convene.

If a specialized building doesn’t exist yet, the skill will create it for you. The first time you run /iterate or /convene in a project, expect a building to appear on the territory.

Watching it run

AB Window (right edge) — see which agents are currently busy with activity dots and notification badges.
Loop Tracker (Cmd+Shift+L to toggle) — see active loops, their round, and which agent is up.
Queue Drawer — see messages waiting for busy agents. Each agent has a FIFO; messages process in order.
Agent Window — open any agent mid-flow to read their chat history and current state.

Stopping or intervening

You can interrupt a workflow at any point:

Stop an agent mid-stream — the stop button in the Agent Window halts the current run.
Reorder or drop queued messages — open the Queue Drawer and drag.
Override an agent’s reply — type a follow-up; agents adapt to new context.
End a loop early — close the loop entry in the Loop Tracker.

Comparison

Workflow	Building	Agents involved	Parallel or sequential	Best for	Stopping condition
PRD Handoff	CodeForge	Planner → Developer → Reviewer	Sequential	Shipping a feature end-to-end	Reviewer approves, or you stop
Drafter-Reviewer Loop	LoopReview	Loop Orchestrator + Drafter + Reviewer	Sequential, multi-round	Polishing a draft of anything text-shaped	Round 5 reached, or you stop
Council	Council	Council Orchestrator + 3 Members	Parallel	Hard decisions, diverse takes	All members reply; orchestrator synthesizes

Buildings & Agents — the container model the workflows ride on.
Chief of Staff & Deans — who routes work to which workflow.
CodeForge — the PRD-handoff building.
Loops & Councils — the specialized buildings for the other two workflows.
Loop Tracker — the panel that shows active loops.
Skills (Slash Commands) — full reference for /draft-a-prd, /iterate, /convene, and others.
Queue Drawer — managing messages to busy agents.