Vibeleaderboard
← Course overviewModule 09 · Coordinate several pieces of work · Beta
Lesson 9.1

Module contents

Coordinate several pieces of work

Lesson 1 of 5

Which parts of the work can run at the same time?

Module 8 ended by noticing something about the supplier report once its inputs, checks and effects were written down: the invoice reads did not depend on each other, the total depended on all of them, and the post depended on the file. That structure is the subject of this module. It decides whether a piece of work can be split between several agents or sessions, and whether splitting it would help. This lesson starts where the decision has to start, with a drawing of what depends on what, before anyone asks how many workers to use.

Numbered links identify sources. Underlined terms offer a definition without leaving the lesson.

What this lesson needs from earlier modules

From module 8: written before a run, the as evidence of what ran, and the that keeps a workflow's cases, checks and recovery plan together. From module 3: an is a model, a and tools in a loop; a gives a its scope, its allowed actions and its . From module 4: a is one piece of work as a harness keeps it, and a is whatever carries work from one context to another. From module 5: a tool's says what it does, what it needs and what evidence it returns. From module 2: a can change a , and whole-file replacement can overwrite earlier changes.

Module 6, on choosing a setup, and module 7, the optional software-building module, sit between those and this one. Nothing here requires module 7. Where splitting work between agents touches code, this module says so and points to module 7 for readers on that path; every example here is a document task.

The case: choosing a spring planting supplier

The garden committee has to choose a supplier for next spring's planting order and wants a recommendation for its November meeting. Everything about this case is authored for the module. The garden is in a mainland town. Three suppliers are in the running: Greenway Seeds Ltd, Marlow Plant Supply and Fernbank Nurseries. The committee has agreed a rubric: the price of the standard spring order, the delivery charge, any minimum order, whether the supplier delivers to the garden's area, whether it accepts payment by invoice within thirty days, since the garden has no card, and the lead time.

The work has three parts. Gather the facts for each supplier against the rubric from their published price lists and terms. Check each supplier's eligibility against the garden's two hard constraints, delivery to the area and invoice payment, from the suppliers' delivery and terms pages. Write the recommendation for the committee. The treasurer plans to give the work to agents and is deciding how many.

The harness for this case has read_url, which fetches a web page and returns its text, save_page, which saves a fetched page as a file so that what was read is kept, read_file, write_file and list_folder. Everything is kept in one shared folder, Garden/Suppliers/Spring-2027, and the recommendation is a file in it. Reads and fetches run without asking; saving a page and writing a file ask first.

A dependency map before a headcount

The first question is not how many agents. It is which parts of the work need the results of which other parts. A is a drawing of the work's parts with an arrow from each part to the parts that cannot be completed until it is finished. Here is the map for the supplier decision:

  supplier list + rubric + constraints  (given)
            |                     |
     +------+------+              |
     |      |      |              |
  facts:  facts:  facts:       eligibility:
  Greenway Marlow Fernbank     all three, from their
  (price, terms pages)         delivery and terms pages
     |      |      |              |
     +------+------+--------------+
                   |
          reconcile: one table, sources attached
                   |
          recommendation (final text needs the table;
                          outline and structure can start earlier)
                   |
          save file, then hand to the committee

Read the arrows. Gathering Greenway's facts does not need Marlow's, so the three fact-gathering parts are independent of each other. The eligibility check needs the supplier list, the garden's constraints and the suppliers' own delivery and terms pages, which it fetches for itself; it does not need the price facts, so it can run alongside them. Two of its questions, delivery to the area and invoice payment, are also rubric items, so the fact-gathering and the eligibility check will both read those pages. That overlap is deliberate: it is a cross-check on two fields that decide the outcome, and it costs a second read, which the last lesson counts. The recommendation's final text needs the reconciled table. Its outline, the rubric headings, the committee's constraints, the shape of the argument, can be drafted before the returns are in, and the map marks that distinction rather than forbidding all early work.

The map says something the headcount question hides. Four parts can run at the same time. Everything after them is mostly a line, and a second agent on the recommendation would have little to do until the table exists. The map also says where the seams are, which module 8 called the places where checks have to go: between each fact-gathering part and the reconciled table, between the eligibility check and the table, and between the table and the recommendation. Those are the handoffs, and the next two lessons are about what crosses them.

Fan out, fan in: what a framework makes visible

Software frameworks for building agents have to represent this structure explicitly, and one teaching example makes the shape concrete. LangChain's notebook on parallel execution in its LangGraph framework builds a graph in which one node runs, then two nodes run in the same step, then a fourth node runs after both have finished. It calls the split a fan-out and the join a fan-in, and this course borrows the pair as : a point where independent parts start at once, and a point where the work waits for all of them before continuing. When two parallel nodes each try to write the same piece of shared state in the same step, the framework refuses until a rule for combining the values is declared. 1

That refusal is the useful part, and it is not about the framework, which was read and not installed. Combining parallel results is a step with a rule, not something that happens by itself. Two workers writing to the same place at the same time is a conflict unless something says how their outputs are merged, and the join has to know what it is waiting for. In the supplier map the join is the reconciled table, and what each branch has to return for it is the next lesson's question.

When parallel work fits and when it does not

Anthropic published an account in June 2025 of a research feature built from a lead agent and several subagents that search in parallel. The team reports the arrangement suited to open questions with several independent directions, and a poor fit for tasks whose parts share context or depend on each other closely. 2 That is one team's report about research questions on its own systems, and neither a worker count nor a result transfers from it. The criterion does, because it is the dependency map: independent parts can be explored at once, and parts that need each other's results cannot, whatever the headcount.

So the belief that more agents finish sooner, or do better work, has no general answer. The map answers it for each case. In the supplier decision, four parts can run at once and the rest is mostly a line; if the gathering takes most of the time, splitting it helps, and if writing the recommendation takes most of the time, splitting the gathering saves little and the cost of coordinating it, which the last lesson counts, may exceed the saving. Where every part depends on the one before, a second agent has nothing to do but wait for the first.

Carry this forward

  • Draw the dependency map before deciding on workers: each part of the work, with an arrow to every part that cannot be completed until it is done. Independent parts can run at once; a chain cannot be sped up by adding workers.
  • A fan-out starts independent parts together and a fan-in waits for all of them. Combining their results is a step with a rule; two workers writing to one place at once is a conflict unless the merge is defined.
  • Deliberate overlap between parts, such as two workers reading the same terms page for different purposes, is a cross-check with a cost, not a mistake, as long as it is chosen.
  • One vendor's report found parallel subagents suited to independent directions and a poor fit for closely dependent parts; the criterion transfers, the worker count and the result do not.

Lesson check

In the authored dependency map, which of these pairs can run at the same time, and why?

Choose an answer for each question.

This is a practice check. Answers reset when you leave this page. Results are not saved and do not place you in another module or award a qualification.

The map shows four parts that can run at once. Giving them to workers means writing four assignments, and the next lesson asks what each assignment has to say and what each worker has to bring back.

Sources · Reviewed 2026-09-29
  1. 1. LangChain Academy: Parallel node execution (LangGraph module 4 notebook)
  2. 2. Anthropic engineering (13 June 2025): How we built our multi-agent research system

Sources support nearby explanations. Product details can change. Scenarios and model results are authored illustrations unless a lesson explicitly identifies a recorded execution. Module 7 identifies its offline code checks.