Anthropic Agents That Run for Days: What's Real

A wave of posts this month claims "Anthropic engineers showed how to build agents that run for days with graph engineering." The workshop behind those posts is real, and worth an hour of any builder's time. The graph engineering part is not: the word "graph" appears zero times in the 75-minute transcript. Re-upload channels grafted the trending vocabulary onto it, in at least one case adding a quote that appears nowhere in the transcript and carries no source.

The Receipts

The real thing: "Anthropic Workshop: Build Agents That Run for Hours," by Ash Prabaker and Andrew Wilson, both Anthropic applied-AI engineers, at the AI Engineer conference. Uploaded 2026-05-18, 94,958 views at our check on 2026-08-24. It is a harness talk: how to structure the scaffolding around a model so an agent keeps producing good work over long runs.

The wave: re-uploads and clip channels recut the workshop under graph engineering titles. The largest we found, at 27.9k views, retitles it "Loop Engineering to Graph Engineering." Another re-upload, titled to put graph engineering in the workshop's mouth, states in its description, without a source: "More than 30% of our code is already written by agentic graphs." That sentence is not in the transcript. The closest real line is secondhand: Wilson quotes a Boris Cherny post from Claude Code's one-year anniversary, that almost all of Claude Code is now written by Claude Code and that it "can run effectively for days at a time." Cherny's line is about the product and its harness, and says nothing about graphs.

If you came here from one of those posts searching for the graph course or guide they imply: there is no Anthropic graph engineering guide, the same way there is no Google graph engineering course. What exists is better documented and less catchy: a workshop on long-running harnesses, and an engineering essay on multi-context handoffs and persistent progress artifacts.

What the Workshop Actually Teaches

The workshop's central claims are:

The time-horizon curve. With a minimal scaffold and a 50% task-completion bar, the presenters chart an earlier model generation at about one hour of effective runtime and the newest at about twelve hours, one year apart. They describe roughly thirty-hour runs with their full harness, cheap mass sub-agents making parallel work economical, and a division of labor pattern: the strongest model plans, a fast workhorse model executes.

Self-evaluation is a trap. The workshop's core pattern is a generator/evaluator pair in separate context windows, with the evaluator under instructions to break the output rather than bless it. Crucially, their evaluator does not read diffs: it drives a browser and actually uses what was built. Their demo receipt: a one-shot "build a retro game maker" looked finished, but the arrow keys and spacebar did nothing; the same prompt with the adversarial evaluator in the loop shipped a working game. If you have read our evaluation guide, this is the same argument from inside Anthropic: the agent that built the thing is the wrong agent to judge it.

Compaction is not coherence. Long runs die by context, and the workshop is blunt that lossy summarization drifts: an agent working from summaries of summaries slowly forgets what done means. Their answer is structured handoffs, fresh contexts that receive an explicit, structured brief rather than a compressed history.

Taste is gradeable. The workshop puts it this way: "most people say you can't grade taste. We think you can if you have a strong enough opinion and write it down." Their demo grades output on a written rubric, design, originality, craft, functionality, weighted toward design. That claim is the entire premise of putting quality gates in front of unattended work.

The summary slide. Five takeaways, verbatim in spirit: self-evaluation is a trap, use an adversarial evaluator; compaction is not coherence; structured handoffs and clean contexts win; subjective quality is gradeable; read the traces and prune the scaffold as models improve. Separately, just before the slide, they note that grading rubrics package well as skills.

They are equally clear about what is unsolved. For multi-agent traceability, their current best method is still reading traces by hand, sometimes with a Claude-assisted first pass. For what artifacts should persist when an agent returns to something days or weeks later, they say it is something they are working on.

The workshop's whole first half is the discipline our Loop Engineering course teaches as the verifier: one agent, a written bar, an evaluator that is not the builder, run until the check passes. If you want the twelve-hour curve instead of the one-hour one, that is the skill that moves you along it.

Where Graphs Actually Enter

The re-uploads are wrong about the source, but they are pattern-matching something real: the workshop's structured handoffs between clean contexts are, in graph vocabulary, edges between nodes, and its generator/evaluator pair is a two-node topology with an adversarial edge. The workshop simply never needs the word, because its subject is making one node strong: a single long-running agent whose harness keeps it honest.

That ordering matters more than the vocabulary. A graph of weak nodes is a slop multiplier, which is why our own graph checklist starts at the node, and why the strongest video in the graph wave, AI LABS' 72.5k-view breakdown of Anthropic's shipped verification skills, lands on the same point from the other side: it compares the same review skill run on a fast model versus a strong one, and finds the fast model confidently flagging intentional choices as defects. Their conclusion and the workshop's are one sentence apart: the node that does the judging is the last place to save tokens.

The sequence for a builder chasing the "runs for days" result: write the bar down, split builder from evaluator, structure the handoffs, and only then wire nodes into a graph when one agent genuinely is not enough.

Related Content

• Graph Engineering Guide (2026) - The pillar: nodes, edges, shared state, and when a graph earns its complexity.
• Google Graph Engineering - The sibling debunk: the "free Google graph engineering course" claim, and what Google actually ships in ADK 2.0.
• How to Evaluate AI Agents - The workshop's self-evaluation-is-a-trap argument as a build guide: gates that do not drift.
• Loop Engineering: Stop Writing Prompts, Start Writing Verifiers - The single-node discipline the workshop spends its first half on, end to end.
• Harness: The 6 Components - The scaffolding vocabulary for everything the workshop configures around the model.

Join AI Builder Club