Agent swarm

A swarm is a named set of roles that is launched on the repository with one button. Only communicates with you architect: he studies the code, distributes tasks to participants, collects their reports and summarizes.

Roles

Role View What does
Architect presenter the only one who speaks to you; studies the repository, breaks down work, compiles reports
Analyst reviewer parses requirements and data, does not edit anything
Frontend developer developer interface and client code
Backend developer developer server, API, data
Security reviewer looks for risks, secrets, unsafe challenges; only report
Product reviewer looks at the task through the eyes of the user
Tester developer writes and runs tests
DevOps developer assembly, CI, environment
Frontend inspector reviewer evaluates the quality of client code written by other agents
Backend inspector reviewer evaluates the quality of server code
Quality inspector reviewer general assessment of change beyond division into front and back

Reviewer roles cannot edit files or run commands - this is prohibited by role-level policy, regardless of mode and settings (see. Control).

Assemble the composition

Settings → Swarm:

  • buttons "Collect: Full Swarm / With Inspection / Development / Audit" create a ready-made composition with one click (“With inspection” - architect, front-end, back-end, front-end inspector and back-end inspector);
  • "New Swarm" — your own: choose roles for each agent and model, assign a leader, edit the role instructions if necessary (it has its own version history);
  • if a role has an agent selected that is currently unavailable, the card will warn: the swarm will not start until the agent is connected.

Launch

In the board composer, select the chip "Swarm", repository and describe the entire task - how you assign it to the team. Pulse will create a task, one session for each role, and launch only an architect; the rest are waiting.

Protocol

  1. The architect receives a brief: role, composition of the swarm, your task, task notes, an excerpt from the repository memory, prompts from connected MCP servers.

  2. He inspects the code and distributes tasks in blocks:

    frontend: Translate LoginForm to common components from src/ui
    security: Check token storage, do not edit anything - just report
    tester: Cover the login form with tests and run npm test
  3. Pulse parses the block and sends each participant their task. A participant who has not yet started gets the first turn with a role, task and context.

  4. The participant works and ends his turn with a report. The report is the text after the last call of the tool; he goes to the architect.

  5. When all tasks are completed, the architect sums up. The result is added to repository memory — the next tasks will begin with this knowledge.

In the “Swarm” column you can see everything: roles, who is the leader, whose task is in progress, whose report has been sent, how many waves have passed.

Developers have their own worktrees

Developer roles (frontend, backend, tester, DevOps) work each in its own working copy on a branch <task branch>-<role>. Reviewers and an architect are tasked in the worktree.

  • Before the task, the task branch is merged into the participant’s copy (what is not committed on both sides is first committed with the message “swarm: ...").
  • After the report, the participant’s work is committed and merged back into the task branch.
  • 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

  • The participant fell — Pulse repeats its task (up to two attempts, with the note “last attempt was interrupted”), the session restarts itself. After the second failure, the task is marked failed and the architect receives a message.
  • Participant stuck — a task without a report for more than 20 minutes is interrupted and considered a failure: the same repeat logic continues to work.
  • Need to intervene manually — the participant’s ✈ button in the “Swarm” column sends him a task directly from you; the report will still be returned to the architect.

Inspectors in a swarm

Inspector roles work on the strongest available model and evaluate the work of the others: evaluation along six axes, findings and correction to the author. The report goes to the architect, like any reviewer, and he decides who to distribute the edits to. More details - Quality inspectors.

Limitations

  • The tasks are given by the architect; you can give a task to a participant manually, but the role of the “distributor” is the same.
  • The report is considered to be the last text of the participant's turn - if the model ends the turn by calling a tool without words, the report will be empty.
  • Swarm counts the waves: one wave - one block of tasks and all reports on it.

State of the decision layer of an autonomous swarm 24/7

Packages packages/pulse-* and apps/pulse-server develop a separate autonomous swarm 24/7. The swarm described above in the Pulse window does not use their decision layer. B packages/pulse-core interface implemented DecisionEngine, deterministic rulesEngine, wrapper loggingEngine, entry to pulse.decisions and calculation rulesCoverage. These are the verifiable components of the library; they are not connected to the execution of instruments.

packages/pulse-agents/src/runner.ts while collecting the context of the role, and runRoleTurn makes one request to the model and returns text. Implementations AgentExecutor there are no tools with calls; queue provides beforeToolCall, but the working dispatcher has not yet called it. Flag requiresGate only declared in the role registry; gate module packages/pulse-guard no. Work turns do not record solutions in pulse.decisions, the rule coverage metric does not reflect their implementation, and the error DECISION_ESCALATION does not arise from this layer.

Until problem #125 is implemented, the rules of §5 are not a working defense before executing tools. Autonomous swarm 24/7 is not ready to run with tools.