The Focus Problem
AI capability is often framed as Memory × Reasoning. The industry is racing to improve both: RAG systems and expanding context windows tackle memory, while chain-of-thought and models like o1 enhance reasoning.
But there's a third dimension that's largely unnamed: Focus.
Focus is the ability to maintain coherent, goal-directed attention on the right information at the right time. Unlike memory (which is about capacity) or reasoning (which is about capability), focus is about sustained attention quality.
Humans understand this intuitively. You can have access to all the information in the world (memory) and be brilliant at problem-solving (reasoning), but without focus, you accomplish nothing. The same is true for AI agents.
What is Focus Persistence?
Focus persistence is the ability to maintain optimal attention across arbitrary timelines. For AI agents, this means staying within the 50-150k token "sweet spot" indefinitely, regardless of project duration.
Traditional approaches fail because they conflate memory (context window size) with focus (attention quality). A 1M token context window doesn't give you more focus - it just means more information competing for attention.
Agent Focus solves this through intelligent relay: agents hand off before degradation, with knowledge refined (not just accumulated) at each transition.
Owning "Focus" in AI
The AI industry uses many cognitive metaphors: thinking, reasoning, memory, learning. But "focus" remains largely unclaimed territory.
This is surprising given how fundamental it is. Every practitioner who's worked with AI agents for extended periods has experienced the degradation problem. Yet there's no widely-adopted term for it.
Agent Focus names this capability explicitly. Not as a feature, but as a category. Just as "version control" became fundamental to software development, we believe "focus persistence" will become fundamental to AI agent coordination.
Core Design Decisions
File-based, Not Database-driven
Everything is Markdown, YAML, and JSON. This makes Agent Focus transparent, debuggable, and naturally version-controlled. You can grep your agent's knowledge. You can diff handoffs. You can see exactly what happened.
Progressive Disclosure Over Front-loading
Rather than loading all available context upfront, Agent Focus uses progressive disclosure. Agents get knowledge first, session logs if needed, and full transcripts only when necessary. This keeps initial context lean and focused.
Refinement Over Accumulation
Each handoff is an opportunity to compress and improve knowledge. Session 10's handoff.md isn't 10x larger than session 1's - it's often the same size or smaller, but dramatically higher quality.
Queryable Past, Not Just Archived
Past sessions aren't dead archives. They're dormant agents that can be woken to answer questions about decisions they made. This preserves institutional memory while keeping current context lean.
How This Compares to Other Approaches
Bigger context windows: Adding more capacity doesn't solve degradation. A 1M token window doesn't maintain focus better than a 200k window - it just takes longer to degrade.
Simple checkpointing: Some systems save progress between sessions but don't refine knowledge. They accumulate rather than compress, leading to bloated context.
Single long-running agents: Works for simple tasks but fails on complex projects that exceed the sweet spot. Quality inevitably degrades.
Agent Focus is designed specifically for the reality that complex work takes longer than optimal attention spans. That's true for humans, and it's true for AI agents.
What's Next
Agent Focus is open source and actively developed. We're exploring:
- Automated quality monitoring and handoff triggers
- Cross-project knowledge sharing
- Team collaboration patterns
- Integration with other AI agent frameworks
If you're working on long-running AI agent projects, we'd love to hear about your experience.