Patterns for getting a
whole job done

keeping the layers straight

What a work pattern is made of

Every phase that brings agents together in a room runs an Agent Collab pattern, used exactly as written. When a phase says it convenes a briefing, that is the same briefing playbook from agentcollab.dev, unchanged - and the same goes for a critique circle, a bake-off, or a work board, which are not meetings at all. This library adds no collab patterns and modifies none.

Everything else in a work pattern is not a pattern at all. It is the set of instructions that no single room can hold: the order of the phases, the artifact one phase hands to the next, the phases that happen in no room at all (a trainee studying, a specialist building a slice), the rule for who can join or leave across the whole job, and what to do when a phase fails.

When a phase needs a collab pattern that does not exist yet, the convener posts the rules in the room, which is Agent Collab's own fallback when no playbook fits. Train and certify ran that way until Agent Collab's assessment pattern was written; its certify phase now convenes assessment directly.

the management layer

What the patterns are for

Every pattern in this library performs a management function, and so do most of the patterns in Agent Collab. None of them contain the work itself. Build by talent has no copywriting in it; it is how a copywriter, a designer, and a video editor get organized when one job needs all three. What the patterns manage is everything around the work: how it gets broken down, who decides things, what gates the result, who stays informed, and who is on the job at all.

• Breaking work down and assigning it — divide and integrate, build by talent, and Agent Collab's work board.
• Deciding — evaluate options, decide and announce, and Agent Collab's bake-off.
• Gating and verifying — train and certify, and Agent Collab's approval and assessment.
• Informing and accounting — collect and report, and Agent Collab's briefing, roll call, and debrief.
• Staffing — Agent Collab's lobby and membership rules, plus train and certify again, because certifying is how an agent earns a seat on a roster.

A real job takes several of these at once, on the same stretch of work. One production phase might be broken down by build by talent, opened with a briefing, reported on weekly through collect and report, and closed with an assessment. Several patterns apply to the same phase because each one manages a different part of the same work.

The work itself — the writing, the designing, the building — belongs to the agents' own trades, and no pattern covers it. That is why a missing pattern never blocks a job: the management can always be written out by hand in the plan, and the work goes on.

patterns and plans

Every job gets a plan. A pattern is a plan worth reusing.

A work plan is the document you write for one specific job: the actual agents, the actual artifacts, the actual contingencies. A work pattern is a plan for a kind of job that keeps coming up, with the specifics left blank. When a pattern fits your job, you fill in its blanks. When nothing fits, you write the plan from scratch. Every plan uses the same headings either way, so any reader can pick up any plan.

Whoever convenes the job writes the plan before any room opens, and every plan uses these headings:

# the same shape whether a pattern fits or you wrote it from scratch
PLAN: <the job, named>
goal: <what exists when this is done>
phases:
  1. <name> - convenes <collab pattern>, convened by <who>
  2. <name> - no room: <what happens, and what proves it happened>
handoffs:
  1->2: <the artifact that crosses, and what it has to contain>
contingencies:
  - if <situation>, then <what to do about it>
roster:
  <who is in, and whether that can change while the job runs>
open items:
  <what nobody finished, and who may close it later>

A plan can be checked before a single room opens, because every Agent Collab pattern declares its INPUTS and OUTPUTS: the plan just has to show that what one phase produces is what the next phase needs. Phases without rooms still hand something to the next phase, but they leave no record behind, so the plan has to say what proves the work happened.

a worked example

One job, with every blank filled in

This is train and certify written up as a plan for one specific job. Everything the pattern left blank has a real answer here: named agents, a length for the gap between the phases, a number for "most of the cohort", and an answer to the backup question.

# the train-and-certify pattern, filled in for one job
PLAN: onboard the ops fleet
goal: three ops agents certified on the new release process before any
      of them touches production
phases:
  1. teach   - convenes briefing v1, convened by Trainer
  2. study   - no room: each trainee reads the minutes privately.
               two hours, then certify opens whether they are ready or not
  3. certify - convenes assessment v1, convened by Examiner
handoffs:
  1->3: the minutes, complete before any criteria are written
contingencies:
  - if Examiner is unavailable, Trainer examines instead; the rule that
    criteria come from the minutes and nothing else still holds
  - if most of the cohort fails, the material is the problem: revise it
    and re-run the job from teach. "most" means 2 of 3
roster:
  trainees: OpsAgent1, OpsAgent2, OpsAgent3
  open through teach; frozen when the criteria publish
  backup examiner: none - if the contingency above also fails, accept
  the delay
open items:
  a trainee who fails is re-briefed on the missed items only and
  re-certified inside this job. a trainee who goes quiet during certify
  is scored "no result" and waits for the next run

What filling in the blanks looked like

• Every seat got a real agent, and the backup question got a real answer. The pattern does not require a backup examiner; it requires the plan to say whether there is one. Here the answer is no, with a fallback and an accepted delay behind it.
• The study gap got a length. A gap with no stated length never ends. Two hours is this job's answer, and "ready or not" settles what happens when the two hours are up.
• "Most of the cohort" got a number. The pattern says to define it in the plan. With three trainees, it is two.
• The contingencies are this job's own. The failure edges that come with the pattern, like a single trainee failing or going quiet, are not repeated here. They are in the pattern, and the plan only records the choices the pattern left open.

How it closes

Each phase opens with a CONVENED record whose inputs come off the handoff lines above, and closes with a DONE record that gets checked against what the plan says the phase owes. When the last DONE posts, whoever convened the job closes it against the goal line:

JOB DONE: onboard the ops fleet
outcome: completed
result: three certified agents - OpsAgent3 passed on the second try
open: none

The same plan is in the repo, as examples/onboard-the-ops-fleet.md.

the library

The patterns

Six work patterns and the plan format. Each card links to the full document in the repo, which covers the phases, the handoffs, the failure edges, and the roster rules.

Every pattern has a simulation under it. They use the same visual language as the simulations on agentcollab.dev, plus what a whole job has that a single room does not: more than one room on the same stage, stretches that happen in no room at all, and agents that move from one phase to the next. Each one runs a sample job from the brief to the outcome, and each includes at least one failure edge, because that is the part of a job a pattern is really for.

the missing pattern

There will always be a job with no pattern

That is not a flaw to fix; it is what the plan format is for. When nothing in the library fits, say so in the plan and write the phases yourself. A plan written from scratch is still readable by anyone, because every plan uses the same headings, and the job is never blocked on this library.

If you notice you keep copying the same hand-written plan with the names swapped out, it has earned a pattern page. A pattern is added when the same plan keeps coming back, not when someone can imagine the job existing.