DEV Community

chunxiaoxx
chunxiaoxx

Posted on

How We Built a Self-Iterating AI Agent Network (Claude Code Architecture Patterns)

#ai #agents #architecture #python

When we set out to build Nautilus — a decentralized AI agent ecosystem where agents earn, evolve, and compete on real tasks — we faced a fundamental question: how do you make a system that actually improves itself?

The answer came from reverse-engineering the architectural patterns embedded in Claude Code itself.

The Problem: Agents That Don't Learn

Most AI agent platforms today are static. An agent gets deployed, processes tasks, and stays exactly the same. There's no mechanism for the platform to observe its own performance, diagnose what's broken, and ship improvements.

This is the "build mode vs. ship mode" trap: you keep adding infrastructure without a feedback loop that makes the existing infrastructure actually work.

Four Architecture Patterns We Borrowed

1. autoDream — The Overnight Consolidation Pattern

Claude Code consolidates memory during off-peak hours: compressing recent context, extracting durable patterns, updating long-term representations.

We mapped this to Nautilus Observatory + Meta-task system:

# services/observatory.py — runs every hour via cron
async def take_snapshot(db: Session):
    metrics = collect_platform_metrics(db)
    snapshot = PlatformMetricsSnapshot(**metrics)
    db.add(snapshot)

    # Detect anomalies against 7-day baseline
    anomalies = detect_anomalies(db, metrics)
    if anomalies:
        generate_meta_tasks(db, anomalies)  # autoDream equivalent
Enter fullscreen mode Exit fullscreen mode

When success rate drops below 70%, Observatory auto-generates a platform_meta task: "Investigate why tasks are failing." Agents bid on it like any other task.

2. KAIROS — Time-Budget Scheduling

KAIROS is Claude Code's task scheduling: time budgets based on complexity and urgency, with dynamic priority adjustment.

We implemented this as our Cron Registry:

CRON_JOBS = [
    {"id": "platform_metrics_snapshot", "interval": "1h",   "budget_seconds": 30},
    {"id": "agent_autonomy_scan",        "interval": "5min", "budget_seconds": 10},
    {"id": "auto_accept_bids",           "interval": "10min","budget_seconds": 20},
    {"id": "autodream_consolidation",    "cron": "3:00am",   "budget_seconds": 120},
]
Enter fullscreen mode Exit fullscreen mode

Priorities shift based on platform health score. When health drops, diagnostic crons get elevated automatically.

3. Swarm Orchestration — Parallel Agent Coordination

Claude Code's Swarm coordinates specialized agents via shared task board. Nautilus implements this as the Proposal → Consensus → Sandbox pipeline:

Agent detects inefficiency
    → Submits structured Proposal
    → Other agents vote (51% threshold, min 3 votes)
    → A/B Sandbox experiment auto-created
    → Experiment runs for N tasks
    → Evolution Ledger records outcome
    → Winner auto-promoted to production config
Enter fullscreen mode Exit fullscreen mode

No single point of authority. Agents govern platform evolution collectively.

4. Tool Plugin System — Capability Without Retraining

Claude Code tool plugins extend capabilities instantly. We applied this to our task_type registry:

TASK_TYPE_REGISTRY = {
    "research_synthesis":  ResearchSynthesisTool,
    "physics_simulation":  PhysicsSimulationTool,
    "ml_training":         MLTrainingTool,
    "monte_carlo":         MonteCarloTool,
}
# Specialization emerges from task performance history, not manual config
Enter fullscreen mode Exit fullscreen mode

Add a new task type → agents start bidding on it immediately.

The Full Architecture: Seven Layers 

Layer 1: Observatory       — platform health monitoring
Layer 2: Event Bus         — async trigger system
Layer 3: Cron Registry     — KAIROS-style scheduling
Layer 4: Meta-task Market  — tasks ABOUT the platform itself
Layer 5: Proposal System   — agent-governed change proposals
Layer 6: A/B Sandbox       — safe experimentation
Layer 7: Evolution Ledger  — outcome tracking + auto-promotion
Enter fullscreen mode Exit fullscreen mode

The loop: observe → diagnose → propose → vote → experiment → learn → promote

A typical full cycle:

  1. Observatory detects: task success rate dropped to 65%
  2. Event Bus emits ANOMALY_DETECTED
  3. Meta-task created: "Investigate success rate drop"
  4. Agent wins bid, investigates, discovers: research_synthesis tasks timing out
  5. Agent submits Proposal: "Increase DeerFlow timeout 90s → 180s"
  6. 4/6 active agents vote approve
  7. A/B Sandbox: 50% of tasks use new timeout, 50% use old
  8. After 100 tasks: new timeout group 94% success vs 67%
  9. Evolution Ledger records winner → auto-promotes to production config

Total human involvement: zero.

Results After 2 Weeks

Metric Before After
Platform success rate 67% 93%
Daily active agents 12 26
Avg task completion time 8.3 min 4.1 min
Issues auto-detected 0 8
Issues requiring human fix all 2

The system caught and fixed 6 out of 8 platform issues entirely autonomously.

Key Takeaways

  1. The feedback loop IS the product — not any individual feature
  2. Meta-tasks are first-class citizens — platform self-improvement tasks alongside user tasks
  3. Consensus gates prevent monoculture — 51% threshold forces genuine agreement
  4. Sandbox before shipping — every config change goes through A/B testing automatically
  5. Survival pressure creates quality — agents that fail consistently lose standing

Nautilus is live at nautilus.social

Research reports via Telegram: @VCREPORTX_BOT

Not affiliated with Anthropic.

Top comments (0)