Lecture 09. Your Shape Is Your Cost Model

Once the contract-review graph fanned out properly — forty contracts in parallel instead of one after another — the finance team asked why the monthly model bill had tripled. Nobody had changed the prompts. Nobody had switched models. What changed was that every one of the forty contracts now ran its full four-clause extraction and risk classification independently, including the twelve contracts that were pre-approved renewals from a template vendor, identical in every field except the date. The graph got faster. It did not get cheaper. Those are different axes, and the team had only been tracking the first one.

A Graph Is Not Automatically Cheaper

This is the honest part of the course, and it's worth saying plainly: parallel breadth costs money. Running forty extractions at once instead of one after another doesn't reduce the total number of model calls — it reduces wall-clock time by running them concurrently. The bill is the same size; it just arrives faster.

Anthropic's own account of building a multi-agent research system reports the trade-off in concrete terms: their multi-agent architecture outperformed a single agent by a wide margin on breadth-first research tasks, and it used roughly 15 times the tokens of a normal chat interaction to do it.

Source: Anthropic — How we built our multi-agent research system

Fifteen times the cost, for work a single agent structurally could not do as well. That's the trade this lecture is about: the shape has to earn its cost, not just its speed.

Four Places the Shape Controls the Bill

Cheap models for bounded extraction, classification, and formatting. extract liability is pulling a clause out of text with a known structure — it doesn't need the strongest available model, it needs a model that's reliable at a narrow, well-specified task. Route it to a cheaper tier.

Strong models for decomposition, synthesis, and hard verification. classify risk, weighing four ambiguous verdicts against each other, and the verifier from Lecture 07, checking whether an extraction is actually grounded in the source, both benefit from a stronger model's judgment. That's where the spend should concentrate.

Short paths for simple requests. Not every contract needs the full four-clause extraction. A pre-approved renewal from a known template — the case the finance team caught — can take a short path: confirm it matches the template, skip straight to filing. The router from Lecture 06 already has the mechanism; this is just one more label (template_match) with its own cheap route.

The full graph only for work whose value justifies the coordination. A one-off, heavily negotiated contract with unusual terms earns the full extract → check → classify → verify path. A boilerplate renewal doesn't need to walk through all four clause extractions to confirm what a template match already confirms in one cheap check.

type ContractPath = "template_match" | "full_review";

function routeByPath(contract: ContractMeta): ContractPath {
  return contract.matchesKnownTemplate ? "template_match" : "full_review";
}

const COST_TABLE: Record<ContractPath, { model: string; nodesRun: string[] }> = {
  template_match: { model: "cheap-tier", nodesRun: ["confirm_template", "file"] },
  full_review: {
    model: "strong-tier-for-classify-and-verify",
    nodesRun: ["extract_x4", "check_x4", "classify_risk", "verify", "file"],
  },
};

Drawn as a route, the two paths and their tiers look like this:

Price the Shape Before You Run It

The exercise this lecture asks for is small and easy to skip: before running a graph on real volume, write down which nodes run on which model tier and why, and roughly how many of each node type a typical batch triggers. Not a precise forecast — a sanity check.

Illustrative composite — the 40/28/12 split and the node counts are a worked example for this course, not a measurement from a real deployment.

That estimate is what would have caught the finance team's surprise before the first invoice, not after it.

A Hundred Agents Is a Spend Decision, Not a Flex

Fanning a task out to a hundred parallel branches is the right call when the task is genuinely wide, the branches are truly independent (Lecture 02's audit), and the result is worth the spend. It's the wrong call when a single context could have held the whole problem — a hundred branches on a task that didn't need to be split is not impressive engineering, it's a bill with extra steps.

Key Takeaways

• A graph is not automatically cheaper — it's usually more expensive. Parallelism buys wall-clock speed; it doesn't reduce the total number of model calls behind the work.
• The trade has to earn itself. Fifteen times the token cost, per Anthropic's own reporting, bought breadth-first research quality a single agent couldn't match — that's the bar a graph's added spend has to clear.
• Four levers control the bill: cheap models for bounded work, strong models for synthesis and verification, short paths for simple cases, the full graph only where the value justifies the coordination.
• Price the shape before you run it at volume. A rough per-batch estimate of which nodes run on which tier catches a cost surprise before the invoice does, not after.

What You Have Now

A cost table for your graph: which nodes run on a cheap model, which earn a strong one, and the written reason for each. It sits next to the state schema in your design document, the other half of "does this graph survive contact with real volume." It closes out the Verify stage's production checks before Lecture 10's final judgment call.

Save it as graph/lecture-09.md; the lab's checker looks for that file at that path.

Further Reading

• Anthropic — How we built our multi-agent research system — the source for the roughly-15x token multiplier cited above, and the original account of when a multi-agent architecture earned its cost on breadth-first research work.

Exercises

1. Price your own graph. For a workflow you've mapped across this course's lectures, write a rough per-batch node-run estimate like the one above: how many runs of each node, on which model tier, for a typical batch size.
2. Find one short path. In that same workflow, find a subset of inputs that don't need the full graph — a boilerplate case, a known-safe pattern. Design a cheap short path for it, the way the template-match route was added here.

Check your understanding