3.2 - Single-Agent vs. Multi-Agent Orchestration

Build exercise: Build and compare single-agent, sequential, and parallel hub-and-spoke reviews

Intermediate · 40 minutes

You'll practice:

• Apply the isolation/parallelism test to a concrete scenario
• Implement explicit context passing between a coordinator and its subagents
• Spawn independent subagent calls in parallel and merge their results

1. Write a single agentic loop that reviews a list of 6 short code snippets (as one big prompt containing all 6) for one specific style rule, and note how the response quality and prompt size change as you imagine scaling this to 200 files.

   You need the baseline to compare against - the single-agent approach is legitimate at small scale, and seeing where it starts to strain is what motivates decomposing it.

   You should see: One API call returning a review of all 6 snippets, with the prompt string containing every snippet's text concatenated together.

   Hints

   1. What happens to a single prompt's size and the model's ability to track per-file findings as the file count grows?

   2. Concatenate the snippets with clear delimiters and ask for a per-file verdict list. Notice that the prompt is doing double duty as both instructions and the entire dataset - that doesn't scale.

   3. const prompt = snippets.map((s, i) => `--- File ${i}: ${s.name} ---\n${s.code}`).join("\n\n") + "\n\nFlag any use of var instead of const/let, per file.";
      const response = await client.messages.create({ model: "claude-sonnet-5", max_tokens: 1024, messages: [{ role: "user", content: prompt }] });

2. Split the 6 snippets into 2 uniform "subagent" calls of 3 files each, each with its own independent messages.create() call and its own explicitly-passed context (just its 3 files and the style rule - nothing else).

   This is the isolation principle in code: each subagent call gets exactly what it needs written into its prompt, and nothing it doesn't, proving to yourself that no context is inherited automatically.

   You should see: Two separate API calls, each with a prompt containing only its assigned 3 files, each returning its own findings independently.

   Hints

   1. If these were run through a shared conversation, what would leak between them that shouldn't? How do you prevent it with separate calls?

   2. Write a reviewSlice(files, rule) function that builds a prompt from only the files passed in, and call it twice with different slices. Each call is a fresh messages array with no shared history.

   3. async function reviewSlice(files, rule) {
        const prompt = files.map(f => `--- ${f.name} ---\n${f.code}`).join("\n\n") + `\n\nRule: ${rule}`;
        const res = await client.messages.create({ model: "claude-sonnet-5", max_tokens: 512, messages: [{ role: "user", content: prompt }] });
        return res.content.find(b => b.type === "text")?.text;
      }
      const slice1 = files.slice(0, 3), slice2 = files.slice(3, 6);

3. Run both slice reviews in parallel with Promise.all instead of sequentially with two awaits, and measure the wall-clock time difference against running them one after another.

   This is the parallelism win the exam expects you to recognise: independent subtasks invoked together finish in roughly the time of the slowest one, not the sum of both.

   You should see: The Promise.all version completing in noticeably less wall-clock time than two sequential awaits of the same two calls.

   Hints

   1. What JavaScript/TypeScript construct lets two independent async calls run concurrently instead of one blocking the other?

   2. Use Promise.all([reviewSlice(slice1, rule), reviewSlice(slice2, rule)]) instead of awaiting each call in sequence. Time both approaches with console.time/console.timeEnd to see the difference directly.

   3. console.time("parallel");
      const [r1, r2] = await Promise.all([reviewSlice(slice1, rule), reviewSlice(slice2, rule)]);
      console.timeEnd("parallel");
      
      console.time("sequential");
      const s1 = await reviewSlice(slice1, rule);
      const s2 = await reviewSlice(slice2, rule);
      console.timeEnd("sequential");

4. Deliberately break isolation once on purpose - pass slice2 a review prompt that references "the issues found in the previous file" without actually including them - and observe that the subagent has nothing to work with, then fix it by passing the prior findings explicitly if a task genuinely needs continuity between slices.

   Seeing the isolation failure firsthand is the fastest way to internalise why context has to be explicit - a subagent literally cannot answer questions about information it was never given.

   You should see: The subagent either hallucinating an answer, asking what "the previous file" refers to, or producing an unusable response - followed by a corrected version that includes the actual prior findings and produces a sensible answer.

   Hints

   1. If a subagent's prompt refers to something it was never shown, what are its only two options?

   2. It can either say it doesn't have that information, or (worse) guess - neither is useful. Fix it by adding the actual prior findings as an explicit argument to the function and interpolating them into the prompt.

   3. // Broken: references context that was never passed
      const brokenPrompt = `Given the issues found in the previous file, review these:\n${slice2Text}`;
      
      // Fixed: pass it explicitly
      async function reviewSliceWithContext(files, rule, priorFindings) {
        const prompt = `Prior findings for context: ${priorFindings}\n\nNow review:\n` + files.map(f => f.code).join("\n\n") + `\n\nRule: ${rule}`;
        // ...
      }

5. Write a small coordinator function that merges the two slice results into one combined report, and confirm the merged output covers all 6 files with no duplication or gaps.

   Aggregation is a coordinator responsibility distinct from delegation - the exam expects you to recognise that merging correctly (not just dispatching correctly) is part of the pattern.

   You should see: A single combined report listing findings for all 6 original files, sourced from the two independent slice results.

   Hints

   1. What's the simplest check that would catch a coordinator merge bug, like accidentally dropping one slice's results?

   2. Concatenate or structure the two results, then assert the merged output mentions all 6 original filenames - a quick sanity check for silent gaps in the merge.

   3. const merged = { findings: [r1, r2].join("\n\n") };
      const allNamed = files.every(f => merged.findings.includes(f.name));
      console.log(allNamed ? "All files covered" : "Coverage gap in merged report");