Open Source

Centurion

Resource-aware orchestration for AI agent fleets

Spawn, schedule, and manage 100+ AI agents with hardware-aware admission control. The infrastructure layer that Claude Code doesn't have.

100+
Agents
HW-Aware
Scheduling
5
Integrations
382
Tests
How It Works

Three-layer architecture

Layer 1 — Your Application
Raw Agentic Loop

The inner loop built into Claude Code. One agent, one task, sequential execution. No parallelism, no persistent state.

Layer 2 — Claude Code Subagents
Parallel but Unmanaged

Spawns background agents via the Agent tool. Multiple tasks run concurrently, but with zero resource awareness. No scheduling, no backpressure. Can OOM-kill the system.

Layer 3 — Centurion
Managed Fleet Orchestration

Hardware-aware scheduling, admission control with memory-pressure detection, DAG-based task decomposition, real-time event streaming, and auto-scaling. Safe, structured parallel execution at machine scale.

Scheduler
HW-aware
Broadcasting
all / legion / century
Auto-scaling
Optio
Architecture

How Centurion works

Centurion sits between your orchestrator and the agents it spawns. Every agent spawn request passes through hardware-aware admission control — checking RAM, CPU, and memory pressure before allowing execution. The diagram below shows the full request flow.


  ┌─────────────────────────────────────────────────────────────┐
  │                     Orchestrators                        │
  │                                                             │
  │   ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌────────┐ │
  │   │ Claude   │   │ Telegram │   │  REST    │   │  CLI   │ │
  │   │ Code     │   │ Bot      │   │  API     │   │ Pipe   │ │
  │   └────┬─────┘   └────┬─────┘   └────┬─────┘   └───┬────┘ │
  └────────┼──────────────┼──────────────┼─────────────┼───────┘
           │              │              │             │
           └──────────────┴──────┬───────┴─────────────┘
                                 │
                                 ▼
  ┌─────────────────────────────────────────────────────────────┐
  │                Centurion  (localhost:8100)                 │
  │                                                             │
  │   ┌───────────────┐  ┌───────────────┐  ┌───────────────┐  │
  │   │   Hardware    │  │  Admission   │  │   Memory     │  │
  │   │   Monitor     │  │  Control    │  │   Pressure   │  │
  │   │               │  │               │  │   Detector   │  │
  │   │  CPU  RAM     │─▶│  Can this     │─▶│               │  │
  │   │  Thermal      │  │  agent run?   │  │  normal/warn/ │  │
  │   │  Disk         │  │  yes → spawn  │  │  critical     │  │
  │   │               │  │  no  → queue  │  │  → throttle   │  │
  │   └───────────────┘  └───────┬───────┘  └───────────────┘  │
  │                              │                              │
  │   ┌───────────────┐  ┌──────┴────────┐  ┌───────────────┐  │
  │   │   Auto-Scale  │  │  Agent Pool   │  │  Event       │  │
  │   │   (Optio)     │  │               │  │  Stream      │  │
  │   │               │  │  max_agents:  │  │               │  │
  │   │  Scale up/    │◀─│  auto from    │─▶│  WebSocket    │  │
  │   │  down based   │  │  hardware     │  │  real-time    │  │
  │   │  on demand    │  │  probing      │  │  status       │  │
  │   └───────────────┘  └───────┬───────┘  └───────────────┘  │
  └──────────────────────────────┼──────────────────────────────┘
                                 │
                                 ▼
  ┌─────────────────────────────────────────────────────────────┐
  │                      Agent Fleet                          │
  │                                                             │
  │   ┌──────────┐   ┌──────────┐   ┌──────────┐              │
  │   │ Agent 1  │   │ Agent 2  │   │ Agent N  │    ...       │
  │   │ (claude) │   │ (claude) │   │ (shell)  │              │
  │   └──────────┘   └──────────┘   └──────────┘              │
  └─────────────────────────────────────────────────────────────┘
Integrations

Multiple ways to connect

Centurion adapts to your stack. Run it as a standalone CLI, embed it as a library, or deploy it behind its REST API. Each integration mode exposes the same scheduling and admission-control guarantees, so you get identical resource safety whether you are scripting locally or orchestrating from a CI pipeline.

Centurion integration modes component diagram showing CLI, library, and REST API connection options
The Problem

Why Centurion

