Legion AI Framework: Build Multi-Agent Systems with Python
Table of Content
Are you ready to build intelligent, interactive AI systems that work together like a well-coordinated team? Meet Legion , a powerful, provider-agnostic multi-agent framework that makes it easy to create, manage, and scale complex AI workflows, with just Python.
Whether you're building chatbots, automation pipelines, or AI-powered research tools, Legion gives you the tools to define agents , tools , chains , teams , and even graph-based workflows, all in one unified framework.
What is Legion?
Legion is an open-source framework for building multi-agent AI systems . It abstracts away the complexity of working with multiple AI models and tools, allowing developers to focus on the logic of their application rather than the infrastructure.
With Legion, you can:
- Use multiple LLM providers (OpenAI, Anthropic, Groq, Ollama, Gemini, and more)
- Define intelligent agents with roles, tools, and dynamic prompts
- Create teams of agents that collaborate on tasks
- Build complex workflows using chains or graph-based execution
- Seamlessly inject parameters and manage memory
- Monitor performance and errors in real time
Hazem Abbas
Key Features of Legion
1. Provider-Agnostic Design
Legion supports multiple LLM providers through a unified interface. You can switch or combine providers like OpenAI , Anthropic , Groq , Ollama , and Gemini without changing your codebase.
2. Agent Abstraction
Define AI agents with clear roles, tools, and prompts using simple decorators. This makes it easy to build complex behaviors and logic.
3. Tool Integration
Use the @tool decorator to define functions that your agents can use, from simple math to complex external API calls.
4. Chains and Teams
- Chains : Link agents together in a sequence to process data step-by-step.
- Teams : Build collaborative AI teams where each agent plays a specific role, like a research team with a leader, analyst, and writer.
5. Graph-Based Execution
Build advanced workflows using graph-based execution . Define nodes, edges, and channels to create scalable, dynamic AI pipelines.
6. Input/Output Validation
Ensure data integrity with Pydantic-based schemas for both input and output of your agents and tools.
Hazem Abbas
7. Dynamic System Prompts
Create agents that adapt to context and user preferences with dynamic prompts.
8. Memory Management
Support for various memory backends to store and retrieve conversation history and agent state.
9. Monitoring and Observability
Built-in tools for tracking agent performance, resource usage, and error logs — ideal for production environments.
10. Asynchronous Support
Fully async design for high-performance, scalable applications.
Why Use Legion?
- Modular & Extensible : Build reusable components and workflows.
- Flexible : Supports both simple and complex AI architectures.
- Provider-Agnostic : Use any LLM provider you want, or mix and match.
- Scalable : Designed for production use with async support and observability.
- Developer-Friendly : Clean API, decorators, and base classes for customization.
- Community-Driven : Open source, actively developed, and welcoming contributions.
Getting Started with Legion
Legion is designed to be simple to install and use. You can install it via pip:
pip install legion-ai
Once installed, you can start building your first AI agent in minutes. Here's a quick example:
from legion.agents import agent
from legion.interface.decorators import tool
@tool
def add_numbers(a: float, b: float) -> float:
return a + b
@agent(model="openai:gpt-4o-mini")
class MathHelper:
def __init__(self):
self.tools = [add_numbers]
def add(self, a, b):
return self.add_numbers(a, b)
# Run the agent
math_agent = MathHelper()
result = math_agent.add(2.5, 3.5)
print(result) # Output: 6.0
Example Use Cases
1. Text Analysis Chain
Create a chain that summarizes text and then analyzes keywords:
@agent(model="openai:gpt-4o-mini")
class Summarizer:
...
@agent(model="openai:gpt-4o-mini")
class Analyzer:
...
@chain
class TextAnalysisChain:
summarizer = Summarizer()
analyzer = Analyzer()
2. Research Team
Build a team of agents that analyze numbers and generate reports:
@team
class ResearchTeam:
@leader
class Leader:
...
@agent
class Analyst:
...
@agent
class Writer:
...
3. Graph-Based Text Processing
Create a graph that normalizes text and then summarizes it:
@graph
class TextProcessingGraph:
normalizer = normalize_text
summarizer = Summarizer()
Documentation & Examples
Legion comes with a growing set of examples and documentation:
examples/agents/basic_agent.pyexamples/chains/basic_chain.pyexamples/teams/basic_team.pyexamples/graph/basic_graph.py
These examples will help you understand how to build everything from simple agents to full AI teams and graph-based pipelines.
License
MIT License.
Legion is more than just another AI framework, it’s a new way to build intelligent, interactive AI systems. Whether you're a solo developer or part of a team building enterprise-grade AI solutions, Legion gives you the flexibility, power, and structure you need.
LLMP-io
