Grab the Inside Scoop on How Google, Anthropic, and Manus Built Long-Running AI Agents

Agentic context engineering hinges on one core shift: memory—not a bigger prompt window—is what makes long-running AI agents work reliably. Larger context windows and smarter models have not solved the underlying problem; they often worsen it by letting irrelevant history and tool noise drown out the signals that matter. As tasks stretch into multi-hour loops, performance can drop not because the LLM fails, but because memory construction is naive—stuffing too much into the context and treating “context” as a transcript rather than a computed, task-relevant view.

The blueprint presented centers on treating every LLM call as a fresh projection computed from durable state. Instead of dragging hundreds of turns forward, the system rebuilds a minimal slice: which instructions apply now, which artifacts matter now, and which memories should be surfaced now. That “compiled context” approach is framed as essential for multi-hour autonomy, because it prevents signal dilution and keeps attention focused on what’s relevant at each step.

A second pillar is a tiered memory model that separates storage from presentation. Working context is a minimal per-call view; sessions act like structured event logs across an agent’s trajectory; memory holds durable searchable insights extracted across runs; and artifacts represent large objects referenced by handles or tags rather than pasted into prompts. With this separation, the context window can stay small while the overall memory system grows arbitrarily large—mirroring traditional computer architecture with cache, RAM, and disk.

From there, the guidance becomes operational. Default context should contain nearly nothing; retrieval should be an active decision made when the agent needs information. Long-term memory should be searchable rather than pinned permanently, because relevance-ranked retrieval helps the agent distinguish critical constraints from recent noise. Summarization must be schema-driven and ideally reversible, so multi-step reasoning doesn’t collapse into vague “glossy soup” that erases decision structure and edge-case semantics.

The practical fixes extend beyond memory into system design. Heavy state should be offloaded to tools, file systems, or sandboxes, with pointers passed back instead of raw tool outputs—reducing cognitive burden and keeping context lean. Multi-agent setups should isolate scope using sub-agents (planner, executor, verifier) that communicate through structured artifacts rather than sprawling transcripts, avoiding cross-talk and reasoning drift. Prompt layout should follow caching and prefix stability: stable identity/instructions rarely change, while only the variable suffix (user input and fresh tool outputs) updates, cutting latency and cost.

Finally, the payoff is framed as concrete capabilities unlocked by correct memory architecture: long-horizon autonomy for web browsing and repo audits; self-improving behavior via strategy and instruction updates stored in memory (without weight training); scalable cross-session personalization; multi-agent orchestration without context poisoning; deep reasoning over large corpora by treating repos and PDFs as artifacts; auditable enterprise systems with reconstructible session logs and memory updates; cost-stable operations through sublinear token growth; and domain-specific “agent OS” environments where finance, coding, and medical agents can maintain durable workspaces and risk state.

Common failure modes are also spelled out: dumping everything into prompts, blind summarization, assuming long context windows are unlimited RAM, using prompts as an observability sink, tool bloat, anthropomorphizing agent roles, static prompt configurations that never evolve, over-boxed harnesses, and ignoring caching/prefix discipline. The overall message is tradecraft: there’s no magic bullet—production-grade agents require engineering memory and context as a first-class runtime environment.