Black Friday33% off all plans See plans Enter it at checkout

AI Agent Boss and Agent Teams

An AI Agent Boss is an agent that runs other agents. You give it a job. It splits the job into tasks, puts the plan on the board, and once you approve, starts a worker terminal for each task. It answers the workers’ questions from your brief, collects what they made, ranks the versions and tells you which one it recommends.

Each worker is an ordinary terminal tab, so you can watch it, answer it or stop it at any time. The Terminal Manager shows the Boss and its workers together as a team.

Agents are free on every plan. The Boss and its workers run on your own agent subscriptions, and every worker is a full agent session: four workers cost about four times as much as one.

When a team helps

A team pays off when the job splits into parts that don’t depend on each other and don’t change the same files:

  • three versions of a hero section, each in its own direction;
  • one page per worker for a small site;
  • a research part and a build part that meet only at the end.

For a small job, or one where every step needs the step before it, a team only adds cost and waiting. The Boss does a job like that itself.

Start a Boss

  • On the Canvas, click GLAI ▸ Run AI Agent Boss and pick the agent that leads: Claude Code, Codex, Antigravity, OpenCode, Cursor or xAI.
  • Or click + on the terminal tabs and choose Run AI Agent Boss. This works in the GLEA panel of the Video Editor too.
  • Or click Run with agent team on a pipeline. A Claude Code Boss gets the pipeline as its job: steps with no arrow between them run at the same time, each in its own worker terminal. See Pipelines.

On a GreenLight Dash Server, the Boss and its workers can be Claude Code or Codex.

The Boss opens in a new tab named AI Agent Boss, with a Boss icon. It reads its instructions, says it’s ready and asks for the job. Describe the job in plain words, as you would to a person: what you want, the brief, and anything it must not touch.

How a job runs

  1. The plan. When the job is board work, the Boss puts its plan on the board as a pipeline: a Starter with your brief and one step per task. Each step is named with a letter, the task and the agent, for example “A · Minimal · Claude”. Arrows between steps mean “wait for”; steps with no arrow between them run at the same time.
  2. Your approval. The Boss asks in its terminal whether to start the workers. Change the plan on the board first if you want, then answer. If you said “just go” in the job, it starts straight away.
  3. The workers. Each task gets a worker terminal: a new tab with the task’s letter. The step on the board shows the worker’s status, and turns orange (Needs you) while the worker waits on someone.
  4. Questions. When a worker asks something, the Boss answers from your brief and your words. It stops for you only when it must: a choice of taste that the brief doesn’t settle, money it wasn’t asked to spend, publishing or sending anything off your computer, deleting your own work, or a login or key only you have. It asks in one short line in its terminal.
  5. Results. Each worker ends with three sentences: what it did, the files it changed and anything left open. The Boss puts that summary in the worker’s step.
  6. The report. For versions of the same thing, the Boss ranks them with Compare (below). Then it closes the workers and tells you what was done, what it recommends and why, and the defaults it picked on the way.

Everything the job makes goes into the board’s folder. The Boss never deletes, hides or moves the versions it didn’t pick; you may prefer one it ranked lower.

A Boss keeps going until the job is done, so you can leave it running. A Claude Code Boss uses its /loop command for that.

The app wakes the Boss

When the Boss’s turn has ended and a worker finishes, needs someone, stops on an error, hits its time limit or is closed, the app types one line into the Boss’s terminal, like this:

[GreenLight] Worker "A · Minimal" finished. Run: gl-term wait --any

That line comes from the app, not from you, and the Boss carries on from it. The app never types it while the Boss works, while it shows a permission prompt, or within a minute of you typing in the Boss’s terminal.

Limits

WhatLimit
Workers per Boss6 at a time.
Agents the app starts by itself8 in total: the workers of every Boss plus the agents of Variants. The terminals you start yourself don’t count.
LevelsOne. A worker can’t start workers of its own.
A worker’s time limit30 minutes unless the Boss sets another, up to 4 hours. At the limit the app stops the worker’s turn and tells the Boss.
The BossNo time limit.
Permission promptsNever answered by a Boss. A worker that shows a permission prompt or asks whether to trust a folder waits for you, marked Needs you.

An agent that isn’t installed on your computer is refused. The Boss picks another agent or tells you; the GLAI menu installs it.

Teams in the Terminal Manager

The Terminal Manager keeps a Boss and its workers together:

  • The Boss’s row has a Boss label and a summary such as “3 workers · 2 done · 1 needs you”.
  • Its workers sit right under it, each with its letter. The whole team stays in the group of its most urgent member, so a worker that needs you brings the team to Needs you.
  • When a Boss types into a terminal, that row shows what it sent and when, for example “AI Agent Boss sent “Brand green, as in the brief.” · 2m”.
  • On the Wall, each team has its own group, such as “AI Agent Boss · team of 3”.
  • A worker’s finished turn makes no notice: its Boss collects it.

