Agent teams
A team brings Claude Code, Codex, Antigravity and GitHub Copilot agents together in an org chart, each with a role. When a seat finishes its part, the work moves along the arrows to the next one, until the end of the round, when you approve what goes into the code. Each seat can be yours or someone else’s, on their machine.
What it is and where
The Teams button in the top bar (in the group with Command, Report and Board) opens Teams: your agent team as an org chart. Each seat has a role and shows, live, the session in it (working, your turn, idle). Tap a role in the left column to create a seat (with a seat selected, the new one goes below it, already connected). Drag seats to arrange them, or use Arrange; to connect, drag from the ○ under a seat to the next one. Tap an arrow to remove it (the × in the middle, or Delete).
The screen follows the team’s path:
- At the top of the board, what’s missing: Build → Prepare → Run, and the first thing left to do (choose the team folder, an invite waiting, an invitee’s folder not shared yet, a machine without the role’s agent…). Tapping it takes you there; See all shows the list. An orange dot marks the seat with something pending on the board, and starts marks where the request comes in.
- On the left, the roles to add seats. Someone invited sees Your seats there, with what to do on each.
- On the right, the selected seat: on top, Now (the session and the main action: Open the session, See the conversation or Open a session with the role); below, Agent, Where it works and Who takes care; the rest under More options. With nothing selected, the Round log. With an invite waiting for you, only the acceptance shows.
- Below the board, the team’s request, like a session’s message box.
- ⚙ Team, at the top: name, building, team folder, code through git, Empty the seats, Copy to another project… and delete.
- ? (Help), at the top, next to close: a short answer (with a video) for each question (how a round works, building, people on another machine, running again, the code and git, what each thing is for), Show me on screen and the screen tour. Each heading has a ? that explains that part.
Live: the seat whose agent is working pulses, with a stripe running along its edge and what it’s doing now (the tool in progress, like Edit index.html); the arrow the work just went through gets a running dashed line. With “Reduce motion” on in the system, only the colors change.
The left and right panels collapse with ‹ / › and change width by dragging their edge.
Chats: at the top of the board, Chats shows each seat’s chat side by side, live, in org chart order.
Deliveries: next to Chats, what each seat saved in its folder, with a preview, in org chart order. Approve marks the file; Redo sends your reason to the seat that made it (it goes in when the seat is free). The person running the team and the seat’s owner can mark.
Building the team
Get started: New team asks What do you want the agents to do?. Tell it your way, typing or speaking (or tap an example), and tap Build: an agent on one of your machines puts together The proposal, with the project (a new folder), the team (the roles and handoffs), Run on its own (when the request talks about something that repeats), the Connectors that help, the Project guide (questions about what the agents need to know, to answer right there or later), the Deliveries and what goes through the Outbox. Adjust by tapping the pieces or with Adjust in words ("remove the reviewer", "run at 7"). Nothing is created until Create: then Fleetly creates the folder, the missing roles, the team with its schedule and a guia-do-projeto.md help file with your answers (you fill in the blanks later). Each spot in the team shows the agent and the model (Opus, Fable…): the one of the session in it or, when empty, the one the role asks for. Each connector in the proposal shows whether it is already connected in your Claude account (✓ connected in your Claude account) or takes you to claude.ai to connect it. Claude roles come with those connectors: they read without asking for approval, and anything that writes waits for you in the Outbox. Start empty and Start from a recipe take you to the usual wizard.
The usual wizard:
New team opens a four-step wizard: Template (a ready team or a blank one), Code (the team folder, chosen with Use this folder or created right there with New folder here…, and team code through git, if the folder has a remote repository), People (on each seat, you or an invite to someone in the building, and the agent) and Review, with an optional First request. On create, the invites go out and the org chart opens with everything set up; the first request waits on the board and, with no invites, the round can start right away (Start the round as soon as it is created).
Team templates: in New team, start from a ready-made template, with the names and prompts of every role. Development: One builds, the other reviews (backend in Claude, reviewer in Codex), Full feature (PO, backend, frontend and reviewer), Bug duty (triage in Antigravity, frontend or backend, tests in Codex) and New screen (PO, frontend, end-to-end QA and interface reviewer). And one per area: Blog post from scratch, Prospecting by email, Ticket triage, Weekly finance report and Document a process. Roles you don’t have yet are added to your library; if you already have a role with the same name, the team uses yours. Other teams are in From a recipe: big change (with an architect and technical docs), database migration, security review, email sequence, SEO, sales proposal, help article, cash flow and open a job, among others. In Edit roles → Start from an example, there are also standalone development roles, such as Architect, Database, End-to-end QA, Interface reviewer and Technical docs.
To put an existing session on a team, use Add to a team… in its message box’s +: Teams opens with the session, and you tap a seat, a role (to create the seat with it) or New team.
- Open a session with the role: opens the new session with the role already set (and the team’s folder, if chosen).
- Put in an existing session: the seat shows that session. It comes in without the role prompt, which only applies to a session that starts from the role.
- Open the session takes you to it in the dashboard; Vacate empties the seat.
Each seat’s agent: the role suggests an agent, but each seat chooses which one it runs in, under Agent (on the selected seat, or in the People step of New team). The same role can run in Codex on one team and in Antigravity on another, without changing the role; with another agent, its default model applies. If the template asks for an agent the seat’s machine doesn’t have (the Reviewer in Codex, on a Mac with only Claude), the seat already comes with one it has; on an existing team, the top of the board tells you, with Use Claude in this seat. Changing a seat’s agent takes the previous session off it, and the next round opens a new one.
A team can mix agents: the frontend specialist in Claude, the reviewer in Codex and the tests in Antigravity, for example, on different machines. In Antigravity and Copilot, the team runs in Auto mode: commands that change something ask for approval, so turn on Accept automatically or forbid commands in the role so the team doesn’t stop and wait (Antigravity, GitHub Copilot).
Without the team folder (in ⚙ Team, or in New team’s Code step), empty seats have nowhere to open their sessions, and Start stays off: the top of the board tells you.
Arrows with conditions: tap an arrow to choose when it applies: whenever the seat finishes, if APPROVED, if REJECTED (back to whoever built it) or another word (for example, UI or API, so triage picks the path). The seat is told which words to use at the end of its answer. Each arrow has a limit of times per round (3 unless you change it): past that, the team stops and calls you. Finishing with DONE or APPROVED with no arrow to follow is the end of the path.
Arrows with approval: on the arrow, under Who approves before it moves on, select yourself or people in the team’s building (other people, on Team and Enterprise). With more than one, choose One approval is enough or Everyone must approve. When the seat finishes, the work stops at the arrow (the next seat shows waiting for approval) and the approvers get what was delivered on their phone and in Teams, to Approve (it moves on to the next seat), Ask for changes (it goes back, with what you wrote and what was delivered, to the seat chosen in If changes are requested, it goes back to: whoever delivered it, unless you change it, or an earlier seat; from there the work goes through the next seats again, counting toward each arrow’s loops, until it stops at the same arrow. On the board, the way back is dashed, labeled changes) or Decline (the round stops). In the phone notification, Decline with a text counts as asking for changes. Use it for a PO who analyzes the idea before anyone builds it, a marketing text someone approves before it goes out, or a design that needs the brand owner’s OK. Whoever approves an arrow sees the team, even without looking after a seat.
Reuse a team: in ⚙ Team, Copy to another project… creates the same team (seats, arrows and each seat’s part, without the sessions) in an existing project or a new folder, and asks where each seat that had its own folder goes. Empty the seats takes the sessions out of the current team, so the next round starts fresh. A team’s session shows the team name in its header; tapping it opens the team, and closing a session opened from the team takes you back to it. See in the Office shows rooms by team.
Team roles: the roles New team creates belong only to that team (under This team, in the list on the left); the Library keeps the ones you reuse in other teams. To take a team role to the library, open it in Edit roles… and tick Keep in the library. There you also see the library roles used by only one team, with Move to the team. Deleting a team deletes the roles that were only its own.
The round
Put the team to work: write what the team should do below the board and tap Start. The request goes to the first seat (the one no unconditional arrow points to: a REJECTED loop back doesn’t count); an empty seat opens a session with the role, in the team’s folder. When a seat finishes its part with a DONE: line (or PRONTO:, APPROVED/REJECTED), what it delivered moves along the arrows, with the team’s request, to the next seat’s session, even if one is Claude and the other Codex, and on different machines. In each seat, under More options, you can write this seat’s part in this team (for example, “only the scoreboard API”).
Several sending to one: a seat that receives from several (the reviewer receiving from frontend and backend) waits for everyone who will still deliver in the round and gets it all together. The round only ends when no one has the work anymore.
Unstick a seat: each seat shows where it stands in the round (has the work, delivered, waiting for approval or stopped without DONE). If the session finished without the line, or is stuck as working, pick the seat and use Hand off (or As APPROVED, As REJECTED… when its arrows have conditions): the last answer moves along the arrows right away. A session takes one seat only. What runs in a seat is the role’s agent, and the card shows which (Claude or Codex); to switch, change the role. When putting in an existing session, the list only shows the role’s agent’s sessions. A seat holding a session from another agent (from before this rule) shows as wrong session, with Replace for the right one.
Run again: when the round ends, Round finished shows up below the board. To tweak something or ask for the next feature, write there and tap Start: the same sessions get the request and remember what they did. Start from scratch takes the sessions off the seats, and the next round opens new sessions, without the memory of the earlier ones.
The Round log, on the right (with no seat selected), shows each step: where it started, each handoff and the end. Stop, below the board, ends the round. If a seat’s agent didn’t even run because it isn’t logged in on its machine, the log says so and what to do.
While the team works: the board is view-only. The role list, the arrows and each spot’s options come back when the round ends, or when you tap Stop. Before starting, the top of the board says what is missing, including a connector the roles use (Instagram, Gmail…) that isn’t connected in your Claude account, with Connect on claude.ai. An arrow with a condition takes the place of the arrows without one: a REJECTED goes back to whoever did it and doesn’t move forward.
Brakes: an answer without the DONE: line doesn’t move on; the team lets you know so you can check the session. At most 12 handoffs per round. A failed delivery is retried before you’re told. The team acts with your access: it only sends to sessions and folders you can use.
Run the project and publish
On a phone, the board fills the screen and both panels slide up from the bottom, one at a time: Roles, top left, to add seats to the team, and Round, top right, with the log, the approvals and publishing. Tapping a seat or an arrow opens its details; × closes them.
With nothing selected on the board, the right panel shows Run and see, with each seat’s session and Run the project on each, at any time. When the team finishes, the phone notification opens the team, and the same card becomes Review and publish: Run the project asks the session to start the app; while it works the card says so, and once the app is up the address shows (and the preview, if it’s on). In a Codex seat, a short Codex session in the same folder runs it, with internet turned on in its sandbox (without it, the app can’t even open its port); in an Antigravity seat, a short session of the machine’s Claude (in Antigravity’s Auto, every command to install and start the app would ask for approval); in Claude, the request goes to the session itself. In every case, the app starts detached and keeps running after the answer. Next to the address, Stop ends the app (only what runs on that port, inside the session’s folder). And the apps Fleetly starts go into Apps Fleetly started: each one stops on its own after 2 hours (+2 h extends it), even with the dashboard closed, and the top bar shows N apps running while there are any. Run the project also shows inside the selected seat; to deselect, tap an empty spot on the board, Close or Esc.
Publish at the end of the round: the end notification reaches whoever created the team with Approve and Deny, like permission requests (on iPhone and Android, with Face ID or fingerprint). Approving publishes from the team folder’s machine: with team code through git, it opens the pull request from the team branch to the main branch with the GitHub CLI (or updates the one already open), and merging stays with you, on GitHub; without git, it commits and pushes the branch the team folder is on. The Review and publish card has the same buttons (Open the pull request or Publish, and Not now), and the result goes into the log and arrives in a second notification. Only whoever created the team can publish.
The team’s code
Team code through git: in ⚙ Team, with a guide in the ? next to it. When on, every seat works on the team branch (by default, time/<name>), each on its own machine: before a seat starts, Fleetly brings in what the others sent; when it finishes, Fleetly commits what it changed and pushes it to the team branch, with the access of whoever takes care of the seat. If two seats change the same lines, nothing is undone: the seat gets a conflict notice to resolve. The team folder needs a remote repository (GitHub, GitLab…); if it doesn’t have one yet, the notice itself offers Create on GitHub (private, through the GitHub CLI signed in on the folder’s machine, which may be another one) or I already have a repository, to paste the address and push. At the end, the pull request and the merge are up to you.
In Team branch, pick one the repository already has (the main one is marked) or a new one; if you don’t pick, a new one is used, time/<team name>. Picking the main branch (like main), the team pushes straight to it, with no pull request: fine when only you work on the project.
The team works in its own copy of the folder, next to yours (for example, my-project--team-name, a *git worktree* of the same repository): your folder stays on the branch you are on, and whatever you or other sessions have half done in it never ends up in a team commit. Dependencies (like node_modules) don’t come along: the agent installs them in the copy if it needs to run something.
Approve everything: in ⚙ Team, Approve everything in this team turns on the chat’s Accept automatically in each seat’s session: commands and edits go through without asking. What the role forbids (like push) and the building’s policy still apply. Each seat can change it in its panel, under Approvals: Like the team, Always ask or Approve everything. Without any of this, a seat’s approval request reaches the dashboard and your phone, like the others.
Plan first: tick Plan first, below the request, and the first seat writes the round’s plan in Plan only mode, without changing anything: what changes and in which files, what each seat does and in what order, the risks and how to test. The round waits for you in Plan to approve, in the round panel (the phone notification arrives too): Approve plan starts the team, with the plan in each seat’s message; Ask for changes sends the plan back to the first seat with what you write; Decline stops the round. The option is saved with the team.
Run on its own: tick Run on its own, below the request, pick the days and time and write the request for each time (for example, "today’s post, following the calendar"). The team starts the round on its own, in your time zone, even with the panel closed. If the previous round is still running at that time, or an invite hasn’t been accepted, it skips that day, notifies your phone and shows the reason right there. If it’s offline at that time, it still starts if it comes back within 2 hours.
The main branch in the flow: before a seat that edits files starts, Fleetly also merges the main branch into the team branch. Without conflicts, it just goes on. With conflicts, the merge stays open in the team’s copy and resolving it becomes the first part of that seat’s request; nothing with conflict markers (<<<<<<<) gets sent. A read-only seat doesn’t merge. The report says whether merging with the main branch conflicts, and Ask the team to resolve it sends the team to handle it in a short round. Seats don’t ask you to grant permissions: what the role can’t do becomes PENDING, with who on the team does it. If a role’s instructions ask it to write files and it isn’t allowed to edit, the role editor warns you right away, and the team warns you before starting. If a seat still asks you for a permission or a command, the report shows it as a problem, with its own words. In a team where no seat edits, the report tells you to resolve the conflict in the pull request.
Publish all the way: in ⚙ Team → Publish, turn on After the pull request, merge it into the main branch and, if you want, write the Deploy command (for example ./scripts/deploy.sh). At the end of the round, Publish opens the pull request, merges it and runs the command in the team folder, on that machine, one step after the other, showing each result and the command output; the phone notification arrives when it is done. With a conflict or a failing GitHub check, the merge is not forced: the report tells you what to do. The building policy applies to the command as to an agent command, and nothing runs without your tap. If the project deploys on its own after the merge (GitHub Actions, Vercel), leave the command empty.
Help for the agents: in ⚙ Team → Help for the agents, write or upload files (.md, .txt, Word or PDF; Word and PDF become text, so every agent reads them the same way) that apply to every seat in the team: the project architecture, how to test, the house rules. Before each handoff, the team puts the files in the seat’s folder, in .fleetly-ajuda (outside git: they never go into a commit), and tells the agent to read what helps. What applies to a single role goes in its skills, in Edit roles. Use in another project brings the help files along.
Talking straight to a seat: you can, but commit, push, merging the main branch and publishing belong to the team. If you write something like that in a seat’s session, the message box warns you and offers Ask the team. Whatever changes in the team’s copy outside a round goes into the branch in the next round, and the report flags it. If the collector on one of the team’s machines is on an old version, Teams warns you before starting: quit and reopen the Fleetly app there.
Round report: when a round ends (everyone finished, it stopped, or you stopped it), the report opens on its own and stays in the card under the board and in the Results tab. At the top, For you: an agent on your machine sums up in plain words what is done, What to do now (the steps, in order, up to publishing) and what is Not done or tested yet. Right below, Before publishing lists what needs a look (the number on the badge is the same) and Good to know, what one seat left for the next; the rest goes under Technical details. The card under the board can be minimized (⌄) into a single line with the verdict. Quick fix: after a round, in Who does it (under the request and in Ask the team for a change), pick Only one seat: the request goes straight to it, without the plan or the other seats, and the round ends there, with the report. Check Then a review to have the reviewing seat check it; if it rejects, it goes back once to whoever did it. Fleetly suggests the seat that made the last commit. It keeps two sources apart: from git (this round’s commits, the files by group with lines added and removed, and anything left uncommitted in the team’s copy) and according to the agent (each seat’s final line and the TESTES, PENDENTE and COMO VER lines the team asks for at the end of each part). What to check crosses the two: a round with no commit, a test the agent didn’t run or said failed, pending work, a database migration, a CLAUDE.md change, an .env file, dependencies and deleted files. The verdict only says Ready for you to review when none of that shows up. In See it working, the preview opens on the screen the agent pointed to; in Next steps, open the pull request, see the changes in the repository or ask the team for a change. The phone notification carries the verdict and the numbers.
Following a round: while the team works, the Teams button in the top bar gets a dot (blue while working, amber when it needs you), and its tooltip says who has the work and for how long; on very wide screens it is also written next to it. The tab title gets a ● with the team name. Tap it to open the team. On the board, each seat with the work shows how long it has had it and how long it usually takes (from the team’s past rounds; none on the first), and the line under the board says how long the round has been running, who has the work and who comes next. Tap what a seat is doing to see its latest actions.
Results: the tab next to Code, with everything the team did across rounds: how many deliveries, how many approved and rejected, commits, lines added and removed, how long each seat worked, a list of what was done (the first line of each delivery) and the rounds. Only seats and agents, never people. It counts from 11/07/2026.
Choosing the team: the button with the team name, at the top, opens a box with search (name, folder, building or who created it). Running teams come first, then recent ones and the rest by building; arrow keys and Enter also pick. The last team you opened comes back when you reopen Teams.
The Code tab, next to Org chart and Conversations, gathers the team’s code: the team branch, with See on GitHub, and, for each seat, the files it changed and hasn’t pushed yet and who is in each one right now. Tapping a file opens it right there, alongside, without leaving the team: on your seat, in the editor, to edit and save (All files shows the tree), and Send to the team commits and pushes what changed in your seat to the team branch, with an optional message; everyone else on the team gets a notice on their phone and in the log, and seats that are idle with nothing pending get the code right away (an open editor updates on its own); seats with unsent changes or a working agent get it through Get new code or when the seat starts. The bar at the bottom only shows up when there’s something to do (changes to send or new code to get); while the seat’s agent is working, the buttons wait. With a file open, the seat list closes with ‹ and changes width by dragging the divider; on a teammate’s, view only, with File and Changes (the diff before the push). Open the session takes you to the seat’s session.
See a teammate editing: when a teammate has a team file open in Fleetly’s editor, the Code tab and the editor show where they are ("Beto, line 42"), with the line marked in the role’s color, and what they type, live, before saving; Follow keeps up with their line. Showing is each person’s choice: the editor asks the first time, and Visible to the team or Hidden from the team, at the top of the editor, changes it whenever you like. Only people on the same team see it, only while the file is open, and nothing is stored. It works in Fleetly’s editor; someone editing in another editor shows up through what changed in git.
Who is changing the file: in a team session’s editor, a bar tells you when another seat changed the same file and hasn’t pushed yet (or is changing it right now), and See what it changed shows the diff in its folder, view only, before the push.
People on other machines
On different machines: in each seat, Where it works picks the folder, including on another machine (Claude on the server and Codex on the Mac, for example). The handoff carries the text of what was delivered; one machine’s files don’t show up on the other, so the receiver is told, and code crosses over through git (push on one side, pull on the other).
A team with people from your building (Team and Enterprise): in ⚙ Team, under Team’s building, pick the building. On each seat, Who takes care → Invite someone from the building… calls a person. They get it in the panel (the Teams button shows how many invites are waiting), on their phone and by email, and Accept only asks for their machine and folder (with team code through git, Fleetly clones the team repository into it; if it’s a private GitHub repository the person can’t access yet, Fleetly requests access on its own: with the GitHub CLI signed in on both machines, their account becomes a collaborator and the clone goes on): no open session needed, the seat’s agent opens there, with their account, when the work arrives. Whoever takes care of a seat sees the team and follows the round; whoever created the team (and the building owners) changes it and runs the rounds, which only start once every invite is accepted.
Accepting a team invite: the invite arrives in the panel (the Teams button shows how many), on your phone and by email. On the seat, a card with three steps, and whatever doesn’t apply is hidden:
- Where the agent works: pick the machine and the folder (Use this folder, or New folder here…). No open session needed: the seat’s session opens there when the work arrives.
- The team’s code (with team code through git on): Bring the team’s code into this folder clones the team repository into it. If it’s a private GitHub repository your account can’t access yet, Fleetly requests access on its own (it needs the GitHub CLI signed in on both machines).
- Show to the team (only when the machine is in another building, like your personal one): Share this folder with … lets the team’s building see this seat’s sessions, and only this folder’s. The rest of the machine stays yours only.
- Accept. It can take a minute while the code arrives.
Sharing a machine with another building: the machine stays in its own building (seeing everything it did), and the team’s building sees only the shared folders: the sessions show up in the Office, the team, See the conversation and the Code tab, and people there can at most operate on them (not revoke or change the machine). The machine owner’s usage, plan and cost don’t show up. It’s done from anywhere, in the panel or on the phone, without being at the machine. To stop: Settings → Buildings → Machines, tap the machine and then Stop sharing. The team building’s rules (policy) don’t apply on the shared machine; when they need to, connect the machine for real to the building, from its Fleetly icon, with Add another building…. In an Enterprise building that locked its machines, sharing isn’t allowed.
Codex on Windows: Fleetly turns on Codex’s Windows sandbox (the one that doesn’t need administrator rights). Without it, Codex refused every command, even git status. With it, a role that doesn’t edit (like the Reviewer) and the Ask for approval and Plan only modes read and run commands without being able to write, as on Mac and Linux. Needs app 0.1.21 or newer on the Windows machine.
In the Office
In the Office, choose Rooms by team (at the bottom, next to Rooms by project and Rooms by tag): each team becomes a room with its seats’ sessions, and the rest goes to “Not on a team”. At each handoff, a folder walks from the desk that delivered to the one receiving it, leaving a tape on the floor that turns green when it arrives (with “reduce motion” on in the system, it doesn’t move). The whiteboard on the room’s wall opens Teams.
Didn’t find what you were looking for? Write to admin@fleetly.tools.