Stop writing prompts for Claude. Build a graph that can run itself.
That is the core message Anthropic engineer Lamis delivered at the AI Native DevCon in London — and in under thirty minutes she unpacked a year of the company's internal agent engineering: memory management, workflow orchestration, and a multi-agent review loop the team calls Dreaming. The through-line is a methodology Anthropic calls the agent graph, and it marks the industry's shift from workshop-style prompting to engineered operations. The age of the prompt is fading; the age of graphs and memory is arriving.
Memory: From a Prompt Section to a Filesystem
Lamis opened with a blunt observation: intelligence alone does not compound. The strongest model on earth still has no idea what a finished job looks like inside your organization. Someone has to feed it that knowledge — and the system has to remember it. Anthropic burned through four generations of memory design in a single year, and the arc of that evolution is instructive.
Generation one: CLAUDE.md. A Markdown file that humans can read and agents can write, injected at the top of every session. The results were, in her words, unreasonably effective — it passes organizational knowledge at exactly the right place (the conversation's context) in exactly the right form (natural language). The flaw is unbounded growth: the file keeps getting longer until it bursts the context window.
Generation two: memory tools. Hand the decisions to the agent — when to read, when to write, when to update. Flexibility jumped. So did the noise: agents proved unreliable judges of what deserves remembering, and trivia started crowding out signal.
Generation three: Skills, with progressive disclosure. Lamis's metaphor is a bookshelf: when someone addresses you in French, you pull down the French dictionary — you do not carry seven years of French classes memorized in your head. The agent reads a few summary lines at the top of a file and decides whether to load the rest, which can be arbitrarily deep. Load-on-demand finally broke the context-window bottleneck.
Generation four — where Anthropic has landed: the filesystem as memory. The reasoning is refreshingly unglamorous: agents already know how to browse files and grep for keywords, so index the knowledge well and get out of the way.
Then reality added a new problem nobody had solved at this scale: when thousands of agents mutate one shared memory, whose write wins? One agent's mistake propagates to the entire fleet in an instant. Anthropic's answer is four guardrails:
- Rollback — every write is reversible.
- Collision safety — if someone else committed while you were editing, your version is discarded and redone.
- Permissions — global knowledge is read-only; agents append to their own scratchpads.
- Portability — memory data can be migrated. No lock-in.
An audience member asked the obvious question: isn't this just reinventing the database? Lamis laughed and conceded the point — it is a return to old, boring software engineering principles, rebuilt in a shape agents can use.
Dreaming: Agents Reviewing Themselves at Scale
All four generations address one problem: capturing knowledge while the agent works. Two ceilings remain. Distraction — the agent spends its compute doing the task and writing memory at the same time, and the two compete. Tunnel vision — it only sees what happened in the current session; you can watch it repeat the same mistake across a dozen sessions and it will never notice. Sessions start from a blank slate, and agents running in different environments cannot see each other's scars.
Anthropic's answer is called Dreaming.
The mechanics: after the agents clock out, spin up a dedicated review agent, spread the memory store and a large batch of historical conversations across the table, hunt for places where errors recur, and propose fixes one by one — each with evidence attached (which conversations, how many incidents). Humans make the final call.
Lamis's analogy is a school. Students hand in papers, teachers grade daily — but nobody sees the whole. Then the principal lays out every exam in the building and notices the entire geography class missed the same question. Checking the textbook, she finds the concept was never taught. She adds it to the curriculum, and by the next morning every student knows it.
This sounds like added cost. Lamis says the opposite: once the memory base is clean, agents pass on the first attempt more often, make fewer mistakes, and the total bill goes down. That is what real compounding looks like.
And you do not need to wait for a product. Run it weekly yourself: open a fresh session, hand over the week's conversations, ask the model to surface the places you keep getting stuck, and append the fixes to your CLAUDE.md.
Workflow Graphs: Your Workflow Is Already a Graph — Badly Drawn
Memory handles time: experience accumulating across sessions. Workflow graphs handle structure: within a single task, what order should the steps run in? Alongside the talk came a graph-engineering guide whose thesis fits in one line: your workflow is already a graph. You just drew it badly.
Take the classic chain — research, then summarize, then draft. Three steps in a line, each waiting for the last. But does every step genuinely depend on the one before it?
The key method is the fake-edge test. Interrogate every arrow in the workflow: does this step actually consume the previous step's output? Does data truly flow across that connection? If not, the arrow is fake — and the waiting it imposes is pure waste.
Delete the fake arrows and the most common shape that emerges is the diamond: one step finishes, the flow fans out into several parallel branches, then converges at a merge point. Your wait time becomes the slowest branch, not the sum of all of them. Parallelism carries its own risk, though — a branch producing garbage will smuggle it silently into the final result. So before the merge, add a quality gate: is this output usable? Only usable outputs proceed.
Why This Is a Turning Point
Prompts carry a defect at the root: improvement does not accumulate. You polish a prompt to perfection, it performs beautifully once — and the next task starts from zero. The craftsmanship lives and dies inside a chat window.
Graphs and memory attack exactly that. The graph writes structure into a file, reusable next time. Memory writes experience into files, compounding across sessions. Dreaming lets the AI refill those files itself, without a human babysitting daily. The human role shifts accordingly: from feeding instructions line by line to nodding or shaking your head the next morning.
- For individual developers: this starts in five minutes. Create a CLAUDE.md, define what a finished job looks like, and add one line every time you hit a pit.
- For teams: institute Dreaming — a weekly review of the agents' shared mistakes, with fixes written into the global knowledge base.
- For product builders: workflow graph engineering should be a default platform capability, not an advanced trick buried in docs.
Three Things to Do Right Now
- Create a CLAUDE.md. Five minutes. Write down what "done properly" means for your agent. One line added per pitfall, forever.
- Draw your workflow graph. Sketch your most common multi-step task, run the fake-edge test on every arrow, convert serial chains to diamonds, and add a quality gate before each merge.
- Run one Dreaming session. Friday afternoon: feed the week's agent conversations to a fresh session, ask for the three most common failure patterns, write the fixes into CLAUDE.md.
All three together cost less than half an hour. A month from now, your agent will be considerably smarter than it is today — and unlike a prompt, none of that effort evaporates when the session ends.