What is Agentx

AgentX is a modern, configuration-driven framework designed for building collaborative AI agent teams. It emphasizes a clean Task-centric API, intelligent reasoning through a ‘Brain’ component, secure code execution in Daytona sandboxes, and efficient memory management for complex multi-agent workflows.

Use cases

AgentX can be utilized in scenarios requiring team collaboration among AI agents, such as content creation, research, planning, and project management. It enables diverse workflows with agents handling various tasks, improving productivity in automating complex processes through intelligent decision-making and communication.

How to use

To get started with AgentX, clone the repository and install the dependencies. You can create tasks using a YAML configuration file, start the API server, and use CLI commands for monitoring or running examples. The Python API allows you to manage tasks, memory operations, and event handling programmatically.

Key features

AgentX boasts several key features including Brain-powered intelligence for reasoning, a task-centric API for managing workflows, configuration-based setup using YAML, modern observability through CLI and web dashboards, secure code execution with Daytona sandboxes, memory management with Mem0 integration, and a tool ecosystem that supports both built-in and extensible plugins.

Where to use

AgentX is suitable for use in AI development environments, research labs, and production systems where multi-agent interaction is crucial. It is designed for scalability and reliability, making it ideal for applications involving complex AI workflows, collaborative problem-solving, and real-time decision support in domains like education, business, and creative industries.

AgentX

An open-source framework for building autonomous AI agent teams.
Explore the docs »

AgentX provides the backbone for creating, orchestrating, and observing sophisticated multi-agent systems. It moves beyond simple agent-to-agent communication to a robust, task-driven framework where teams of specialized agents collaborate to achieve complex goals.

✨ Key Features

Based on a refined and modular architecture, AgentX is built around a few core concepts:

• 🤖 Multi-Agent Teams: Define teams of specialized agents in simple YAML files. Each agent can have its own role, tools, and configuration.
• 🗣️ Natural Language Orchestration: Agents hand off tasks to each other using natural language. A central TaskExecutor interprets these handoffs and routes work to the appropriate agent, enabling complex, dynamic workflows.
• 🛠️ Secure & Extensible Tools: Tools are defined with Python decorators and their schemas are automatically generated. Shell commands are executed in a secure Docker sandbox, providing safety and isolation. A flexible ToolExecutor manages the entire lifecycle.
• 🧠 Stateful & Context-Aware Memory: Agents maintain long-term memory, enabling them to recall past interactions and context. The memory system supports semantic search, ensuring agents have the information they need, when they need it.
• 📡 Streamable Communication: The entire lifecycle of a task, from agent thoughts to tool calls and results, is available as a real-time stream of events. This allows you to build rich, observable UIs like the Vercel AI SDK.
• 🎯 Task-Centric API: Interact with the system through a simple, powerful API. Kick off complex workflows with execute_task() or manage interactive sessions with start_task().

🚀 Getting Started

The best way to get started is by following our Quickstart Guide, which will walk you through building a simple chat application and a multi-agent writer/reviewer team.

1. Installation

Install AgentX from PyPI:

pip install agentx-py

Or for development, clone the repository:

git clone https://github.com/dustland/agentx.git
cd agentx
uv sync

2. Usage Examples

AgentX can be run directly from the command line or via its Python API. You can find complete, working examples in the examples/ directory.

Running an Example

This demonstrates a basic multi-agent collaboration:

# Navigate to an example directory
cd examples/simple_team

# Run the demo script
python demo.py

Using the CLI

The framework includes a powerful CLI for managing your agent system:

# Start the API server
agentx start

# Monitor tasks and events in your terminal
agentx monitor

# Launch the web dashboard for rich observability
agentx monitor --web

# Run a named example directly
agentx example superwriter

Using the Python API

Here is a simple example of an autonomous run:

import asyncio
from agentx import execute_task

async def main():
    # Execute a task with a simple prompt
    result = await execute_task("Write a brief report on renewable energy trends")

    print(f"Success: {result.success}")
    print(f"Summary: {result.summary}")
    print(f"Conversation rounds: {len(result.conversation_history)}")

asyncio.run(main())

The script above shows a simple autonomous run. For more advanced patterns like message streaming and interactive sessions, please see the complete scripts in the /examples directory.

📊 Observability & Monitoring

AgentX includes a comprehensive observability system for monitoring and debugging multi-agent workflows.

Launch a modern web dashboard built with FastAPI and Preline UI:

# Start web dashboard
agentx monitor --web

• Dashboard: System overview with metrics and recent activity.
• Tasks: Task conversation history viewer with export.
• Events: Real-time event monitoring with filtering.
• Memory: Memory browser with search and categories.
• Messages: Agent conversation history during execution.
• Configuration: System configuration and status viewer.

You can also use the observability features in CLI mode without the option --web.

🏗️ Architecture Overview

AgentX is a modular framework composed of several key components that work together to execute complex tasks. At its heart is the TaskExecutor, which manages the overall workflow and provides secure tool execution through its integrated ToolManager. It interacts with a Team of Agents to perform work, and consults the Orchestrator for intelligent agent routing and coordination decisions.

Key Components:

• Task Executor: Manages task lifecycle, workspace, and tool execution
• Orchestrator: Handles agent routing and coordination decisions
• Team of Agents: Specialized agents that perform the actual work
• ToolManager: Provides secure, isolated tool execution per task
• Platform Services: Shared services for memory, storage, and observability

You can discover more design details from following documents:

• System Architecture - Overall design and system architecture
• State and Context Management State and Context management
• Tool Calling - Invoke tools for actual tasks
• Communication and Message - Message format for composite content and streaming

🤝 Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

🙏 Acknowledgments

This project was initially inspired by and built upon concepts from AG2 (AutoGen), an excellent multi-agent conversation framework. While AgentX has evolved into its own distinct architecture and approach, we’re grateful for the foundational ideas and patterns that AG2 provided to the multi-agent AI community.

📄 License

Licensed under the Apache License 2.0 - see LICENSE for details.

Built with ❤️ by the Dustland team