Module 3 · Planning, Context & Multi-agent Systems · scripted

Cognitive Load: The Two Loads

30 minoutcomes: context-engineering
🎤 Talk view← Cockpit

A judgment failure, not a budget failure

We have priced the conversation carefully — the recurrence, the window, the cost of every carried word. Now watch a failure that no budget explains:

Example 1a · The buried constraint
user

Find and book a venue for the March workshop — 40 people, and it must be wheelchair-accessible; two of our speakers require it.

assistant
⟨tool_use⟩
search_venues(city = "Molde", capacity = 40)
user
⟨tool_result⟩
[6 venues, full specifications: floor plans, AV inventories,
catering menus, parking, cancellation policies — 4 pages]
assistant
⟨tool_use⟩
get_availability(venue = "all", month = "March")
user
⟨tool_result⟩
[availability grids for 6 venues × 31 days — 2 pages]
assistant
⟨tool_use⟩
get_pricing(venue = "all")
user
⟨tool_result⟩
[rate cards, seasonal discounts, deposit schedules — 3 pages]
assistant
⟨tool_use⟩
book_venue(venue = "Fjordgården Loft", date = "2026-03-12")
user
⟨tool_result⟩
Booked: Fjordgården Loft, 12 March.
assistant

Booked the Fjordgården Loft for 12 March — best rate of the six, available all month, and the AV setup covers your needs.

NoteThe Loft is a second-floor room with stair access only — it said so, on page 2 of 9, in the specifications the agent itself retrieved. The constraint was in the very first message. Nothing was missing from this conversation. The failure is not that the agent lacked information — it's that the information that mattered was drowning in information that didn't.
Example 1b · The same task, on a lean wall
assistant
⟨tool_use⟩
search_venues(city = "Molde", capacity = 40,
              accessible = true)
