Hi, I'm Lena. I kept seeing "agent workflow memory" come up in builder conversations. Not as a product name, but as a problem people were trying to describe. So I went looking for the research behind it.
This is what I noticed when I read through it.
First, Verify the Paper
Exact title, authors, venue, year, and official link
The paper is titled "Agent Workflow* Memory", authored by Zora Zhiruo Wang, Jiayuan Mao, Daniel Fried, and Graham Neubig from Carnegie Mellon University and MIT. It was first posted on arXiv in September 2024 and accepted as a poster at ICML 2025. The full text, code, and benchmark data are available through the official GitHub repository.
I want to be clear about this because "agent workflow memory" as a phrase gets used loosely. People attach it to any agent memory feature. This paper is doing something more specific than that.
What not to assume from the keyword alone
The phrase sounds generic enough that you might think it covers all forms of agent memory — conversation logs, RAG retrieval, user preferences. It doesn't. AWM is specifically about extracting reusable task routines from successful action sequences and feeding them back to the agent for future tasks.
…I had to read the abstract twice before that distinction clicked.
The Problem the Paper Tries to Solve
Why agents repeat workflow mistakes
Here's the part that made me stop and think. Current agents treat every task independently. An agent that successfully books a flight on Monday doesn't carry that knowledge to Tuesday. It starts over. Every time.
The paper frames this clearly: agents "fail to grasp the key to disentangling increasingly complex tasks — to extract and learn reusable task workflows shared across similar tasks." They don't generalize from their own successes. They don't build a library of moves. They just… do each thing fresh.
Why chat history is not enough
I think a lot of builders assume that if you keep the conversation history, you have memory. The AWM paper challenges that assumption directly. Raw action trajectories are too specific. They contain environment details, element IDs, page states — things that don't transfer across contexts. What transfers is the routine, not the raw log.
This is a distinction I didn't fully appreciate until I saw the benchmark results. Agents with full trajectory access still failed on tasks that required the same underlying steps in a different environment. The memory was there. It just wasn't in a usable shape.
The Core Idea in Plain English
What gets stored
AWM extracts workflows — abstract descriptions of common sub-routines that appear across multiple tasks. Each workflow has a goal (what it accomplishes) and a routine (the general steps). Think of it less like saving a recording and more like writing down a recipe after cooking the same dish several times.
What gets retrieved
When the agent encounters a new task, AWM checks whether any previously induced workflows are relevant. The selection is task-driven — it doesn't dump all workflows into context. Only the ones that match the current goal get loaded. This is important because context window space is finite, and irrelevant workflows are noise.
What gets reused
The reused workflows act as high-level guidance during action generation. The agent still makes its own decisions at each step, but the workflow tells it the general shape of the solution. On WebArena, a benchmark for realistic web navigation tasks, this led to a 51.1% relative improvement in success rate. On Mind2Web, the dataset covering 2,000+ tasks across 137 real websites, the improvement was 24.6%.
…that's a bit unexpected. Not because the numbers are high, but because the gains came from such a structurally simple intervention.
Implementation Pattern for Builders
I'm not going to pretend this is a tutorial. But if you're building agents and this paper interests you, here's how the core pattern works.
Memory capture
AWM watches agent trajectories — the full sequence of actions taken during task execution. In the offline setting, it processes annotated training examples. In the online setting, it induces workflows from the agent's own test-time experiences, with no pre-existing examples required. This dual-mode design echoes a broader trend in agent memory research — systems that learn from both historical data and live experience.
Workflow trace selection
Not every trajectory is worth learning from. AWM extracts workflows by identifying repeated sub-routines across multiple successful trajectories. The extraction can be rule-based or LLM-based. The LLM-based approach performed better in the paper's experiments, which makes sense — routines don't always look syntactically identical even when they're doing the same thing.
Retrieval conditions
Workflows are retrieved based on goal similarity to the current task. The agent doesn't search through workflows by keyword. It matches the high-level objective. This means a workflow learned from booking a hotel can potentially help with booking a restaurant if the underlying interaction pattern is similar.
Validation before reuse
Here's where I paused. The paper doesn't describe a formal validation step for reused workflows. The workflows are treated as guidance, not as verified programs. If a workflow is outdated, wrong, or irrelevant, the agent may still follow it. The paper acknowledges this — dynamic environment changes can make previously useful workflow actions fail.
I'm not sure how much weight to put on that limitation. But it's worth noticing.
Where This Differs from Existing Tools
Cursor, Claude, memory layers, and workflow traces
If you're using Cursor, you've probably noticed its memory features — Rules, the Memories tool in Automations, and community-built solutions like cursormemory that persist context across sessions. These are useful, but they store preferences and patterns, not abstracted task routines. They remember what you like, not how to solve a class of problems.
Claude's own memory system works similarly — it retains user-level context, not workflow-level abstractions.
AWM operates at a different layer. It doesn't remember your coding style or your project structure. It remembers the shape of successful task execution and offers that shape to the agent next time a similar task appears. That's a meaningfully different kind of memory.
The gap I keep noticing across all these tools: none of them currently let agents share what they've learned with other agents. One agent learns, and only that agent benefits. The workflow stays local.
What the Paper Does Not Solve
Stale memory, poor trace quality, cross-task transfer, governance
I spent a while sitting with this section. The paper is honest about its limits, which I respect.
Stale memory. Websites change. A workflow for navigating a checkout page in January may not work in June. AWM has no built-in mechanism for expiring or updating workflows. Once a workflow is induced, it stays as-is until the system is retrained or the workflow library is manually pruned.
Poor trace quality. If the training trajectories are noisy or contain errors, the induced workflows inherit those problems. Garbage in, slightly-more-organized garbage out.
Cross-task transfer. AWM generalizes well within similar task types — cross-website and even cross-domain performance improved by 8.9 to 14.0 absolute points over baselines. But there's no evidence it can transfer a workflow from, say, web navigation to code debugging. The abstraction works within a task family, not across fundamentally different domains.
Governance. Who decides which workflows are trustworthy? In a single-agent system, this is manageable. In a multi-agent system, it becomes a real question. The paper doesn't address workflow verification, quality scoring, or access control. It doesn't need to — that's not its scope. But if you're thinking about deploying this pattern in production, you'll need answers the paper doesn't give you.
…this is the part I keep coming back to. The paper solves the induction problem well. The management problem — what happens after you have hundreds of workflows across dozens of agents — is still wide open.
FAQ
What is the Agent Workflow Memory ICML paper about?
A method for extracting reusable task routines from agent action sequences and selectively reusing them in future tasks. Published at ICML 2025 by CMU and MIT researchers. The full paper is on arXiv.
Why does the ICML paper matter for building agentic workflows in 2026?
Because agents repeating solved problems instead of learning from them is the single biggest efficiency drain in production systems. AWM offers a concrete pattern for fixing that.
How does the paper's approach to memory work in real agent workflows?
AWM induces abstract workflows from successful trajectories, stores them, and retrieves relevant ones when a similar task appears. It works both with training data (offline) and purely from the agent's own test-time experience (online).
What are the key implementation ideas from the ICML paper?
Workflow induction (extracting reusable routines), selective retrieval (matching by goal similarity), and dual-mode operation (offline with data, online without). The online mode requires zero labeled examples.
What limitations does the ICML paper highlight about agent memory?
Workflow actions can fail when environments change. The paper doesn't address workflow expiration, cross-domain transfer beyond web tasks, or governance of shared workflow libraries.
Should solo developers read and implement this paper right now?
If you're building agents that execute multi-step tasks repeatedly, the core pattern is worth understanding. Even a simpler version — extract what worked, store it, retrieve it next time — can meaningfully reduce error rates and token costs.
Where This Points
I'll be honest — I read this paper expecting a narrow academic exercise. What I found was something closer to a design pattern that production builders are going to need. The question isn't whether agents need workflow memory. They obviously do. The question is what happens at the edges: when workflows go stale, when multiple agents need to share them, when you need to verify that a workflow is still valid before an agent trusts it.
The paper doesn't claim to solve those problems. But it gives the induction layer a clear shape.
…I keep thinking about one specific gap. AWM lets a single agent accumulate workflows over time. But what if that knowledge could propagate? What if one agent's successful repair became a reusable asset for other agents in a network — verified, scored, and inherited through a protocol rather than locked inside one system's context window?
That's not what this paper does. But it's the direction the problem points toward.
If you're building agents that keep re-solving the same class of problems, it might be worth looking at how EvoMap's GEP protocol approaches exactly that gap — turning isolated agent learnings into shared, auditable evolution assets across a network.
I'll keep watching how this space develops.
Previous Posts:
- If workflow memory caught your attention, you’ll probably want to read how EvoSkills: Self‑Evolving Skills Proved explores persistent reusable capabilities instead of one-off agent fixes.
- For a deeper look at why most agents still lose operational knowledge between sessions, Hermes Agent vs EvoMap Agent Memory breaks down the architectural gap between session memory and transferable workflow memory.
- If you're thinking about how workflows, memory, and orchestration layers fit together, OpenHarness and GEP: Agent Stack Layers Explained maps the stack from tools to reusable evolution assets.
- The research discussion here connects naturally with Agent Skills vs GEP Assets: The Real Difference, especially around what agents can actually retain and inherit over time.
- And if the idea of agents repeatedly relearning the same fixes feels painfully familiar, ARC‑AGI‑3 and the Agent Learning Gap (GEP) digs into why current systems still struggle to accumulate durable operational knowledge across tasks and agents.