Your other terminals

A Boss controls its own workers. Your other terminals stay yours unless you let it in.

Hand it one terminal. In the Terminal Manager, hover the terminal’s row and click the hand, Hand to ‹Boss›. The row then says “handed to ‹Boss›”. Click the arrow, Take back from ‹Boss›, to take it back.

Let it use all of them. Turn on App settings ▸ AI Agents ▸ Let a Boss control my other terminals (off by default). A Boss can then read, type into and stop your other terminals, with these limits:

  • It never types into a terminal you used in the last 5 minutes.
  • It never touches another Boss’s workers.
  • It closes only idle terminals.
  • What it sends shows on that terminal’s row in the Terminal Manager.

With the setting off, a Boss can only list your terminals.

Compare versions

When the workers made versions of the same thing, the Boss ranks them with Compare. Compare takes 2 to 6 versions: three hero sections, four logos, two cuts of a clip, three headlines. It makes a picture of each one itself:

  • an image card: its file;
  • a video card: three frames;
  • an HTML card: a still, or two for an animated page;
  • a note or text card: its words.

Who judges:

  • With an AI key (OpenAI, Anthropic, Google or WaveSpeed in API Keys), a model scores every version on how well it matches the brief, its visual quality and the clarity of its message. Matching the brief counts double.
  • Without a key, the agent looks at the pictures and ranks them itself. Its ranking is marked “agent’s pick”.

On the board, each card’s note strip shows its rank, for example “#1 · 8.5/10 · recommended — Hero A”. A ranking note beside the cards lists every version with its scores and one line on why. Compare also:

  • says when the top two are a close call, and leaves the pick to you;
  • flags near-copies: two versions that are the same picture with only colours or type changed;
  • never moves, hides or deletes a card. Running it again restores each card’s own title first.

Compare judges pictures. For a video it sees three frames, not the timing or the motion.

The Compare step in a pipeline

A pipeline can rank its own results. Click Add Node Frame ▸ Compare Step and wire the steps that make the versions into it. It ranks what they made against the Starter’s brief when they are done, or when you click Compare now.

The step shows the ranking with a bar per version, any near-copies (“B is a near-copy of A: the same picture, other colours.”), why the winner won, a close call (“… are close. Your pick.”), and who ranked: “Ranked by ‹model› · your key” or “The agent’s pick · no AI key”. Without an AI key, Compare now starts an agent in GLAI to do the ranking.

An agent outside the app as Boss

An agent you connected with Connect External Agent (Claude Code in your own terminal, Grok and others) can be a Boss too: on this computer with the desktop app, or on any computer with a GreenLight Dash Server. See Using the Board with Hermes, OpenClaw and External Agent systems.

  • When it hands part of a job to another agent, it starts that agent in the app, as a terminal tab on the board. You can watch, answer and stop it there, instead of it running hidden in the outside agent’s own shell.
  • In the Terminal Manager these terminals say “worker of an external agent” (on a server, the token’s name). On the Wall they form a team under the agent’s name.
  • In the desktop app it can also start an AI Agent Boss of its own on a board. That Boss plans and runs its own workers, with no time limit, and its row says “started by an external agent”. The outside agent can read, answer, steer and stop those workers too, even while their Boss sleeps.
  • It controls only the workers it started and the workers of a Boss it started. Your own terminals are never its to control, whatever Let a Boss control my other terminals says.
  • It can ask the app what waits for you: questions from your agents, permission prompts only you can answer, agents stopped on an error or done with their turn, Agent Notes your agents answered, and review and photo cards. It passes each item on to you in its own chat, and answers only its own workers’ questions.
  • On a GreenLight Dash Server the workers are the server’s Claude Code and Codex, signed in by the server’s owner, at most 6 at a time. The token needs Runs agents turned on in the server’s settings.

The commands behind it

A Boss runs its team with the gl-term command, which every terminal in the app has. The board skill teaches agents how to use it, so you never have to type it. It helps to know the main ones when you write a job for a Boss or connect an outside agent:

CommandWhat it does
gl-term new --agent codex --label B "<task>"Starts a worker with a task. The agent is claude, codex, gemini (Antigravity), opencode, cursor or grok (xAI).
gl-term waitWaits until the workers finish or one needs someone.
gl-term result AReads A’s three-sentence summary.
gl-term send A "<message>"Sends A a message. It waits until A’s turn ends; with --now it stops A’s turn and goes first.
gl-term stop ASends A Ctrl+C.
gl-term close ACloses A’s terminal.
gl-term live A onShows A’s work on the board as it happens. See Watching Agents Live.

Where to go next

Was this helpful?

0

Updated

Comments

Leave a Reply