Squads

A squad is a team of agents that do a piece of work together. You give a card or a question to the squad instead of to one agent. The squad's coordinator splits the work into steps, gives each step to the member it fits, has one member critique what another wrote, and brings the result together. A content squad with a researcher, a writer and an editor, for example, takes a blog post from research to draft to final edit.

A squad also has a shared instruction. You write it once, on the squad, and every agent in it gets it at the start of its own instruction; the coordinator reads it as the squad's working rules too. Decisions like which work starts with research, or who critiques whom, go here.

#When it's useful

A squad helps in two cases. First, when a piece of work needs more than one skill: with research, writing and critique in separate agents, the squad brings them into one job and the members see each other's output. Second, when coding agents that each cover a different repository of the same project share the same rules. A rule like "write commit messages in this format, never skip tests" goes on the squad once; each agent keeps what's specific to its own repository (which framework, which folder layout) in its own brief.

A squad does not change the agents' settings. An agent's model, temperature, which connections it can use and which tools it can call always stay the agent's own. Two agents in the same squad can run on different models.

#Giving a card to a squad

Instead of one agent, you can give a card to the whole squad. In the card's Assignee picker squads sit at the top of the list as their own group; the new card form has the same list. If you write @squad.squad-name in a comment, the card moves to that squad and starts working.

A coordinator runs a squad's card. It reads the squad's shared instruction as its briefing, splits the work into checklist items and gives each item to a member of the squad. Members mark only the items given to them, and they all see the card's outputs and working note. The coordinator can hand work only to the squad's members; it cannot call an agent from outside the squad or a temporary helper.

When the squad has two or more members that run in Orbi, work one member produces is critiqued by another: the critic lists concrete defects and the producer fixes them. A member cannot critique its own work, a cycle has at most two critique rounds, and every critique shows in the step trace. If a cycle tries to close without anyone critiquing what was produced, Orbi stops it once and asks for the critique. There is no setting for this; it is how a squad works.

On the card face, up to three members of the squad show stacked instead of a single avatar, and the rest are counted as "+N". While the card runs, the member working at that moment has a ring around its avatar. In the card drawer the assignee section lists the squad's name and members. The board filter can also show only one squad's cards.

A squad card runs more agents, so the card's agent-run cap is multiplied by the number of members in the squad.

#Reading a squad card

The Summary tab of a card the squad worked on reads top down. The card's description comes first, then Result: the squad's summary, the linked pull requests, the latest report and the checklist. Below it, Who did what, on the Trail tab, tells the steps in order, such as "Kod ajanı wrote the code" and "Reviewer reviewed the code · asked for fixes". Each step has a one-line result under it; open a row to see which device, repository and branch the member worked on, and the details. The coordinator's comments are signed with the squad's name. Open a critique step to read the critique in full.

The coordinator's question. When the coordinator cannot go on without your answer, it asks the way a single agent does. The question shows as a comment that starts with "❓" and is signed with the squad's name, the card goes back for review and the status line says Waiting for an answer. Write your answer as a comment; you do not need to mention anyone: the card goes back to the squad and is queued again. A comment that mentions another agent or a squad goes to them, and if you assigned the card to someone after the question, it stays with that person. While members that run on their own device are still working, the coordinator does not ask; it waits for them to finish first.

In the Outputs tab each output is one document, and the one changed last is at the top. When a member revises a text or the coordinator updates its report, the new version replaces the old one. The document's header shows the version number, the author and the status: Approved, Fixes requested or Latest version not reviewed. When a document's latest version was not reviewed, the Result section on the Summary tab says so too. How it got here lists the versions and the critiques between them, newest first. Open a critique to read it in full; open Changes on a version to see what it changed against the previous one, with removed text struck through in red and added text in green. That way you can tell at a glance whether a critique was applied.

Research, briefings and review notes sit closed under Working material, below the deliverables. They are what the squad used while preparing the text; they are not critiqued and are not the card's result. The coordinator decides which step writes the deliverable and which feeds it when it splits the work; the checklist shows "deliverable" or "working material" next to each item. Members see the whole plan too, so the researcher writes notes and the writer builds the text in its own way. A member's checklist item is complete only once that member has done its part; the coordinator cannot close it on the member's behalf.

#The squad's shared computer