user
⟨tool_result⟩
2 venues match (of 6; 4 excluded — no step-free access):
[#V2] Kulturhuset Sal B — 60 cap, ground floor
[#V5] Havnesenteret — 45 cap, elevator + ramp
assistant
⟨tool_use⟩
book_venue(venue = "V5", date = "2026-03-12")
assistant

Booked Havnesenteret for 12 March — it seats 45 and has full step-free access. Four other venues were excluded on accessibility.

NoteSame model, same task, same constraint. The difference is what the wall carried: two candidate lines instead of nine pages. The first agent didn't run out of tokens or window — it ran out of judgment. That is the cost this pair of lessons is about.

The reader who always just arrived

Why does a crowded conversation degrade judgment, mechanically? Because of the fact we have leaned on since the beginning: the LLM has no memory. It does not "keep track" of the conversation as it goes — every iteration, the entire conversation is presented fresh, to a reader encountering it for the first time. Look at what one iteration actually is:

What iteration 23 really does

ARRIVEa reader with no memory of iterations 1–22 is handed the whole conversation.
ORIENTread all of it. Reconstruct: what is the task, what has been done, what mattered, what is stale, what is still binding.
DECIDEmake one decision.

Steps 1–2 are repeated at EVERY iteration — and every word on the wall, live or dead, is re-read and re-judged for relevance by a reader who has never seen any of it before.

Call step 2 the re-orientation tax. It is charged in two currencies at once:

Paid twice

Every word on the wall is paid for TWICE, every iteration:

  once in TOKENS     — the recurrence bills it
  once in JUDGMENT   — a fresh reader must notice it,
                       weigh it, and decide it doesn't
                       matter... without error, every time

The first payment shows up on an invoice.
The second shows up in Example 1a.

Two kinds of load

There is a name for this in the learning sciences. Cognitive load theory — Sweller's framework for how minds handle complex tasks — divides the burden of any task into two parts, and the division transfers to agents almost perfectly:

The two loads

INTRINSIC LOADthe difficulty of the task itself, as formulated: the judgment genuinely required to choose the next step.
EXTRANEOUS LOADeverything else the worker must process: material present but not needed for THIS step — dead results, unused tools, stale scaffolding, just-in-case documents.

In Example 1a: judging two accessible venues = intrinsic. Re-reading nine pages to find them = extraneous.

The classical advice about human learners is: you can't remove intrinsic load — it is the task — so design ruthlessly against extraneous load. For agents, the advice is better than that, and this is the central claim of these lessons: for agents, both loads are designed. Extraneous load is set by what we let onto the wall — that gets its own lesson. But intrinsic load is set by something we chose even earlier.

Intrinsic load is chosen at formulation

The intrinsic difficulty of the agent's job is not the difficulty of the problem. It is the difficulty of the problem as formulated — under the representation we chose and the tool language we granted. Watch the same genuinely hard problem under two formulations:

Example 2a · The agent as laborer
user

You have the following tools available for use:

  1. get_enrollments()
  2. post_schedule( assignments )

Task: Schedule the department's 14 exams into 5 days: no student sits two exams in one day, statistics before econometrics, room B is unavailable Wednesday, and Prof. Berg is away Friday.

assistant
⟨tool_use⟩
get_enrollments()
user
⟨tool_result⟩
[14 courses × enrollment lists — 212 students, overlapping]
assistant

Let me attempt an assignment. Monday: statistics (9:00, room A), microeconomics (13:00, room B)… but 31 students take both statistics and micro — moving micro to Tuesday. Then econometrics must follow statistics, so Wednesday — but room B is unavailable Wednesday, so room A — but marketing was in room A Wednesday, moving marketing to Thursday… wait, marketing shares 18 students with organizational behavior, which I placed Thursday…

NoteWatch it drown. Constraint solving is search — try, collide, backtrack — and this formulation makes the LLM perform the search in text, on the wall, every collision another paragraph of extraneous history for the next iteration to re-read. The problem is genuinely hard. The formulation made the agent's job the hard part of it.
Example 2b · The agent as formulator
user

You have the following tools available for use:

  1. get_enrollments()
  2. solve_constraints( model )
  3. post_schedule( assignments )

Task: Same task.

assistant
⟨tool_use⟩
get_enrollments()
user
⟨tool_result⟩
[summary: 14 courses; 37 conflicting pairs listed by ID]
assistant
⟨tool_use⟩
solve_constraints(model = "
  vars: exam[1..14] in {Mon..Fri} × {A, B} × {9:00, 13:00}
  no student-conflict pair on the same day       (37 pairs)
  exam[stats] before exam[econometrics]
  room B unavailable Wednesday
  exams graded by Berg not on Friday
")
user
⟨tool_result⟩
Solution found (0.2s): [14 assignments, all constraints
satisfied]. Note: solution is not unique; 6 alternatives exist.
assistant
⟨tool_use⟩
post_schedule(assignments = "[the solution]")
NoteThe problem didn't get easier — the job did. The agent's work is now exactly the part that needs a mind: reading the messy world and casting it into a clean model — which constraints exist? did I capture Berg's situation? The search, which needs no judgment at all, went to a machine that does it perfectly. Look at what stayed on the wall: the model — twelve lines — and the answer. The thousand dead-end assignments were never conversation.

The formulation principle

Hire the model to FORMULATE, not to labor.

Intrinsic load is the difficulty of the CAST, not of the
problem: an agent's best move against a hard problem is to
express it in a form something else can solve exactly.
The judgment stays; the search leaves.

This is a thread we've pulled before, now said at full strength. The framing lesson showed that representation chooses the reasoning — circles are hard in the wrong coordinates. The tool lessons showed the tool set is a hypothesis about how the problem will be solved. Put together: the formulation — representation plus tool language — sets the intrinsic load before the conversation begins. Solvers, databases, compilers, statistics engines: every one is an opportunity to move labor out of the conversation and shrink the agent's job to modeling and judgment.

The formulation audit
  • In Example 2b, what mistakes can the agent still make? Notice: every one of them is a judgment mistake — miscasting the world — not a search mistake. Why is that the right place to spend a model?
  • Take a computation-heavy task from your research. What is its solver — the tool that would turn your agent from laborer into formulator? Does it exist already?

The two dials

The design space, in one view

set byattacked with
INTRINSIC LOADthe FORMULATION: powerful tools,
representation +solvers, better
tool languagecasts of the problem
EXTRANEOUS LOADthe WALL: placement and
what is presentlifetime — deciding
beyond this step'swhat enters, what
needsleaves, what never enters at all

One dial was set before the conversation began; the other is managed while it runs. We've just turned the first. The next lesson builds the instrument for the second — a way to see extraneous load, so it can be engineered instead of felt.

Your turn

Take an agent task from your domain that feels expensive. Split one page in two columns: everything the agent must genuinely judge (intrinsic), and everything it merely wades through (extraneous). Then re-formulate: name the tool — solver, database, script, search — that would move the largest intrinsic item out of the conversation, and write the tool call the agent would make instead. What is left on the intrinsic list? That remainder is what you are actually paying a model for.