Laddr is a Python framework for building multi-agent systems where agents communicate, delegate tasks, and execute work in parallel. Think of it as a microservices architecture for AI agents — with built-in message queues, observability, and horizontal scalability.

Overview

Laddr provides a production-ready framework for developers who want to build sophisticated multi-agent applications without managing the underlying infrastructure. It handles agent communication, task delegation, parallel execution, and provides comprehensive observability tools out of the box.

The framework uses Redis Streams for reliable messaging, SQLite (default) or PostgreSQL for trace storage, and MinIO/S3 for artifact storage. It includes a React dashboard for monitoring and debugging agent systems in real time.

Laddr offers two operating modes: a Coordinator-Orchestrator mode, where a coordinator agent analyses tasks, delegates to specialists, and synthesises results; and a Sequential Deterministic Workflow mode, where tasks flow through agents in a fixed, pre-defined pipeline.

Key Features

Horizontal Scaling: Scale each agent independently based on workload, with multiple workers per agent and automatic load balancing across Redis Streams.
Built-in Delegation: Agents delegate tasks to other agents through the message bus.
Batch & Parallel Execution: Run many tasks in parallel with full tracking and WebSocket monitoring.
Complete Tracing: Every agent action is logged automatically (SQLite or PostgreSQL), with optional Langfuse integration for external tracing.
Interactive Dashboard & Playground: Monitor agents, traces, batches, and logs; test agents interactively with live streaming responses.
Custom Tools: Register any Python function as an agent tool with the @tool decorator; system tools such as delegation and storage can be overridden.
LLM Agnostic: Works with Gemini, OpenAI, Anthropic, Groq, Ollama, and local models.
Pluggable Backends: Swap Redis, PostgreSQL, or storage providers.
Artifact Storage: Payloads over 1MB are automatically offloaded to MinIO/S3, with only a reference sent through Redis.
API Security: Optional API key authentication for all endpoints.

How It Works

Laddr uses a microservices-like architecture for AI agents:

Message Bus (Redis Streams): Each agent has a dedicated stream for receiving tasks
Worker Pool: Multiple workers consume from the same stream for load balancing
Task Processing: Workers process tasks, call tools, and interact with LLMs
Delegation: Agents can delegate tasks to other agents via the message bus
Trace Storage: All executions are automatically traced (SQLite by default, or PostgreSQL)
Artifact Storage: Large payloads stored in object storage (MinIO/S3)

Technical Architecture:

Message Queue: Redis Streams (7.0+) with consumer groups for load balancing
Database: SQLite by default for traces and job history; PostgreSQL (15+) if configured
Storage: MinIO (local) or AWS S3 (production) for artifacts
Runtime: FastAPI (0.115+) for REST API endpoints, with auto-generated OpenAPI docs
Dashboard: React-based UI for observability
Language: Python 3.10+ (below 3.14)
Deployment: Docker native, with docker-compose
License: Apache 2.0

Technical Details

Message Bus Architecture

Laddr uses Redis Streams for reliable messaging:

Agent Queues: Each agent has a dedicated stream (laddr:agent:{name})
Consumer Groups: Multiple workers consume from the same stream
Load Balancing: Redis automatically distributes tasks across workers
Persistence: Messages persisted until acknowledged
Backpressure: Queue depth monitoring prevents overload

Trace Storage

All agent executions are automatically traced:

Complete History: Every tool call, LLM interaction, delegation
Structured Data: JSON traces with metadata
Default Backend: SQLite, with PostgreSQL as an optional configured backend
Optional External Tracing: Langfuse integration with automatic span creation

Artifact Storage

Large payloads automatically stored:

Automatic Threshold: Messages >1MB stored as artifacts
S3-Compatible: MinIO (local) or AWS S3 (production)
Efficient Messaging: Only artifact reference sent via Redis
On-Demand Retrieval: Workers fetch artifacts when needed

API Endpoints

Laddr provides a REST API for job management, observability, and agent interaction. Key endpoints include:

Job Management:

POST /api/jobs - Submit a new job
GET /api/jobs/{job_id} - Get job status and result
GET /api/jobs - List all jobs
POST /api/jobs/{job_id}/replay - Replay a failed job