In workspaces where agents work on their own computer (Work on the agent's own computer), a squad card can run on a computer too. When the coordinator decides the work needs one, a single computer opens for the card and the members work in the same folder at the same time. Each member works with its own model, its own instructions and its own permissions; the coordinator tells each member which files are its own, and members do not change each other's files. In the card's trace every step shows the name of the member that did it. Stopping from the status line stops the whole squad, and a comment you write on the card reaches every member that is working. While it waits for a free computer the squad counts as one. A member whose model cannot be called from the computer does its part in Orbi as before.

#Members that run on a device

When the squad has a coding agent that runs on its own device, the coordinator gives it a part of the card and names the repository to work in, picked from the member's repository list. If the member has several repositories and the card does not say which one, the coordinator does not guess; it writes the question on the card and moves the card to review.

The member's work is a run of its own on the card. A device that has that repository takes the run, the member works on its own branch, links its pull request to the card and closes its run. The card stays "in progress" meanwhile, and on the board the card says which member works on which device. A run no device has taken yet shows as "waiting for a device".

Code is reviewed only by another member that runs on its own device, because a member that runs in Orbi cannot open the branch. If the squad has a single member on a device, the review falls to you: the card comes to review with a comment asking you to look at the pull request. The Agents page warns about such a squad. When one part depends on another (the web change uses a new API endpoint), the coordinator has the API done first and then starts the web part with the API's pull request.

When the last member run ends, the coordinator wakes up on its own, reads the members' results, integrates the work and moves the card to review. No work is opened for a member whose repository no device has set up; the coordinator names the missing repository in a comment and moves the card to review. If a device has the repository but does not take the work for a long time, the run closes when it times out and that member's open items are marked as errors with the reason; the coordinator finishes the rest.

#Talking with a squad

You can talk to a squad without giving it a card. Write @squad.squad-name in a channel, or pick the squad under Squads when you start a new conversation on the Chat screen. Either way the squad's coordinator reads the request and runs only the members it needs; a member with nothing to add stays out of the conversation.

The conversation happens where you can see it. When the coordinator hands a member a piece of work, it writes that as a line with the reason: "→ @agent.researcher: scans the sources". Each member answers under its own name. With two or more members, another member critiques what was produced, and the critique stands apart with a Critique label. At the end the coordinator writes one answer for the squad that reads on its own. If no other member reviewed the work in that answer, a note under it says so. Orbi sets the note from the turn's critique record, not from what the answer says, so it shows even when the answer calls the work verified.

So the channel does not fill up, all of the squad's messages are kept in one block. Closed, it shows the question and the squad's latest answer; Show the discussion lets you read the hand-offs, the members' answers and the critique in order. While the squad works, the block says working. Answers arrive member by member in the background, so you need not wait on the page.

To keep the conversation going, press Reply to the squad on the block. The composer says the message goes to the squad, and you do not have to mention it again. An ordinary message you write to the channel without a mention does not go to the squad. In a 1:1 chat the squad is the counterpart, so every message goes to it.

The squad uses its tools in a conversation too: it can write files or records. It does not open cards in a conversation; Save as task opens the card for the conversation's work. Before it sets up something new from scratch, such as a collection or a flow, it asks for approval. The approval card sits under the message of the member that asked; once you approve, it is built exactly as shown and the outcome is written to the squad. A 1:1 squad chat is yours alone and does not appear in the workspace timeline.

If the work does not end with the conversation, use Save as task on the block. A task assigned to the squad opens in the project you choose and starts in To do. The request, the squad's last answer and a link back to the conversation go into its description. The members' work goes into the Outputs tab: the text of the member that answered last is the deliverable, that member's fixes are its versions, and the other members' notes are working material. The whole conversation, critiques included, is added as working material too. Queueing it is a separate step, because a task run spends credits. End the conversation closes it; mentioning the squad again starts a new one.

A coding agent in the squad that runs on its own device does not take part in the conversation: a code change needs a branch and a pull request, and those belong to a card. The coordinator names that part in its answer; on the task you open with Save as task, the coding agent takes it.

#Model, files and computer in a squad chat

The composer of a 1:1 squad chat is the same as in an agent chat. You attach files to a message with the paperclip button. Only files in spaces you can read can be attached, and the attached file shows under the message. If you pick a model in the model picker, the coordinator and every member of the squad run on that model for that message's turn; the members' own model settings do not apply to it. While a model is picked, the line under the composer says so, and your message shows which model was picked. Members' own models puts every member back on its own model.

In workspaces where agents work on their own computer (Work on the agent's own computer), a squad chat uses the computer too. When work comes in, such as "prepare a spreadsheet, a Word document and a PDF", the coordinator opens one computer for the chat and shares the work among the members. The members work in the same folder at the same time, and each writes under its own name when it finishes. The member that made a file attaches it to the chat. Files you attached are ready on the computer. A message you write while the members work reaches the working members at once. If a member asks a question, the question appears in the chat and the line above the composer says waiting for an answer. Your answer goes to that member on the same computer. The computer stays open while the conversation goes on and closes after 20 minutes of silence. The next message continues with the same folder. A short question is answered without opening a computer. Credits are charged with each member's own usage. A squad conversation in a channel uses the computer the same way. Everyone reads the channel, so the computer works on behalf of the channel: nobody's personal connections are used, only files every reader of the channel can see reach the computer, and credits are charged to the workspace (In a channel).

If the Orbi process running a turn stops in the middle of the work, the turn is not lost. Within a few minutes the line The turn stopped midway and started again appears in the chat, and the squad answers the same message from the start. Your message is answered once, and the folder on the computer and what the members wrote until then stay. Credits for the computer are still charged once. If the restarted turn stops midway too, the block says it could not finish; write your message again to retry.

#How the shared instruction and the agent's own instruction combine

Once an agent is in a squad, its effective instruction has two parts: the squad's shared instruction first, then the agent's own brief right below it. The agent's own text stays at the bottom, so if the two disagree on something, the agent's own sentence wins. This lets you apply the squad's general rule while still carving out an exception for one specific agent.

On the agent's detail page, right below the squad picker, the squad's shared instruction shows up read-only and collapsed — click the heading to open it. You see the other half of the agent's behavior before you write your own text.

#Creating and editing a squad

You manage squads from the Agents page; the list there is already made of squad headings. The New squad button at the top of the page starts one: you give it a name, an optional short description and the shared instruction text. To edit an existing squad, open the three-dot menu to the right of its heading and pick Edit squad.

The edit screen also shows the squad's members and each member's description. The coordinator decides who gets which work from these descriptions alone; it does not read their instructions. A member with no description gets a warning next to it: the coordinator sees it as "(no description)" and cannot tell which work it takes, so add a one-sentence description on the agent's page.

When you change the shared instruction and save, every agent in the squad is updated at the same time. If the squad has agents in it, you see a warning before saving that says how many agents will be affected. A task already running finishes with the old instruction; the next one picks up the new one.

Creating and editing squads is open to members with the Admin role only.

#Adding or removing an agent from a squad

The quickest way is the Agents page: open the three-dot menu at the right of an agent's row and pick the squad it should move to. The squad the agent is already in is marked and cannot be picked; an agent that is in a squad also gets a Remove from squad option. This takes a single click — you don't need to open the agent's detail page.

The agent's detail page also has a squad picker in the Definition tab, right above the brief. A change made there applies when you save.

When you remove an agent from a squad on the detail page, or move it to a different one, Orbi asks you: the shared instruction will no longer apply — should we copy its text to the start of the agent's own brief? If you copy it, the agent keeps behaving the same way; if you don't, the shared instruction quietly stops applying to that agent.

#Squads on the Agents page

The agent list is grouped under headings: each squad gets its own heading, with its agents listed underneath. Click a heading to collapse or expand that group; which groups you closed is remembered in your browser.

System sits at the very top, with Orbi under it. Orbi can't be put in a squad or moved to another one; it appears in the same language as the rest of the list, but it isn't a squad. Agents that aren't in any squad are grouped at the bottom under No squad.

#Squads show up while you write and while you pick

When you type @agent. in a text box and the suggestion list opens, each agent's squad appears under its name. Two agents with the same title are often told apart only by their squad. The card that opens when you hover a mention you've written shows the squad name as well.

The same line greets you wherever you pick an agent: the assignee picker on a card, the new card form, the list you start a chat from, a collection's AI field, and the palette on the left of the flow canvas. The small line under the name gives the squad first, then the title. For an agent without a squad the line carries only the title, as before. The search box in the flow palette matches squad names too, so typing "Marketing" lists that squad's agents.

#If a squad is deleted

Deleting a squad does not delete the agents in it — they just become unassigned, and the shared instruction stops applying to them from that point on. The delete confirmation tells you in advance how many agents will be affected. Cards given to that squad fall back to Orbi, which runs them on their next run.