Build Multi-Agent Systems That Don't Wake You Up
Configuration-driven agents. Embedded memory. Zero external dependencies. Build multi-agent systems in 5-10 minutes using configuration files.
Why Caxton Exists
Current Pain Points
- Debugging distributed agent state is a nightmare
- Agent crashes affect the entire system
- No standard communication protocols
- Network partitions break everything
- Complex setup with external dependencies
- Observability is an afterthought
How Caxton Solves Them
- Built-in distributed tracing for every message
- Agents with minimal setup
- Standard agent messaging protocols out of the box
- Graceful degradation during network partitions
- Embedded memory system - no external dependencies
- OpenTelemetry from day one
Core Features
Configuration-Driven Agents
Create agents with TOML configuration files. 5-10 minute onboarding. No compilation or toolchain setup required.
Capability-Based Messaging
Lightweight agent messaging with capability routing. Agents discover and communicate through capabilities, not addresses.
Observable by Design
Built-in OpenTelemetry from day one. Every message traced, every decision logged, every metric captured.
Production Performance
Designed for real workloads, not demos. Microsecond latencies, predictable resource usage, graceful degradation.
Debugging Tools
Purpose-built tools for 3 AM debugging. Trace conversations, replay events, inspect agent state, all without restarts.
Tool Integration
MCP (Model Context Protocol) bridges to external tools. Connect your agents to databases, APIs, and services.
Embedded Memory System
Built-in SQLite + Candle vector database. No external dependencies. Optional external backends for scaling.
The 3 AM Test
Every feature designed to be debugged in production
Real Debugging Scenario: Agent Conversation Timeout
Alert fires: "Agent conversation timeout"
$ caxton trace --conversation-id abc123 --last 5mSee exactly where conversation stalled
[03:23:45.123] agent="OrderProcessor" message="propose" status="sent"
[03:23:45.567] agent="InventoryChecker" message="propose" status="received"
[03:23:50.568] agent="InventoryChecker" error="tool timeout" tool="database_query"Root cause: Agent had a slow tool call
$ caxton debug agent InventoryChecker --show-metrics
Memory: 45MB/512MB | Queue: 1,523 messages | Tool calls: 15/s (p99: 5.2s)Fix: Adjust circuit breaker configuration
$ caxton config set --agent InventoryChecker \
--circuit-breaker.timeout=10s \
--circuit-breaker.threshold=3Architecture
Configuration-Driven Architecture
Caxton provides agents for rapid development. Zero external dependencies with embedded memory and local-first design.
- Agents - TOML configuration for 5-10 minute onboarding
- MCP Tool Security - Secure tool execution with permission boundaries
- Capability Routing - Lightweight agent messaging with capability-based discovery
- Embedded Memory - SQLite + Candle vector database built-in
- MCP Tool Bridge - Connect to external systems via Model Context Protocol
- Zero Dependencies - Self-contained with optional external backends
Three Views of the System
External API
:8080
:8081
Configuration Agents
WASM MCP Servers
caxton-server (systemd service)
:8080 (Management)
:8081 (Health)
tokio executor
config agent hosting
Embedded Memory System
transactional storage
embedding search
YAML + markdown
Observability Exports
:9090
:4317
:8081
Agent Isolation
Recovery Hierarchy
Circuit Breakers
Debug Points
Getting Started
From zero to multi-agent system in 5 minutes
Install Caxton
# Download binary from GitHub releases
curl -L https://github.com/jwilger/caxton/releases/latest/download/caxton-linux-x86_64.tar.gz | tar xz
sudo mv caxton /usr/local/bin/caxtonInitialize and Start Server
# Generate default configuration
caxton config init
# Start the server
caxton server startCreate Your First Agent
# order-agent.toml
name = "OrderAgent"
version = "1.0.0"
capabilities = ["order-processing"]
system_prompt = '''
You are an order processing agent. You help customers place orders,
check inventory, and coordinate with payment systems.
When processing orders:
1. Validate order details
2. Check inventory availability
3. Calculate total cost
4. Confirm with customer
'''
documentation = '''
# OrderAgent
A simple agent that processes customer orders with inventory checking.
'''Multi-Agent Example
Create Two Complementary Agents
# order-processor.toml
name = "order-processor"
capabilities = ["order-processing"]
tools = ["database", "http_client"]
system_prompt = '''
Process orders and send inventory requests to
inventory-checking capability.
'''
# inventory-checker.toml
name = "inventory-checker"
capabilities = ["inventory-checking"]
tools = ["database"]
system_prompt = '''
Check item availability and respond to
order-processing requests.
'''Deploy Both Agents
# Deploy both agents
caxton agent deploy order-processor.toml
caxton agent deploy inventory-checker.toml
# Verify both are running
caxton agent list
# NAME CAPABILITIES
# order-processor order-processing
# inventory-checker inventory-checkingWatch Agents Communicate
# Send order request - triggers multi-agent workflow
curl -X POST http://localhost:8080/api/v1/capabilities/order-processing \
-H "Content-Type: application/json" \
-d '{"items": ["item-123", "item-456"]}'
# Agents communicate automatically:
# 1. order-processor receives request
# 2. order-processor sends to inventory-checking capability
# 3. inventory-checker validates items
# 4. order-processor completes order
# Response: {"tracking_number": "ORD-20250910-001"}