Observability:

GET /api/traces - Get execution traces
GET /api/metrics - Get system metrics
GET /api/logs/containers - List Docker containers

Agent Management:

GET /api/agents - List all available agents
GET /api/agents/{agent_name}/tools - Get agent's tools
GET /api/agents/{agent_name}/chat - Interactive chat with agent

Refer to the official API documentation for complete endpoint reference and request/response formats.

Use Cases

Multi-Agent Workflows

Research Agents: Delegate research tasks to specialized agents
Content Generation: Coordinate multiple agents for content creation pipelines
Data Processing: Parallel processing across multiple agent workers
Task Orchestration: Complex workflows with agent coordination

Enterprise Applications

Customer Service: Multi-agent systems for handling customer inquiries
Document Processing: Parallel document analysis and extraction
Business Automation: Complex business processes with agent coordination
Data Analysis: Distributed data analysis across agent workers

Development & Testing

Agent Development: Build and test multi-agent systems locally
System Debugging: Use dashboard to trace and debug agent interactions
Performance Testing: Scale agents horizontally for load testing
Prototyping: Rapidly prototype multi-agent applications

Specialized Applications

AI Research: Build research systems with specialized agent teams
Content Moderation: Multi-agent content review and moderation
Financial Analysis: Parallel financial data processing
Healthcare: Coordinated agent systems for medical data analysis

Getting Started

Step 1: Installation

# Install Laddr
pip install laddr

# Or using uv
uv pip install laddr

Step 2: Scaffold a Project

laddr init my-agent-system
cd my-agent-system

Then edit the generated .env file with your API keys (for example GEMINI_API_KEY, OPENAI_API_KEY, or OLLAMA_BASE_URL with LLM_BACKEND=ollama for local models).

Step 3: Define Your Agents

Agents are declared with the Agent class. Here is the shape laddr init generates:

from laddr import Agent
from laddr.llms import gemini

coordinator = Agent(
    name="coordinator",
    role="Research Task Coordinator",
    goal="Coordinate research tasks by delegating to specialist agents",
    # ...
)

Custom tools are registered with the @tool decorator. Refer to the official documentation for the full API.

Step 4: Start the System

# Start all services (agent workers, database, Redis, MinIO)
laddr run dev

This starts:

API Server at http://localhost:8000
Dashboard at http://localhost:5173
SQLite for traces and job history (default; PostgreSQL if configured)
Redis for the message queue

Step 5: Submit Jobs

curl -X POST http://localhost:8000/api/jobs \
  -H "Content-Type: application/json" \
  -d '{
    "agent_name": "coordinator",
    "inputs": {
      "query": "Latest AI trends"
    }
  }'

Step 6: Monitor in Dashboard

Open the dashboard at http://localhost:5173 (playground at /playground) to:

View job status and results
Explore execution traces
Monitor system metrics
Stream container logs
Test agents interactively

Limitations

Young Project: First public release was in November 2025; the API is still moving quickly
Infrastructure Requirements: Requires Redis, a trace database, and (for large payloads) object storage
Python Only: Currently only supports Python agents; requires Python 3.10 or newer, below 3.14
No Built-in MCP or Computer Use: Laddr's own README documents neither a Model Context Protocol client nor computer-use primitives
Manual Scaling: Workers scale horizontally, but Laddr does not document autoscaling based on queue depth
Learning Curve: Requires understanding of multi-agent concepts
Resource Intensive: Multiple services need to run simultaneously
Deployment Complexity: Production deployment requires infrastructure setup

Alternatives

AgentGPT - Browser-based multi-agent system builder
n8n - Workflow automation with AI agents
Manus - AI agent platform with visual workflow builder

Community & Support

Documentation: laddr.agnetlabs.com - Complete documentation
GitHub: github.com/AgnetLabs/Laddr - Source code and issues (repository created November 2025)
PyPI: pypi.org/project/laddr - pip install laddr
License: Apache 2.0 - Open source and free to use
Issues: GitHub Issues - Report bugs and request features

Built for production. Designed for scale. Made transparent.

Laddr