---
source: 'https://howaiworks.ai/ai-tools/laddr'
section: ai-tools
title: Laddr
description: >-
  Python framework for building distributed, horizontally scalable multi-agent
  systems, with Redis Streams messaging, automatic tracing, and a React
  dashboard.
category: AI Platform
developer: AgnetLabs
projectType: Platform
pricing: Open Source
launchDate: '2025-11-04'
officialWebsite: 'https://laddr.agnetlabs.com'
tags:
  - AI Tool
  - Multi-Agent Systems
  - Python Framework
  - Distributed Computing
  - Observability
difficultyLevel: Intermediate
setupTime: 15-30 minutes
toolLevel: popular
lastUpdated: '2026-07-08'
---

# Laddr

> Python framework for building distributed, horizontally scalable multi-agent systems, with Redis Streams messaging, automatic tracing, and a React dashboard.

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:

1. **Message Bus (Redis Streams)**: Each agent has a dedicated stream for receiving tasks
2. **Worker Pool**: Multiple workers consume from the same stream for load balancing
3. **Task Processing**: Workers process tasks, call tools, and interact with LLMs
4. **Delegation**: Agents can delegate tasks to other agents via the message bus
5. **Trace Storage**: All executions are automatically traced (SQLite by default, or PostgreSQL)
6. **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](https://laddr.agnetlabs.com) 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

```bash
# Install Laddr
pip install laddr

# Or using uv
uv pip install laddr
```

### Step 2: Scaffold a Project

```bash
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:

```python
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](https://laddr.agnetlabs.com) for the full API.

### Step 4: Start the System

```bash
# 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

```bash
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](https://howaiworks.ai/ai-tools/agentgpt)** - Browser-based multi-agent system builder
- **[n8n](https://howaiworks.ai/ai-tools/n8n)** - Workflow automation with AI agents
- **[Manus](https://howaiworks.ai/ai-tools/manus)** - AI agent platform with visual workflow builder

## Community & Support

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

Built for production. Designed for scale. Made transparent.

## Related

### Related tools

- [n8n](https://howaiworks.ai/ai-tools/n8n)

---

Source: https://howaiworks.ai/ai-tools/laddr — HowAIWorks.ai