Turn collaboration into a dependency graph

A useful multiagent design starts by naming the artifacts a task needs. For a release assessment, those might be a change inventory, a compatibility report, a risk table, and a final recommendation. Calling three agents researcher, critic, and manager leaves their interfaces ambiguous. Instead, specify the input snapshot, output schema, permitted tools, completion condition, and evidence requirements for each assignment. A compatibility worker might consume an immutable API diff and produce rows containing affected symbol, supported version, test evidence, and unresolved uncertainty.

This makes collaboration inspectable. The coordinator can reject an incomplete artifact without judging whether the worker sounded confident. It also exposes false independence: if the risk table requires compatibility results, those tasks cannot run concurrently merely because different agents own them. A dependency is an information requirement, not an organizational preference.

Represent each task as a node and each prerequisite as an incoming edge. A directed acyclic graph, or DAG, describes work with no circular prerequisite chain. Suppose inventory takes two minutes, compatibility takes five after inventory, security takes four after inventory, and synthesis takes two after both analyses. Sequential execution takes thirteen minutes. With enough workers, the earliest finish is nine: two for inventory, five for the slower analysis, then two for synthesis. The security branch has one minute of slack.

These are planning estimates, not measured model benchmarks. Real latency includes queueing, tool delays, retries, and coordination. Python's TopologicalSorter accepts predecessors and exposes ready nodes; it does not allocate workers or estimate duration. The example below calculates earliest finish times separately, making the scheduling assumption explicit. [Python graphlib documentation](https://docs.python.org/3/library/graphlib.html).

Excess edges reduce parallelism, while missing edges produce incorrect work. Consider a documentation worker and a test worker that both read the same frozen interface specification. They can proceed independently. If the documentation worker instead reads the test worker's evolving patch, its output depends on an unstable artifact and may describe a version that never ships. Freeze a shared input or introduce a dependency on a reviewed patch, then record its content hash in the downstream assignment.

A DAG is most helpful when tasks have bounded interfaces. Exploratory dialogue may legitimately revisit earlier assumptions. Model that as a new iteration with a new graph or an explicit bounded loop outside the DAG. Do not hide a circular dependency by dropping an edge until the sorter accepts it; you have changed the meaning of the work rather than resolved the cycle.

Ready does not mean running. A service may allow only two simultaneous browser sessions or one repository writer. Add resource requirements to tasks and let the scheduler choose among ready nodes. Critical path priority can improve completion time, but repeatedly preferring long jobs may delay small interactive requests. Tenant quotas and deadlines are separate scheduling objectives that should be stated rather than buried in an arbitrary alphabetical order.

In the worked graph, two analysis workers realize the nine minute estimate. One worker still needs thirteen minutes because the five and four minute analyses cannot overlap. Adding a fourth worker provides no further benefit for this graph. That observation is a useful budget defense: worker count should follow available independent work. It also helps diagnose slow runs before blaming an individual model or increasing concurrency globally.

A task with a long sequential reasoning chain can lose coherence when split across workers. Each handoff requires context selection, serialization, and verification. A single agent that can inspect a small codebase, make one localized edit, and run one check may be simpler and faster than a committee. Specialization earns its cost when workers need different tools, substantially different evidence, or independent analyses that can be evaluated separately.

Evaluate this choice using the same cases and outcome rubric. Compare task completion, correctness of artifacts, elapsed time, total tokens, and integration corrections. A multiagent run that finishes earlier but leaves contradictory assumptions is not an automatic improvement. Keep a one-agent baseline and require the graph to explain its advantage. The graph is an executable hypothesis about where independence exists, not proof that more agents make the task easier.

This deterministic teaching simulation uses invented minute estimates and unlimited workers. It calculates earliest finishes for a DAG; it is not a multiagent runtime. Change a duration or edge and compare total work with critical path length.