This project presents a multi-agent system demo implemented in Python, showcasing asynchronous coordination among specialized agents to collaboratively solve tasks. The system includes five agents — Coordinator, ResearchAgent, PlannerAgent, ExecutorAgent, and ReporterAgent — each responsible for distinct functions such as research, planning, execution, and reporting. Tools like a web fetcher, calculator, and file writer are integrated to enhance agent capabilities. While designed to run independently, the system is LangGraph-friendly, allowing seamless integration with LangGraph pipelines in the future. The demo highlights modularity, role separation, and asynchronous coordination, providing a concise showcase suitable for employer presentations.
Multi-agent systems (MAS) are an effective paradigm for solving complex tasks by distributing responsibilities across specialized autonomous entities. Each agent in a MAS operates semi-independently but collaborates through communication protocols to achieve common goals. This demo illustrates a small-scale MAS implemented in Python that coordinates asynchronously to solve tasks using a combination of internal logic and external tools. The system is designed to be extensible, demonstrating both educational and practical use cases for multi-agent collaboration in AI workflows. LangGraph integration is optional, making it accessible to users without requiring additional frameworks.
The system consists of five distinct agents:
CoordinatorAgent: Manages task delegation and tracks agent progress.
ResearchAgent: Retrieves information from external sources using a web fetcher tool.
PlannerAgent: Generates step-by-step plans for task execution based on research input.
ExecutorAgent: Performs calculations, file operations, and executes planned actions using integrated tools.
ReporterAgent: Compiles outputs and generates summaries for final reporting.
Architecture Highlights:
Agents communicate asynchronously via an in-memory message bus, enabling concurrent task execution.
Tools are abstracted as reusable modules (tools.py), allowing agents to fetch data, calculate results, or write files.
LangGraph detection is included; if installed, agents log potential integration points for future pipeline attachment.
Modular design ensures easy addition of new agents, tools, or LangGraph workflows.
Setup:
Agents were instantiated in an orchestrator (main.py) and assigned a collaborative task such as researching a topic, planning a calculation workflow, executing it, and reporting results.
Asynchronous coordination was evaluated using Python’s asyncio event loop.
The web fetcher was tested with sample URLs, calculations were verified for correctness, and file outputs were checked for accuracy.
Test Scenarios:
Simple task execution: Agents coordinate to fetch information, calculate values, and save a summary.
Multi-step workflow: Agents handle sequential and dependent tasks where outputs from one agent feed into another.
LangGraph integration detection: Agents logged integration readiness without requiring actual LangGraph installation.
Task Completion: All tasks executed correctly with expected outputs.
Asynchronous Coordination: Agents operated concurrently without deadlocks or race conditions.
Tool Integration: Web fetch, calculation, and file writing worked seamlessly across agents.
Modularity: Adding or modifying agents required minimal changes to the message bus or orchestrator.
LangGraph Readiness: The system successfully detected LangGraph, confirming potential for pipeline integration.
The multi-agent demo successfully demonstrates a collaborative, asynchronous MAS with clear role separation and tool abstraction. The system is modular, extensible, and designed to integrate with LangGraph when needed. It serves as a practical showcase of multi-agent coordination for educational or employer-facing demonstrations. Future work may include full LangGraph integration, additional agent specializations, enhanced decision-making capabilities, and more complex task orchestration.