Multi-Agent Teams: Planning, Execution, and Cross-Review

In this tutorial, you will assemble a multi-agent specialized engineering team in Zenborg. You will use a reasoning-focused model as the Manager Agent for planning and synthesis, a fast Worker Agent for code implementation in an isolated Git worktree, and a second independent agent for cross-agent code review.

What You Need Before You Start

Zenborg installed and running.
Authenticated installations of:
- Manager Agent (e.g., Claude Code or Google Antigravity)
- Worker Agent (e.g., Browser Gemini or Gemini CLI)
- Independent Cross-Reviewer (e.g., another connected CLI assistant)
A working Git project with existing tests.

Ordered Screens Overview

During this tutorial, you will navigate through four screens in sequence:

Screen 1: Multi-Agent Team Setup — Assigning roles to distinct models.
Screen 2: Cross-Review & Failover Panel — Enabling independent critique.
Screen 3: Execution & Review Dashboard — Watching multi-stage execution.
Screen 4: Fix Round and Consensus View — Inspecting resolved findings.

Step-by-Step Instructions

Step 1: Define the Engineering Task

Open the Loops tab in Zenborg.

In the Task Scope input field, enter a task that touches multiple files:

Add rate limiting middleware to all POST endpoints using a token-bucket algorithm with Redis backend.

Step 2: Assign Complementary Agent Roles

In the Manager Agent dropdown, choose antigravity (or claude). The Manager Agent drafts the plan, synthesizes worker feedback, and conducts the primary code review.
In the Worker Agent dropdown, choose browser with gemini (or gemini CLI). The Worker Agent conducts the two parallel plan reviews, generates the code in the worktree, and implements any needed fixes.
In the Smart worker (optional) dropdown, choose another CLI agent (such as hermes). If the Worker encounters provider throttling, CAPTCHAs, or fails twice consecutively, the Smart Worker temporarily assumes the task, then returns execution to the Worker.

Step 3: Enable Independent Cross-Agent Code Review

Scroll down to the review options.
Check the box labeled: "Cross-Agent Code Review (Independent Second Opinion)"
In the Cross-Reviewer Agent dropdown, select an independent connected assistant.
Ensure Max Correction Rounds is set to 4.

Step 4: Launch the Multi-Agent Loop

Click the button labeled “Start Orchestration Loop”.
Zenborg branches off an isolated Git worktree for the loop.

Step 5: Observe Cross-Agent Critique and Automated Fixes

The Manager Agent synthesizes the initial plan based on worker plan reviews.
The Worker Agent checks out the worktree and implements the token-bucket middleware.
The Manager Agent inspects the resulting code diff and test outputs.
Next, the cross_review stage executes: an independent second-opinion agent analyzes the implementation.
If the cross-reviewer identifies an unhandled Redis disconnect edge case, Zenborg triggers a fix_1 stage.
The Worker Agent corrects the issue in the worktree and runs tests until consensus is reached.

Step 6: Verify and Integrate

Click on the completed loop to expand the stage details.
Read the cross-review report and the corresponding fix diff.
Click Merge to Main Branch to integrate the verified code into your codebase.

[Visual]	[Spoken]
00:00 - 00:15 Title screen: “Multi-Agent Engineering Teams in Zenborg”. Pan down the Zenborg Loops builder.	“When a single AI model writes and tests its own code, it often overlooks its own mistakes. In this video, we’ll build a multi-agent team where complementary models cross-check each other.”
00:15 - 00:32 Cursor selects Antigravity or Claude as Manager, Gemini as Worker, and sets the task scope.	“We start by assigning roles. A reasoning-focused model serves as our Manager Agent to draft and synthesize the plan. For execution speed, we assign Gemini as our Worker.”
00:32 - 00:52 Checking `"Cross-Agent Code Review (Independent Second Opinion)"` and selecting an independent reviewer in `#cross-reviewer-agent-input`.	“Now we enable the key safety feature: Cross-Agent Code Review. We select an independent agent to act as an auditor. If the worker misses an edge case, the reviewer catches it.”
00:52 - 01:15 Clicking `"Start Orchestration Loop"`. Stages execute: `execution` finishes, `cross_review` flags a potential Redis connection leak, and `fix_1` runs.	“We start the loop. In an isolated Git worktree, the worker writes the code. Then our cross-reviewer steps in. It spots an unhandled edge case, and Zenborg immediately dispatches an automated fix round.”
01:15 - 01:35 The fix round finishes green. User reviews the combined diff and clicks merge.	“The fix is applied, all tests pass, and both models agree on the solution. You get battle-tested code reviewed by multiple frontier models before it ever reaches your main branch.”

| **01:15 - 01:35**
The fix round finishes green. User reviews the combined diff and clicks merge. | "The fix is applied, all tests pass, and both models agree on the solution. You get battle-tested code reviewed by multiple frontier models before it ever reaches your main branch." |