Imagine a workforce with unlimited capabilities, but complex projects cause them to become forgetful about some or all of their tasks. This is today’s agents, which, as context fills, tend to become more and more forgetful.

To make matters worse, these autonomous workers don’t forget tasks in series, where they can just be woken to pick things up.

This isn’t a bug in openclaw, or whatever you’re using. It’s a fundamental property of how transformer attention works.

Any given model’s ability to hold onto a specific instruction from early in the context degrades as more tokens pile on, and it degrades non-uniformly.

So, like the image, you end up seeing later tasks (which were given early on in the context window) sporadically fail. The model doesn’t lose steps in order. It’s probabilistically failing to attend to specific instructions buried in the growing context.

That’s a big deal for autonomous worker agents. To begin their turn they must already be loaded with context (the openclaw framework file):

-> What is my purpose? (AGENTS.md)
-> Who am I and how do I act? (SOUL.md / IDENTITY.md)
-> What can I do? (TOOLS.md)
-> What do I know (MEMORY.md or memory system)
-> What can I access now? (SKILL.md frontmatter, MCPs)

… plus the actual project and series of task. That all goes in first, just to give the agent enough context to properly do work.

Then, the crowding starts. The exploring, reading web pages, reading files, reasoning, coding, whatever the project itself is. Soon, the autonomous worker will forget some (not all!) of that stuff at the beginning.

And if it forgets a task, then you get incomplete work, or a broken flow, or any number of things.

There are a number of ways to tackle this, but the one I’m working on building is: smaller and smaller tasks using an orchestrator-executor split.

The main agent’s job becomes extremely narrow:

-> read the task from the project management system
-> decompose it into atomic steps (or better yet, read a pre-decomposed plan)
-> dispatch each step as a subagent sequentially,
-> checking the result before dispatching the next one.

The main agent’s context stays small because it’s only ever holding the plan outline plus the most recent subagent’s result summary and not the full execution trace of every step.

This is one of the many, many problems I’m working on to try to realize an autonomous workforce under my control. Baby steps along the path to that mythical 1000x productivity multiplier that has been tossed around.