# Anthropic Ran 1,000 AI Agents For 8 Days. Yours Still Needs The Same Thing Explained Again.

## Executive summary

Achieving successful, long-running AI agent operations requires moving beyond simply using powerful models. The core challenge is ensuring agents maintain current decisions and context across days of work. This requires treating project information—even non-code data—like code, centralizing it in a structured repository, and implementing disciplined skills and guardrails to prevent versioning errors and collisions in multi-agent systems.

## Key takeaways

- Context is King: Beyond Facts: Successful long runs require passing evolving learning, decisions, and examples to the AI, not just a one-time snapshot of facts. This allows the agent to function as a true thought partner.
- Treat Knowledge as Code: Project information (e.g., client proposals, agreements) must be structured and centralized like code in a repository so that agents can traverse and reference it consistently, preventing versioning errors.
- Scaling Requires Centralized Skills: Skills should not be viewed as individual 'superpowers,' but as centralized, reusable instructions (repo-shaped) that enable any LLM to attack a problem consistently, ensuring team-wide consistency.
- Mitigating Collisions and Race Conditions: In multi-agent environments, structural discipline is needed. This includes using 'separation of concerns' (analogous to forking) to isolate work and using guardrails to enforce role-specific permissions.

## Technical details

- Agentic System Benchmarks: OpenAI reported AI sessions running for hundreds of hours to fix problems in a code management system. Anthropic reported over 1,000 agents working for 8 days to build a prototype operating system. Gemini 4 Carbon has also demonstrated long runs on hard engineering problems.
- Data Structure and Traversal: The solution involves putting data into a central, structured location (a 'repo') that allows the AI to traverse it effectively, similar to how LLMs are trained on verifiable domains like code.
- Role-Based Permissioning: Sophisticated systems can encode expected behavior for different roles (e.g., PM agents vs. Engineer agents) and harden this with guardrails, ensuring agents only have allowed permissions.

## Practical implications

- Start by identifying a task that requires constant correction and providing the AI with current, saved instructions in a fresh chat to test the concept of evolving instructions.
- Shift the focus from individual productivity to team-shaped solutions by centralizing data and skills, which allows for better collaboration and accountability.
- Implement 'separation of concerns' in knowledge work by structuring tasks into specific folders or versions (analogous to forking) to minimize collisions and race conditions.
- Use meta-skills to prompt the agent to alert a human when a conflict (e.g., conflicting deliverables) is detected, facilitating human oversight.

## Topics

AI Agents, LLMs, Multi-Agent Systems, Data Governance, System Architecture, Knowledge Management, Nate's Newsletter, Nate's Library MCP

Source: https://www.youtube.com/watch?v=v5I0nOoqAV4
