PerchAI
How it works

Flock

Perch's multi-agent mode, on Pro and Ultra. It plans a custom team of workers for a hard task, shows you the plan, runs the workers in phases, and has checker workers verify the result before you see it.

Flock is Perch's multi-agent mode. Where a normal turn is one model working through a task, a flock is a team: Perch plans a set of focused workers for the specific task in front of it, runs them together, and has checker workers review the result before it reaches you.

It is built for hard, multi-part work, the kind where one pass is not enough: reviewing a branch for regressions, auditing a folder of payments, mapping a large repository and naming its risks. For a small, single-step task, a normal turn is faster, and Flock declines those before any work begins.

Pro and Ultra

Flock is on Pro and Ultra. A Starter account holding an Unlimited DeepSeek pass has it too while the pass runs. It runs in Perch Terminal (the desktop app and the CLI), not in web chat, and a run takes longer than a normal turn because a whole team is working and a verifier reviews the result before you see it.

Starting a run

A message becomes a flock only when you ask for one. There are three ways:

  • Begin the message with /flock followed by what you want done.
  • Turn on the Flock switch beside the model button in the composer. It puts /flock in front of your message, so you see the command that will run, and it is off again once the message has gone.
  • In English, open the message with "use a flock to" and the task.
/flock review this branch for regressions and verify the tests

Perch plans the team and shows you the plan before any worker starts.

You approve the plan first

The plan card lists the workers, the steps they run in, and an estimate of what the run will use. Under it you choose:

  • Allow starts the workers on this plan.
  • Refine lets you type what to change, and Perch makes a new plan.
  • Deny runs nothing.

In Take the Wheel, the plan is approved for you and the run starts right away. A one-shot run from your shell (perch run) cannot ask, so an explicit /flock there runs its plan and prints it above the result.

How a flock is planned

Given your task, Perch designs a team for it rather than reaching for a fixed template.

A planner, running on the model your chat uses, reads the task and returns a team of two to ten workers, each with a specific role ("Regression Hunter", "Patch Worker", "Citation Checker"), a bounded objective, a set of tools it is allowed to use, and where it sits in the run. The plan is built for your task, not chosen from a menu.

The plan is not trusted as-is. Worker counts, write permissions, tool access, and every other number are validated and clamped by Perch before anything runs.

If the planner returns no usable plan, nothing runs. Perch says "Flock couldn't plan this task" and you can send the task again without /flock to run it as a normal message.

How the team runs

Workers run in phases, and in parallel within a phase where their work allows it:

Scout. Workers that read and map the material first, so the rest of the team acts on what is actually there.

Work. Workers that do the core task, patching code, drafting a section, running an analysis, each with its own focused context and a narrow objective.

Verify. Checker workers review what the team produced.

Reduce. The results are gathered into a single answer.

Each worker gets a bounded piece with its own context, so one step does not pollute another, and a large task moves in pieces instead of one overloaded request. Workers wait on the outputs they depend on; a worker whose dependency is unavailable is skipped rather than handed empty context.

A worker that needs a decision from you can ask a question while it runs. In Take the Wheel, your model answers for you instead.

Running in the background

In the desktop app a flock runs in the background by default: the reply comes back once the workers start, you keep the chat, and the result shows in that chat when the run finishes. In the CLI the turn waits for the run unless you turn the background setting on.

These commands manage a run from the chat it started in:

CommandWhat it does
/flock statusLists the flocks in this session, newest first, with how many workers are done.
/flock stopStops a running or paused flock.
/flock pausePauses a flock running in the background. Workers that finished keep their results.
/flock resumeResumes a paused flock. The workers that had not finished run again.
/flock restart <worker>Restarts one worker of a background run, along with the workers after it that used its work.

A run that reaches its limit on model calls pauses instead of spending past it. Resume it with /flock resume. A run lives in the session that started it, so it cannot be resumed after you quit that session.

Saved flocks

After you allow a plan, you can keep it and run it again without planning:

  • /flock save release-check saves the last flock you allowed in this chat. It goes in your project, under .perch/flocks/. In the CLI, add --personal to keep it in your own folder instead.
  • /flock saved lists your saved flocks.
  • /release-check runs the saved flock by its name.

How the work checks itself

Verification is where Flock earns the extra time. Checker workers review the team's output, and their findings never silently pass:

  • If a checker finds unsupported claims, missing citations, contradictions, or gaps, the draft goes through one bounded revision pass, then the same checker rechecks it once.
  • On code, a checker returns a verdict of pass, fail, or partial with the checks it ran. A fail sends the work back to the worker that wrote it, and the checker runs again, for a bounded number of repair rounds.
  • The findings, the recheck verdict, and a clear next step travel with the final answer, so you see what was questioned and whether it was resolved.
  • A partial result is reported as partial. Flock does not dress up an incomplete run as a finished one.

Drafting work that cites sources is held to a grounding contract: claims carry inline [n] markers back to what a scout actually found, and anything unsupported is flagged for verification rather than left to stand.

Roles and callsigns

Every worker has two names. Its role ("Regression Hunter") is what the model works as. Its callsign ("Eagle", "Shawarma", "Bell") is presentation only, a way to tell workers apart at a glance while the run streams. Callsigns never appear inside a worker's instructions, so they cannot influence the work. In the CLI a row reads:

Regression Hunter · Eagle · running

Limits and guardrails

Flock runs inside hard limits, enforced by Perch rather than requested from the model:

GuardrailLimit
Workers per flock2 to 10
Workers that can write to your files2 (up to 4 in Take the Wheel, when the plan justifies it)
Wall-clock time8 minutes by default and 10 minutes at most when the turn waits for the run. A run in the background gets longer.
Total tool calls across the run160
Steps per workerCapped for every worker
Model calls across the runCapped. Reaching the cap pauses the run.

Two rules hold regardless of the plan:

  • No recursion. A flock worker cannot start its own flock or delegate to more agents. Orchestration tools are stripped from every worker.
  • Honest results. Unavailable models are reported, not faked; unread files are reported as unread; a run that runs out of budget finishes from the evidence it gathered and says so.

What Flock is not

  • It is not available in web chat. It needs the local file access that only Perch Terminal has.
  • It is not instant. If you need a quick answer, use a normal turn.
  • It is not automatic. Nothing routes a message to Flock unless you ask, and it is no longer a setting on the effort bar.
  • It is not a black box. You see the plan before it runs, and every worker's role and status while it runs.

For the single-agent foundation Flock is built on, see The operator and agents. For how citations are verified, see Citations.