# What a crew is

> Talk to one agent. It hands pieces to the right CLIs, and brings every result back to the same thread.

One agent, working alone, does a big job the way one person would: front to back,
one thing at a time, everything on the same expensive model — the deciding, the
looking-things-up, the typing.

A crew is that same agent deciding it would rather run the job than do all of it.

And the agents it hands the work to are not copies of itself. A crew can put
**Claude Code** (Anthropic), **Codex** (OpenAI), **Grok Build** (xAI) and
**Kimi Code** (Moonshot) on one job — four makers, four subscriptions — so
the deciding runs on your strongest model while the looking-up and the
renaming run on something cheap and fast. One signed-in agent is enough:
a piece with no other agent named runs as a copy of the one you are talking
to.

Which of the four are on this machine is
[which agents beafk runs](https://beafk.app/docs/which-agents-beafk-runs.md).

## The idea

Turn **Put other agents to work** on, at the top of the **＋** sheet.

Now the agent you are talking to can hand a piece of the work to another agent —
with a brief, the way you would brief a colleague who cannot see this
chat — and carry on with its own share while that one works. It reads
what comes back. It hands out more. It tells you what came of it.

You are still typing into one chat. The work has quietly become several
— and every piece grows a card you can open and read in full, which is
[watching a crew](https://beafk.app/docs/watching-a-crew.md).

![two pieces back — Grok's tests green, Claude's two screens — the lead saying what that means, and a fourth piece already filed with Codex to read the diff](https://beafk.app/docs-shots/crew-back.webp)

## Why this is better and not just busier

Because the pieces are not the same size, and neither are the agents.

Your best model is worth what it costs when it is *deciding* something. It is
not worth four times as much to rename a function or to read a folder looking
for where something lives. A crew lets the expensive one stay expensive and do
the expensive part, while the rest goes to whoever is right for it:

- a **scout** on something small and fast — reads a lot, decides nothing, comes
  back with where things are;
- a **builder** on your strongest coding model;
- a **front-end hand** on whichever agent writes the components you actually
  like;
- a **reviewer** on a *different maker's* agent from the builder, deliberately.
  An agent reviewing its own work agrees with itself.

Three of those can be working at the same moment, on three different
subscriptions, while the lead is still reading the first answer. That is where
the speed comes from — and where the value is: your premium allowance goes on
the deciding, and the bulk of the words are written on the subscriptions that
would otherwise have sat idle all afternoon.

## It is not only coding

Anything the agents on this machine can do, a crew can hand out. Read a week of
logs and say what changed. Go through the release notes for the sentence that is
not true any more. Take the same screen and have two different agents draw it,
then pick. The lead does not care what the piece is; it cares that somebody
comes back with an answer.

## How many

As many as the job has pieces. There is no magic number and nothing to buy.

Three run **at once** in one chat — beyond that they queue and start as
the others finish. Eight run at once across the whole machine, however many
chats you have going.

A chat that is still handing out work after sixty-four pieces is stopped.
That is the machine noticing a loop, not a plan you buy more of.

## Two ways to say who does what

**Name a role.** Write it down once — a name, a sentence about *when* to use it,
a CLI, a model, an effort — and the lead is handed your roles as a list of
routing rules it chooses from. That is [writing a role](https://beafk.app/docs/writing-a-role.md),
and it is worth doing for the three or four you will use every day.

**Or just say it.** "Get Codex to write the tests while you do the migration."
"Have Grok take the front end." A piece handed out with no role named runs as a
copy of the lead, on whatever CLI, model and effort it was told to use — so you
can put an agent to work in a sentence, on a machine where nobody has ever
opened the crew screen.

## What it costs

Nothing extra here — beafk charges per machine and adds no token of its own.
Every piece spends the subscription of the agent that ran it, so several agents
working at once is several of your allowances being used at once: the same work
you would have run one after the other, arriving sooner and spread over plans
you are already paying for rather than stacked on the dearest one.

This is why the switch sits at the top of the **＋** sheet rather than two
screens away in a settings pane: it is the one mode that spends other agents'
allowances while nobody is watching, and forgetting you left it on should not be
possible.

## They do not write over each other

Several agents in one checkout will reach for the same file eventually, and they
do not get to fight over it. That guard is not part of the crew — it is the
machine's, on by default, covering every agent on it. A crew is simply where you
meet it soonest. See [two agents, one file](https://beafk.app/docs/holding-files.md).

## One level deep

An agent working on a piece cannot start a crew of its own. That is a deliberate
floor rather than something to work around: agents spawning agents spawning
agents is a bill and a mess with no bottom to it.

## Where they run

On the machine you are on, in the folders your chat is carrying — that is the
point, since they are editing the same checkout. A piece can be started in any
of them, so a job across two repositories is one crew rather than two. Nowhere
else: a second machine is a second chat, opened there.

## When not to use it

For anything small. Briefing an agent on a one-line change is slower than making
it, and it spends several allowances to do it. A crew earns its keep when the
job genuinely has parts.

---

beafk documentation · Crew · https://beafk.app/docs/what-a-crew-is

In this section:
- What a crew is — https://beafk.app/docs/what-a-crew-is.md (this page)
- Writing a role — https://beafk.app/docs/writing-a-role.md
- Watching a crew — https://beafk.app/docs/watching-a-crew.md

Every page, one line each: https://beafk.app/docs/llms.txt
All of it in one file: https://beafk.app/docs/llms-full.txt