Weco AI’s AIDE² System Achieves Level 1 Recursive Self-Improvement: Here’s What Actually Happened

Weco AI’s outer-loop agent improved its inner research agent 8 times over 100 unattended steps, beating a two-year manually-tuned baseline by 16.4% on held-out benchmarks. This isn’t another “AI writes better prompts” story — it’s an agent rewriting another agent’s code autonomously.

Let me explain why this matters for production systems.

The Technical Achievement

Weco AI demonstrated what they’re calling Level 1 Recursive Self-Improvement (RSI) with their AIDE² system. Here’s the setup: they built an outer-loop agent whose job is to improve an inner-loop research agent. The outer agent modifies the inner agent’s code, evaluates performance, then iterates.

The key numbers:

• 8 successive improvements over 100 steps
• 16.4% performance gain over human baseline
• 7 days of autonomous operation
• Fixed compute budget per evaluation

What makes this different from previous attempts? The outer agent isn’t just tweaking hyperparameters or prompts. It’s rewriting actual code — modifying the research strategy, changing evaluation metrics, and adjusting the agent’s decision-making logic.

# Simplified representation of the loop
outer_agent = AIAgent(role="improver")
inner_agent = AIAgent(role="researcher")

for step in range(100):
    # Outer agent analyzes inner agent's performance
    performance = evaluate(inner_agent)
    
    # Outer agent generates code modifications
    modifications = outer_agent.generate_improvements(
        inner_agent.source_code,
        performance_metrics
    )
    
    # Apply modifications and test
    inner_agent = apply_modifications(inner_agent, modifications)

The system cleared four specific criteria Weco set for Level 1 RSI:

1. A fair human baseline (their AIDEhuman system, tuned over 2 years)
2. Sustained multi-step improvement trend
3. Generalization beyond optimized measurements
4. Fixed physical budget constraints
5. Analyzes failure patterns in the inner agent’s outputs
6. Identifies systematic biases or inefficiencies
7. Generates targeted code modifications
8. Tests modifications on held-out validation sets
9. Rolls back changes that decrease performance
10. Autonomous code generation that works: Not templates or boilerplate, but functional modifications to complex systems.
11. Sustained improvement over time: Not a one-shot optimization but consistent gains over 100+ iterations.
12. Generalization beyond training: Performance gains on benchmarks the system wasn’t explicitly optimizing for.

This isn’t AGI or even close to it. It’s a narrow tool that’s very good at a specific task: improving AI research agents within defined constraints.

The Bottom Line

Weco’s AIDE² represents real progress in autonomous agent improvement, but it’s not ready for production deployment outside research environments. The compute costs, safety requirements, and limited scope make it impractical for most use cases today.

What it does prove: agents can meaningfully improve other agents without human intervention, given enough constraints and compute. That’s a building block for more sophisticated automation, not a complete solution.

For now, treat this as a research milestone, not a production tool. But start thinking about how your architectures need to evolve to accommodate agents that modify themselves. Because in 2-3 years, this won’t be research — it’ll be table stakes for competitive AI systems.

The real question isn’t whether self-improving agents will become standard. It’s whether we’ll maintain enough understanding of our own systems when they do.