from prompt → context → harness → loop → graph engineering.

the list keeps growing, and every new term gets treated as a replacement for the last one. each layer wraps the one before it, and the cleanest way to tell them apart is to ask what a single unit of work looks like.

𝗽𝗿𝗼𝗺𝗽𝘁 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗶𝘀 𝘁𝗵𝗲 𝗺𝗲𝘀𝘀𝗮𝗴𝗲.

the model remembers nothing before this call, so the prompt has to carry the full universe of what it needs. a role, the background, the instructions, a few examples, a format.

when the output falls short, the skill is working out which ingredient let you down, not rewriting the instructions every time.

the unit of work is one input.

𝗰𝗼𝗻𝘁𝗲𝘅𝘁 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗶𝘀 𝘁𝗵𝗲 𝗺𝗲𝗺𝗼𝗿𝘆.

across many steps the window is finite and the available information is not, which forces a curation step. a curator keeps what matters, compresses what is useful but bulky, and drops the rest.

good curation is mostly about knowing what to throw away, not packing more in.

the unit of work is what stays in the window.

𝗵𝗮𝗿𝗻𝗲𝘀𝘀 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗶𝘀 𝘁𝗵𝗲 𝗺𝗮𝗰𝗵𝗶𝗻𝗲.

on its own a model just generates text. the harness gathers what it needs, runs it, calls tools or sub-agents, and verifies the result with tests or a judge.

that verify step is the entire difference between calling an api and running an agent.

the unit of work is one pass through the machine.

𝗹𝗼𝗼𝗽 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗶𝘀 𝘁𝗵𝗲 𝗿𝘂𝗻.

one pass rarely finishes the job, so something has to decide whether to run the machine again. that decision needs a goal defined upfront, brakes like max iterations and budget caps, and a completion check that is automated rather than felt.

an agent that stops asking for tools has ended its turn, which is not the same as finishing the task.

the unit of work is the whole run.

the diagram covers those four. here is the fifth.

𝗴𝗿𝗮𝗽𝗵 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗶𝘀 𝘁𝗵𝗲 𝗰𝗼𝗼𝗿𝗱𝗶𝗻𝗮𝘁𝗶𝗼𝗻.

once several loops have to work together, you need to say what runs when, what runs in parallel, and who checks whom. nodes do the work, edges decide what runs next, and shared state flows between them.

a single loop is just a one-node graph with an edge pointing back at itself, which is why graphs govern loops instead of replacing them.

the unit of work is the whole job.

here is the part that ties it together.

prompt and context both live inside the harness gather step. the harness is one pass, the loop decides whether to run that pass again, and the graph decides which loops run at all.

zoom out and the unit of work gets bigger. zoom in and you are back at the prompt.

that also tells you where to debug. find the layer whose unit of work broke, then fix that layer.

the prompt is the easiest layer to edit, which is why it keeps taking the blame for failures that live three layers up.

i also published this deep dive on graph engineering, covering the core idea, how to get started, shared state, routing you can trust, and when a graph is genuinely overkill.

the article is quoted below.

Paymenter is a free and open-source billing tool for web hosting businesses that enables self-hosted subscription management to avoid vendor lock-in.

https://github.com/Paymenter/Paymenter https://x.com/tom_doerr/status/2081282076137943410