Solving Super Agentic Planning

It's coincidental that Anthropic also published recently on similar finds and approaches on multi agent orchestration and memory management https://www.anthropic.com/engineering/built-multi-agent-rese...

Manus and GenSpark showed the importance of giving AI Agents access to an array of tools that are themselves agents, such as browser agent, CLI agent or slides agent. Users found it super useful to just input some text and the agent figures out a plan and orchestrates execution.

But even these approaches face limitations as after a certain number of steps the AI Agent starts to lose context, repeat steps, or just go completely off the rails.

At rtrvr ai, we're building an AI Web Agent Chrome Extension that orchestrates complex workflows across multiple browser tabs. We followed the Manus approach of setting up a planner agent that calls abstracted sub-agents to handle browser actions, generating Sheets with scraped data, or crawling through pages of a website.

But we also hit this limit of the planner losing competence after 5 or so minutes.

After a lot of trial and error, we found a combination of three techniques that pushed our agent's independent execution time from ~5 minutes to over 30 minutes. I wanted to share them here to see what you all think.

We saw the key challenge of AI Agents is to efficiently encode/discretize the State-Action Space of an environment. Building on this insight, we setup:

Smarter Orchestration: Instead of a monolithic planning agent with all the context, we moved to a hierarchical model. The high-level "orchestrator" agent manages the overall goal but delegates execution and context to specialized sub-agents. It intelligently passes only the necessary context to each sub-agent preventing confusion for sub-agents, and the planning agent itself isn't dumped with the entire context of each step.

Abstracted Planning: We reworked our planner to generate as abstract as possible goal for a step and fully delegates to the specialized sub-agent. This necessarily involved making the sub-agents more generalized to handle ambiguity and additional possible actions. Minimizing the planning calls themselves seemed to be the most obvious way to get the agent to run longer.

Agentic Memory Management: In aiming to reduce context for the planner, we encoded the contexts for each step as variables that the planner can assign as parameters to subsequent steps. So instead of hoping the planner remembers a piece of data from step 2 to reuse in step 7, it will just assign step2.sheetOutput. This removes the need to dump outputs into the planners context thereby preventing context window bloat and confusion.

This is what we found useful but I'm super curious to hear:

How are you all tackling long-horizon planning and context drift?

Are you using similar hierarchical planning or memory management techniques?

What's the longest you've seen an agent run reliably, and what was the key breakthrough?