More workers can reduce waiting, but they also introduce ownership, coordination, and supervision problems. An autonomous team needs a clear answer to who may decide, who may change each artifact, and who verifies the result. This original lesson expands Doc Steward into a small team that prepares documentation proposals. Its examples are independently designed from public sources, not a reconstruction of MEGA's paid teaching.
Learning goals
- Organize workers around bounded responsibilities and explicit outputs.
- Identify which tasks can safely run in parallel.
- Route work with evidence and uncertainty handling.
- Supervise cancellation, deadlines, retries, and final integration.
Organize work around artifacts
Start with the output contract: one documentation patch, a source manifest, and a check report. Work backward to the necessary responsibilities. An impact worker identifies affected guides. A reference worker collects API evidence. A draft worker proposes text. A verifier checks the resulting patch against evidence and the task contract.
Roles should describe ownership and deliverables, not personalities. “Senior documentation expert” says little about permissible changes. “Return affected paths with evidence references; do not edit files” is operationally useful. The parent can validate that output before giving a writer authority over a narrow proposal directory.
Anthropic's agent-pattern article distinguishes fixed parallel subtasks from an orchestrator that dynamically chooses and delegates work. Use a fixed graph when the decomposition is known. Add dynamic planning only when the input actually requires it.
John Lindquist's public Jev episode listing identifies routing, sequential classification, and multi-agent coordination as discussion topics. Only the listing and chapter descriptions were available for this research. Our team design below is an original example, not a claim about the exact implementation shown in that media.
Parallelize independence, then integrate deliberately
The impact worker and reference worker can run together because neither consumes the other's unfinished output. Drafting depends on both. Verification depends on a specific completed patch. Running all four at once would create apparent activity while the dependent workers guess missing inputs.
Give each worker an immutable input snapshot and a private output location. Shared writable files create hidden dependencies. Two writers changing the same guide need conflict resolution even when they intend to edit different paragraphs. The simplest policy is one writer per artifact, with the parent responsible for integration.
Parallelism also has a resource budget. Suppose impact inspection takes two minutes, reference collection takes three, drafting takes four, and verification takes one. Serial execution takes ten minutes. Running the first two together makes the ideal critical path eight minutes, before coordination overhead. Four simultaneous workers cannot reduce the four-minute draft dependency. These are hypothetical planning figures, not measured performance.
A worker limit protects model quotas, network capacity, and reviewer attention. Long-running tasks need queue discipline so a burst of events does not starve older work. An incident affecting the reference service should reduce dispatch to that service rather than create a storm of retries.
Routing chooses a worker, not authority
Use deterministic routing for explicit facts: a diff confined to api/pagination can select the pagination policy directly. Use a model judgment when the category depends on meaning, such as whether a changed validation rule affects public behavior. Keep the available categories small and explain what evidence each requires.
TypeSafe's confidence documentation separates probabilities from its confidence statistic and describes different behavior for uncertainty and risk. Choice confidence is not simply the selected option's probability. Thresholds need evaluation on the actual task; copying a number from an example does not validate it.
For our team, uncertain classification sends the task to broader inspection or review. The router cannot add tools to a worker. The supervisor applies the same capability boundary regardless of category. A text claim that the task is urgent does not create permission to publish.
Use a fallback category such as unclear, and preserve the evidence behind routing. A closed choice set without a useful uncertainty path can force a plausible category when none fits. If the reference worker finds that the original category is wrong, it should return that contradiction explicitly. Silent rerouting makes the final provenance hard to follow.
Supervision owns failure and completion
The supervisor maintains task state, deadlines, leases, and artifact versions. A lease gives one worker temporary responsibility for a task. A generation number distinguishes a replacement from a stale worker that finishes late. Integration accepts outputs only from the current generation and expected input revision.
A timeout does not prove a worker has stopped. Cancellation must also revoke its write authority or make its eventual result ineligible. Otherwise a timed-out writer may overwrite a replacement's valid patch. The parent should retain that late result as diagnostic evidence without integrating it.
Avoid unlimited recursive delegation. Every child receives a bounded budget, and those budgets consume the parent's total. If each of four workers independently spawns four children, the system can exceed its intended spend before producing any useful artifact. A clear delegation depth and shared accounting make the actual team size observable.
Worked example
This is conceptual orchestration pseudocode. It uses no real Jev SDK or agent framework API.
snapshot = pin(task.repository, task.revision)
impact_job = dispatch("impact", snapshot, output="impact.json")
reference_job = dispatch("reference", snapshot, output="sources.json")
results = await_both_with_deadline(impact_job, reference_job)
assert results.have_required_evidence
assert results.input_revisions == [snapshot.revision, snapshot.revision]
writer = lease("draft", generation=1, allowed="proposals/task-17/")
patch = dispatch_and_wait(writer, results, remaining_budget)
freeze(patch.hash)
verification = dispatch_and_wait("verify", patch, results)
if verification.passed and lease_is_current(writer):
publish_review_artifact(patch, verification)
else:
record_unresolved_result(task, verification)Assume the change renames a pagination parameter and also changes an error message. The impact worker finds two guides. The reference worker returns the new parameter specification but no evidence about the error message. The supervisor should not ask the writer to invent the missing explanation. It can narrow the proposal to the verified parameter update and flag the other guide, or block the whole task if the contract requires complete coverage.
Now suppose the writer's lease expires and generation two starts. Generation one returns a valid-looking patch afterward. Expected behavior is to reject its integration because its lease is stale, even if its prose appears better. Content quality does not fix concurrency ownership. A reviewer can later compare that artifact if doing so is useful.
Finally, the verifier should inspect the frozen patch and source manifest, not merely read the writer's completion summary. It must show that the submitted artifact satisfies the request. A persuasive report can coexist with a missing file or an unsupported factual change.
Practice
Simulate the team using four local task records. You may use stub workers rather than live model calls. Provide a timeline, output artifacts, and an integration decision.
Acceptance criteria:
- Impact and reference tasks overlap; drafting waits for required evidence.
- Every worker output names its source revision and assigned responsibility.
- Two generations of the same writer cannot both integrate.
- A missing reference produces a visible incomplete result.
- Total calls and elapsed deadline stay within the parent budget.
For the answer rubric, a correct timeline shows at least one independent pair and one real dependency. The stale-output fixture must be rejected by a generation or lease check, not by assuming cancellation always works. The incomplete-evidence fixture must identify the unsupported claim. Award no credit for adding extra workers without explaining their inputs, ownership, and integration path.
Check your understanding
- When should two tasks run in parallel? Answer: When each has the inputs it needs and they can produce separate outputs without shared write conflicts.
- Why reject a late result that looks correct? Answer: Its authority may have expired, and accepting it can overwrite newer work or mix revisions.
- What does the supervisor verify before completion? Answer: The actual integrated artifacts, required evidence, current ownership, and remaining unresolved failures.
Sources
- Building effective agents: parallelization and orchestrator-worker distinctions.
- John Lindquist's public Jev episode listing: routing and coordination topics; listing only.
- TypeSafe confidence: decision uncertainty, confidence semantics, and risk-dependent thresholds.