The Planner–Executor

Spend the judgment once

The Explorer and the Scientist spend judgment at every fork, because their forks arrive one at a time, each shaped by the last. But a large class of problems has a different structure: the situation needs real intelligence to read — once — and then the work is repetitive, long-running, or high-volume. For those, the third archetype: use the mind to write the workflow, then run the workflow without the mind.

The formulation principle said: hire the model to formulate
the PROBLEM, not to labor on it.

The Planner–Executor extends it one level up:
hire the model to formulate the PROCESS.

  PLAN     judgment, once: read the messy situation,
           emit a concrete workflow — as an artifact.
  EXECUTE  no judgment: the workflow runs at code prices,
           as many times as needed.
  ESCALATE judgment returns ONLY on exception.

Classification: this archetype is half in, half out of conversation. Planning is a short conversation — judgment on a small wall. Execution is not a conversation at all: the plan runs as code, and no wall exists between exceptions.

The nightly pipeline

The setting: a collaborator will deliver sensor exports every night for the season. Their format is idiosyncratic — header quirks, local units, a serial-number convention — exactly the messy reading an LLM is good at. But it needs that reading once:

⟨tool_use⟩
inspect_files(samples = ["export-0912.csv", …])

⟨tool_result⟩
[3 files: semicolon-delimited; two header lines; timestamps in
local time, no zone; depths in fathoms; sensor ids like
"NTNU-B2/7"; occasional trailing summary row]

⟨tool_use⟩
emit_plan(workflow = "[see plan below]")

Study that artifact for a moment, because the artifact is the archetype. It is legible — a colleague can read it. It is approvable — the data steward can sign off on it before it ever runs, something no agent trajectory can offer. It is diffable — when it changes, the change is visible line by line. And from tonight on, it executes at code prices: no mind, no wall, no re-orientation — the plan runs the 99 quiet nights for the cost of electricity.

An agent's decisions are spread through a transcript.
A planner's decisions are gathered into a document.

That single difference buys: review BEFORE execution,
approval by humans, versioning, diffing, blame —
the entire apparatus civilization has for documents,
applied to behavior.

Judgment returns only on exception

Then, one night in November:

⟨tool_use⟩
inspect_files(samples = ["q-1104"])

⟨tool_result⟩
[confirms: 1 header, comma-delimited, qc_flag ∈ {0,1,2},
otherwise identical semantics]

⟨tool_use⟩
emit_plan(workflow = "[v2: delimiter comma · 1 header ·
qc_flag: drop rows =2, keep flag otherwise · all else
unchanged]")

The executor's stages RAISE with a reason — the instructive
error, one level up. The reason becomes the planner's brief.

  handle the 99% at code prices
  summon judgment for the 1%, with the evidence attached
  and the RESULT of judgment is always a new plan,
  never a quiet, one-off intervention

Where it sits

How is this different from the pipeline we built two lessons ago? There, a human designer wrote the workflow at design time, for a task type. Here, the planner writes a workflow per situation — NTNU's feed gets its plan, the Bergen collaborator's completely different export gets its own — from the same planner. The Planner–Executor is the pipeline archetype with an agent as its architect:

One requirement makes the whole archetype possible, and it points directly at the next two lessons: the planner needs a plan language — rich enough to express real workflows (stages, conditions, rules), bounded enough that the steward can audit what any plan could possibly do. Designing that language is its own discipline, and it's where we go next.