Agent swarm

The task is for the team.
Conversation with an architect

A swarm is a named set of roles that is launched on the repository with one button. The architect studies the code, distributes tasks, collects reports and summarizes. Developers each work in their own working copy, reviewers do not edit anything, inspectors evaluate the result. The result goes into the repository memory - the next task will start with this knowledge.

11 roles 4 ready-made compositions worktree for developer auto-repeat · timeout 20 min
Task-swarm: role column with tasks and reports, architect chat, notes and repository memory 1 2 3 4
  • 1Column "Swarm" — roles, who is the presenter, who has their own working copy, whose report has already been sent, how many waves have passed.
  • 2Participants' reports come to the architect’s chat: you can see who reported and for what task.
  • 3Architect's summary - what has been done, what has been solved and what has been included in a separate task. From here it goes into the repository memory.
  • 4Task notes and repository memory — the context that each member of the swarm receives as the first turn.
Roles

Eleven roles of three types

Presenter distributes and brings together. Developers edit the code in their working copies. Reviewers and inspectors are read-only: policy prevents them from writing files and commands at the role level, regardless of mode and settings.

Presenter

Architect

The only one who speaks to you. Examines the repository, breaks down the work, distributes tasks, compiles reports, writes the summary into memory.

Developer

Frontend developer

Interface and client code. Your working copy on the branch <task>-frontend.

Developer

Backend developer

Server, API, data. Your own working copy, merging into the task branch after the report.

Developer

Tester

Writes and runs tests. Report - what is covered, what fell, what was not reproduced.

Developer

DevOps

Assembly, CI, environment. Everything that is not application code, but without which it will not work.

Reviewer

Analyst

Parses requirements and data, does not edit anything. His report is an updated statement.

Reviewer

Security

Looks for risks, secrets, unsafe challenges. Only a report - it cannot be edited.

Reviewer

Product

Looks at the task through the eyes of the user: what is unclear, what is superfluous, what is missing.

Inspector

Frontend inspector

Evaluates the client code of other agents along six axes. Works on the strongest model.

Inspector

Backend inspector

The same for the server code: evaluation, “file:line” findings, correction to the author.

Inspector

Quality inspector

General assessment of change beyond division into front and back. Selected by file composition.

Compositions

Four ready - and yours

In “Settings → Swarm” buttons collect the composition with one click. The “new swarm” has its own: roles, for each agent and model, leader, instructions with version history. If a role has an agent selected that is currently unavailable, the card will warn.

Full swarm

All eight basic roles. For tasks that affect the interface, the server, and the infrastructure.

ArchitectAnalystFrontendBackendSecurityProductTesterDevOps

With inspection

Development under supervision: two write, two evaluate. The inspectors' reports are returned to the architect and influence the next wave of revisions.

ArchitectFrontendBackendFrontend inspectorBackend inspector

Development

Minimum for a feature: staging, two hands, tests. Fast and cheap.

ArchitectFrontendBackendTester

Audit

Nobody edits anything: only reports. To check other people's code, accept and analyze incidents.

ArchitectAnalystSecurityProduct
Protocol

Five steps of one wave

Wave - one block of tasks and all reports on it. Swarm counts the waves; Usually two or three are enough.

  1. The architect receives a brief

    Role, composition of the swarm, your task, task notes, excerpt from the repository memory, hints from connected MCP servers.

  2. Reviews the code and distributes assignments

    Block pulse-assign - one line per role. Pulse understands role ids, Russian signatures, @role and continued on the following lines.

  3. Participants receive tasks

    Those who haven’t started yet get the first turn with a role, task and context. Before the task, the developer is given a task branch.

  4. Work and report

    Report - text after the last call of the tool; he goes to the architect. The developer's work is committed and merged back into the issue branch.

  5. The architect sums it up

    When all tasks are completed. The result is added to the repository memory - the next tasks will start with this knowledge.

# this is how an architect gives out tasks
 
```pulse-assign
frontend: Convert LoginForm to general
  components from src/ui, do not touch routing
security: Check token storage,
  do not edit anything - just report
tester: Cover the login form with tests
  and run npm test
```
# branches of one task-swarm
 
pulse/a41c ← task branch, architect's worktree
├─ pulse/a41c-frontend ← own copy, added after the report
├─ pulse/a41c-backend
└─ pulse/a41c-tester
 
# reviewers and inspectors are working
# in worktree tasks: they have nothing to pour in

What is not committed on both sides is first committed with the message “swarm: …”. Merge conflict is rolled back (merge --abort), the architect receives a list of files and a request to decide who rules. In the task and in the task preview you can see “there is a merge conflict.”

When things go wrong

Swarm is not waiting for you to fix it

fell

The participant fell

Pulse repeats his task - up to two attempts, with the note “the previous attempt was interrupted.” The session restarts itself. After the second failure, the task is marked failed and the architect receives a message.

stuck

Participant stuck

A job without a report for more than 20 minutes is interrupted and considered a failure. Then the same repeat logic works. The watchman checks tasks based on a timer, not an event—a freeze cannot go unnoticed.

conflict

Merge conflict

The merge is rolled back, the job is flagged, the architect gets the list of files and decides who is in charge. The participant threads remain - nothing is lost.

manually

We need to intervene

The ✈ button on a participant in the “Swarm” column sends him a task directly from you. The report will still be returned to the architect - he is still the only one distributing it.

On the graph

Who is working, who reported, who has an error

Role sessions diverge from the task, each with its own turns and challenges. The nodes glow according to their state, the task track colors all participants. On the right is the architect’s chat: you can see how he distributed tasks and what he responded to the reports.

  • The timeline below rewinds the swarm to any moment: what everyone knew in the second wave.
  • The cost of the swarm is visible by session and by the amount in the task chip; The task budget affects all participants.
Swarm graph: task → role sessions → turns, on the right is the architect’s chat with a block of tasks
Swarm on the task graph
Inspectors in a swarm

Review is built into the wave

Add the “Front-End Inspector” and “Back-End Inspector” to the composition – a ready-made “With Inspection” composition. The architect gives them tasks along with the others, their reports with an assessment on six axes and findings are returned to him and influence the next wave of edits. The inspector works on the strongest available model and cannot edit anything - according to the role policy.

  • Ratings are accumulated in “Settings → Quality”: over time, you can see which agent writes better in which role.
  • An adjustment from the inspector is a ready-made amendment to the participant’s instructions for the next swarm.
Settings → Swarm: composition of roles with an agent and a model for each, buttons for ready-made compositions
Settings → Swarm
When a swarm is not needed

One agent is cheaper if there is only one task

Swarm makes sense on tasks that are divided into parts: interface + server + tests, or “check someone else’s code from three sides.” One agent is enough to edit one file - a swarm will only add waves and cost. A good heuristic: if you couldn't give a task to three people, don't give it to three agents.

Restrictions today

What you should know in advance

  • Only the architect gives out assignments; you can give the task to a participant manually, but the giver is alone.
  • The last text of the turn is considered the report - if the model ends the turn by calling a tool without words, the report will be empty. The role instructions remind you of this.
  • Participants do not see each other’s transcripts - only tasks and reports through the architect. Shared memory and task notes compensate for this.
Next

Collect your first swarm

One click in “Settings → Swarm”, one prompt in the composer - and the architect is already inspecting your repository.