Claude Code has zero resource management. No RAM awareness, no parallel agent limits, no memory pressure detection. Spawning 20+ subagents on a constrained machine can OOM-kill the entire system. A community request for maxParallelAgents (#15487) was closed NOT_PLANNED — Anthropic views resource scheduling as outside their application boundary.

Centurion fills this permanent gap. It operates at the infrastructure layer: probing hardware, enforcing admission control before every agent spawn, detecting memory pressure in real time, and scaling fleets automatically. It is model-independent — the same scheduler works for Claude, GPT, Gemini, or shell scripts.

Success Stories

Real Projects, Verified Metrics

Every number below comes from actual project history — task counts, test results, and commit logs.

Success Story 01 8 PRs ~30 min

OpenClaw Bug Fixes

An open-source Rust project had a backlog of bugs. Centurion decomposed them into a task DAG with parallel engineering tasks, each gated by QA. Progressive ramp-up scaled from 1 to 4 agents safely.

8 pull requests merged in a single 30-minute session
Ramp-up
1→2→4 agents
Test Suite
7,000+ tests
Memory
0 incidents
Mode
Auto-scheduled

What Centurion Did

Decomposed the bug backlog into a task DAG — architecture phase for issue triage, parallel engineering tasks for fixes, and QA gates before PR submission. Hardware-aware scheduling ran the full Rust test suite (7,000+ cases) per PR without OOM kills. When memory pressure hit “warn” during concurrent test runs, auto-throttled batch size and resumed once pressure normalized.

Quick Start

Up and running in three steps

From zero to orchestrating AI agents in under a minute.

1

Install

$ pip install centurion

Installs Centurion with hardware-aware scheduling.

2

Launch

$ centurion quickstart

Centurion detects your hardware and configures itself automatically.

HARDWARE SUMMARY Platform: Darwin | CPU: 10 cores | RAM: 32 GB RECOMMENDED CONFIGURATION Agent type: claude_cli | Max agents: 20 Centurion is ONLINE [quickstart mode] Health: http://localhost:8100/health ✓
3

Use

# Check system status: curl http://localhost:8100/api/centurion/status # Or install as a LaunchAgent (auto-restart on boot): ./scripts/install-launchd.sh

Comparison

How Centurion Compares

Claude Code ships without infrastructure-level process management. Centurion fills that gap.

Feature Raw Agentic Loop Claude Code Subagents Centurion
Parallel agents 1 Unlimited (unmanaged) 100+ (managed)
Memory awareness ✗ None ✗ None ✓ RAM/CPU probing
Scheduling ✗ None ✗ None ✓ HW-aware admission
Memory safety N/A ✗ OOM risk ✓ Pressure detection
Task decomposition Manual Manual ✓ Automatic DAG
State persistence In-memory ✗ None ✓ .harness/ + SQLite
Cross-project ✗ No ✗ No ✓ Yes
Auto-scaling ✗ No ✗ No ✓ Yes (Optio)
Broadcasting ✗ No ✗ No ✓ Yes
Circuit breaker ✗ No ✗ No ✓ Yes

Evidence

Don't take our word for it

These are open GitHub issues and discussions filed by users running Claude Code at scale. The memory management gap is well-documented.

Issue #4953

Memory leak — process grows to 120+ GB

Long-running Claude Code sessions accumulate memory without bound, eventually consuming all available RAM on the host machine.

Issue #15487

maxParallelAgents — closed NOT_PLANNED

A request for configurable parallel agent limits was closed as NOT_PLANNED, confirming this is outside Anthropic's intended scope for Claude Code.

Issue #22188

93 GB heap crash

A single Claude Code session crashed after its heap grew to 93 GB, taking down co-located processes and requiring a hard restart.

Issue #21403

16 GB RSS on Linux

On Linux workstations, a single agent session reaches 16 GB RSS, making multi-agent workflows impractical without external resource management.

Position

Infrastructure, not intelligence

Centurion operates at the infrastructure level. It does not modify prompts, intercept API calls, or depend on any specific model provider. When Anthropic closed #15487 as NOT_PLANNED, it drew a clear boundary: Claude Code is a single-agent tool, and resource orchestration is out of scope. Centurion exists on the other side of that boundary — managing processes, memory, scheduling, and state so that any agentic coding tool can run reliably at scale.