How to use
Orchestration: models, subagents, files
The general manager hands out work by how hard it is; every employee works with the right model, at the right effort, in its own files. This page explains how the company splits work, guards quality and keeps token spend in balance.
Handing out work
Model and effort by difficulty
Whoever writes the plan stamps each job easy, medium or hard. The job opens with the model and thinking effort that fit the stamp. The defaults:
- Easy: Sonnet, low effort
- Medium: Sonnet, medium effort
- Hard: Opus, high effort
You can change these on the "Model and effort by difficulty" card in Settings › Working style. The point is to stop wasting tokens: simple work doesn't burn the expensive model, hard work doesn't stall on a weak one.
Critical roles on the top model
The general manager, department leads and reviewers run on the strongest model by default. When you move one of them to a weaker model, the app asks you to confirm and reminds you that the risk is yours. The warning shows when you change the model in an employee's settings, and a critical employee below the top model carries a "⚠ Critical role" badge there.
Subagents
Employees on Claude Code can open subagents to go faster, but only the four the company defines:
- Explorer: read only; looks through code and files and reports back.
- Implementer: makes the change it was given.
- Verifier: checks whether the work meets its acceptance criteria.
- Rebutter: a read-only eye that, during nested review, tries to disprove a single finding by reading the code and running the matching test.
Company policy, not the employee, sets a subagent's model and effort, and that model can never be above the employee's own.
Every subagent gets its job in a fixed shape: task, context, the files it may touch, the files it must not, steps, acceptance criteria and a report. The report lists the files it created, changed and deleted separately.
Subagents running in parallel never share files; the employee edits shared files itself.
By the size of the job: subagents are off for easy work (the permission is switched off too), and off for narrow work touching just one or two files; up to 2 may run for medium work, and up to the department cap for hard work. They never run during planning, routing or the goal check. In review and integration testing they only run when nested review is active (for the rebutter). Once the limit brake switches to slow mode, no new session gets a subagent at all. When the setting changes, the employee's terminal reopens with the new permission.
Department settings
Subagents are set per department: on or off, which model and effort, and how many may run at once. In Settings › Departments, click a department (or right-click its heading in the list on the left and pick Department settings), then go to the "Sub-agents" section.
The "Working environment" section of the same window changes the model for the whole department. Right-clicking a department heading also offers Opus, Sonnet or Haiku in one click.
Sequential work chains
Jobs that touch the same files, or that need the output of an earlier one, are chained together; a plan can also list which files each job touches. Two jobs whose files overlap never start at the same time — the second one waits on the board with "⏳ waiting: starts once … is done." When you ask for a goal to run strictly one step at a time, the plan can chain every job in sequence.
External helper
An employee can hand a clearly-specified sub-job to another tool (Claude, Codex, Gemini, opencode) under company policy; it can never call that tool directly, only through the app's own path. Which helpers exist, their model, effort, time limit and an optional daily dollar cap are set in the department window › External helpers section — the employee doesn't choose these, they're fixed.
The write happens in a temporary git copy; anything the helper returns that touches files it wasn't allowed to change is stripped from the patch before the employee applies the rest. A read-only helper never changes any file.
Quality and safety
Status checks
An employee who has gone quiet for 8 minutes (or hasn't delivered for 12) is asked, on the lead's behalf, "🩺 what's done, what's left, any blockers?" The answer shows on the board card (🩺 next up / ⛔ blocker); a reported blocker goes to the lead as a message.
If neither an answer nor output arrives within 10 minutes, the session is treated as stuck and reopened where it left off. A crashed or reopened session is told why and what it last reported — "your previous session was cut off partway, don't redo what's already done, check the git diff." A terminal waiting on a permission question is never poked this way.
Integration test stage
Once every job in a code project is done, and before the goal check, someone from the quality team (first whoever knows test automation/e2e, then a test engineer, then the quality lead) runs the tests against the merged result. Each failure becomes its own fix job; once fixes land, the tests run again. Any job that finishes after the last test run triggers it again; after two rounds, whether to run a third is asked of you.
Review always stays inside the quality team: nobody reviews their own work, and another quality member (or, failing that, the technical lead) reviews the quality team's own work.
Nested review
On hard or large jobs, or when the goal asks for something like "detailed testing," every finding the reviewer raises goes to its own rebutter subagent. The rebutter tries to disprove the finding by reading the code and running the matching test; if it finds no evidence, the finding stands. You and the job's owner only see the findings that survived, with reasoning; the summary starts with "N of M findings survived."
This kicks in on its own: when a job is stamped "hard," when the project has grown (at least 6 jobs, or at least 15 files under review), during integration or acceptance testing, or when "detailed testing" was explicitly asked for. Simple work keeps a single-pass review.
Rule suggestions
Review rejections, failing verification commands, rule violations, conflicting files and stuck jobs are all tracked. When the same problem shows up at least 3 times in 14 days across at least 2 different jobs, a single "📜 Rule suggestion" lands in Approvals. Employees can propose one too, for a pattern they've noticed. Approving it adds it to Rules; a rejected suggestion doesn't come back.
Git safety and snapshots
Git commands that could delete someone else's work (reset --hard, clean -f, bulk checkout ./restore ., stash, branch -D, worktree remove and the like) are blocked at every permission level; reverting a single file is still fine.
Every active job's uncommitted changes (including new, untracked files) are quietly saved every 10 minutes. The 📸 button on a task's board card opens these snapshots; "Recover" brings one back into a separate branch and folder without ever overwriting anything.
Limits and cost
Limit brake
Your Claude subscription's 5-hour and weekly usage windows are tracked separately. Defaults: in the 5-hour window, slow down at 70%, stop at 90%; in the weekly window, slow down at 60%, stop at 85%. The company can also slow down early based on "at this rate, when will it fill up."
In slow mode, fewer jobs run at once, no subagents open in new sessions, and easy work moves to a cheaper model. In stop mode, no new work is handed out; the company picks back up on its own once the window resets. Only employees on that subscription are affected — not ones using an API key or another tool.
Setting: Settings › Working style › Limit brake.
Instructions and rules
Instruction diet
The instructions an employee reads for each job are no longer one long text: they're split into small rule files, and the employee only reads the ones that job needs, via a "what to read, when" list. This noticeably shrinks the size of what goes out with each job.
The 📜 Instruction preview button on a task's board card shows you exactly what went to the employee for that job: who got what, which rule file was included and why, and its size. The Rule reading measure in Settings › Working style shows whether the matching rule file was actually read before its trigger fired.
File ownership
Employees announce the files they work on or add. They don't delete a file they don't recognise: they look up in git history who added it and ask them first, and ask you when nobody owns it. The "Claimed files" box in a project's detail panel shows who has claimed which file.
Message queue
Messages between employees travel through a background queue, so the sender never waits. Messages for an employee whose terminal is closed are not lost; they are delivered when the terminal opens.
Employees on Claude Code write to each other using Claude's own SendMessage feature; these messages also show up on the Messages page with a "via Claude" badge, and are never written to the terminal a second time. Employees not on Claude, and any recipient whose terminal is closed at the time, still go through the file-based route (the message queue).
Did not find it? Write to us