Multi-Agent on Producthunt daily

spring-ai-alibaba

Wed, 15 Oct 2025 15:29:48 +0800

alibaba/spring-ai-alibaba

Spring AI Alibaba

Spring AI Alibaba is an agentic AI framework for building ChatBot, Workflow, and Multi-agent applications.

Core Features

Spring AI Alibaba provides the following core capabilities to help developers quickly build Chatbot, Workflow, or Multi-agent applications:

Graph based multi-agent framework, with Spring AI Alibaba Graph, developers can quickly build workflows and multi-agent applications in ease. Graph code can be generated from Dify DSL and debugged in a visual way.
Enterprise-ready AI ecosystem integration, bring agents from demo to production. Spring AI Alibaba supports integration with the Aliyun Bailian platform, providing LLM model service and RAG knowledge solutions; Support seamless integration of AI observation products such as ARMS and Langfuse; Support enterprise level MCP integration, including Nacos MCP Registry for MCP discovery and routing, etc.
Plan-Act agent products and platforms.

JManus, Spring AI Alibaba based Manus implementation, supports delicacy plan adjustment, plan reuse.
DeepResearch, Spring AI Alibaba based research and report agent with powerful tools like search engines, web crawlers, Python and MCP services.

Get Started

To quickly get started with Spring AI Alibaba, add ‘spring-ai-alibaba-starter-dashscope’ dependency to your java project.

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.alibaba.cloud.ai</groupId>
      <artifactId>spring-ai-alibaba-bom</artifactId>
      <version>1.0.0.3</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>com.alibaba.cloud.ai</groupId>
    <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
  </dependency>
</dependencies>

Please check Quick Start on our official website to learn more details. More starters include spring-ai-alibaba-graph-core, spring-ai-alibaba-starter-nl2sql,spring-ai-alibaba-starter-nacos-mcp-client, etc, please refer to the official website documentation.

NOTE!

Requires JDK 17+.

If there are any spring-ai dependency issue, please lean how to configure the spring-milestones Maven repository on FAQ page.

Playground and Example

The community has developed a Playground agent that includes a complete front-end UI and back-end implementation. The Playground back-end is developed using Spring AI Alibaba and gives users a quick overview of all core framework capabilities such as chatbot, multi-round conversations, image generation, multi-modality, tool calling, MCP, and RAG.

You can deploy the Playground example locally and access the experience through your browser, or copy the source code and tweak it to your own business needs to build your own set of AI apps more quickly. For more examples, please refer to our official example repository: https://github.com/springaialibaba/spring-ai-alibaba-examples

Spring AI Alibaba Graph Multi-agent Framework

Spring AI Alibaba Graph enables developers to implement workflow and multi-agent application orchestration. Its core design is mainly from LangGraph, and we have added a rich set of prebuilt Nodes and simplified the Graph State definition, allowing developers to better integrate with low-code platforms and write popular multi-agent pattern applications.

Core features:

Workflow, built-in workflow nodes, aligned with mainstream low-code platforms;
Multi-agent, built-in ReAct Agent, Supervisor and other modes;
Native streaming support;
Human-in-the-loop, waiting for human confirmation, modifying states and resuming execution;
Memory and persistent storage;
Graph state snapshot;
Nested and paralleled graph;
PlantUML and Mermaid format export.

Enterprise-ready AI Ecosystem Integration

To bring agent from demo to production, developers and organizations face lots of challenges, from evaluation, tracing, MCP integration, prompt management, to token rate-limit, etc. Spring AI Alibaba, as am enterprise solution incubated from serving enterprise agent development, provides profound solutions by integrating with Nacos MCP Registry, Higress AI gateway, Alibaba Cloud ARMS, Alibaba Cloud Vector Stores, Alibaba Cloud Bailian platform, etc.

Distributed MCP discovery and proxy: Support distributed MCP Server discovery and load balancing based on Nacos MCP Registry. Zero code change to transform HTTP and Dubbo services into MCP servers with Spring AI Alibaba MCP Gateway and Higress;
Higress LLM model proxy: Higress as a LLM proxy, spring-ai-starter-model-openai adapter can leverage the unified Higress OpenAI model proxy API;
Better and easy data integration:
- a. Bailian RAG integration. Leverage Bailian platform’s excellent performance on data filtering, chunking, and vectoring, while using Spring AI Alibaba to do RAG retrieval;
- b. Bailian ChatBI integration. Spring AI Alibaba Nl2SQL, built on Bailian ChatBI, completely open-source, can generate SQL based on natural language query.
Observation and evaluation platforms: Thanks to the sdk-native instrumentation of Spring AI, observation and evaluation can be achieved by reporting to OpenTelemetry compatible platforms such as Langfuse and Alibaba Cloud ARMS.

Agent Products and Platforms

JManus

The emergence of Manus has given people unlimited space with the ability of general intelligent agents to automatically plan-act on various tasks. It is expected to be very good at solving open-ended issues and can have a wide range of applications in daily life, work, and other scenarios.

JManus is not just a Spring AI Alibaba version Manus replica, it’s also designed as a platform that can help developers to build their own fine-tuned agents targeting specific business scenarios. The typical characteristic of enterprise level agent is determinism, that means we need customized tools and sub agents, as well as stable and deterministic planning and processes. Therefore, we hope that JManus can become an intelligent agent development platform, allowing users to build their own domain specific intelligent agent implementations in the most intuitive and low-cost way.

DeepResearch

Spring AI Alibaba DeepResearch is a deep research agent developed based on the Spring AI Alibaba Graph, which includes a complete front-end web UI (under development) and back-end implementation. DeepResearch can help users complete various deep research reports with the help of large models and a series of carefully designed tools such as Web Search, Crawling, Python script engine, etc.

Contribution Guide

Please refer to the Contribution Guide to learn how to participate in the development of Spring AI Alibaba.

Contact Us

Dingtalk Group (钉钉群), search 94405033092 and join.
WeChat Group (微信公众号), scan the QR code below and follow us.

Credits

Some of this project’s ideas and codes are inspired by or rewrote from the following projects. Great thanks to those who have created and open-sourced these projects.

Spring AI, a Spring-friendly API and abstractions for developing AI applications licensed under the Apache License 2.0.
Langgraph, a library for building stateful, multi-actor applications with LLMs, used to create agent and multi-agent workflows licensed under the MIT license.
Langgraph4J, a porting of original LangGraph from the LangChain AI project in Java fashion.

crewAI

Fri, 05 Sep 2025 15:27:04 +0800

crewAIInc/crewAI

Homepage · Docs · Start Cloud Trial · Blog · Forum

Fast and Flexible Multi-Agent Automation Framework

CrewAI is a lean, lightning-fast Python framework built entirely from scratch—completely independent of LangChain or other agent frameworks. It empowers developers with both high-level simplicity and precise low-level control, ideal for creating autonomous AI agents tailored to any scenario.

CrewAI Crews: Optimize for autonomy and collaborative intelligence.
CrewAI Flows: Enable granular, event-driven control, single LLM calls for precise task orchestration and supports Crews natively

With over 100,000 developers certified through our community courses at learn.crewai.com, CrewAI is rapidly becoming the standard for enterprise-ready AI automation.

CrewAI Enterprise Suite

CrewAI Enterprise Suite is a comprehensive bundle tailored for organizations that require secure, scalable, and easy-to-manage agent-driven automation.

You can try one part of the suite the Crew Control Plane for free

Crew Control Plane Key Features:

Tracing & Observability: Monitor and track your AI agents and workflows in real-time, including metrics, logs, and traces.
Unified Control Plane: A centralized platform for managing, monitoring, and scaling your AI agents and workflows.
Seamless Integrations: Easily connect with existing enterprise systems, data sources, and cloud infrastructure.
Advanced Security: Built-in robust security and compliance measures ensuring safe deployment and management.
Actionable Insights: Real-time analytics and reporting to optimize performance and decision-making.
24/7 Support: Dedicated enterprise support to ensure uninterrupted operation and quick resolution of issues.
On-premise and Cloud Deployment Options: Deploy CrewAI Enterprise on-premise or in the cloud, depending on your security and compliance requirements.

CrewAI Enterprise is designed for enterprises seeking a powerful, reliable solution to transform complex business processes into efficient, intelligent automations.

Why CrewAI?

CrewAI unlocks the true potential of multi-agent automation, delivering the best-in-class combination of speed, flexibility, and control with either Crews of AI Agents or Flows of Events:

Standalone Framework: Built from scratch, independent of LangChain or any other agent framework.
High Performance: Optimized for speed and minimal resource usage, enabling faster execution.
Flexible Low Level Customization: Complete freedom to customize at both high and low levels - from overall workflows and system architecture to granular agent behaviors, internal prompts, and execution logic.
Ideal for Every Use Case: Proven effective for both simple tasks and highly complex, real-world, enterprise-grade scenarios.
Robust Community: Backed by a rapidly growing community of over 100,000 certified developers offering comprehensive support and resources.

CrewAI empowers developers and enterprises to confidently build intelligent automations, bridging the gap between simplicity, flexibility, and performance.

Getting Started

Setup and run your first CrewAI agents by following this tutorial.

Learning Resources

Learn CrewAI through our comprehensive courses:

Multi AI Agent Systems with CrewAI - Master the fundamentals of multi-agent systems
Practical Multi AI Agents and Advanced Use Cases - Deep dive into advanced implementations

Understanding Flows and Crews

CrewAI offers two powerful, complementary approaches that work seamlessly together to build sophisticated AI applications:

Crews: Teams of AI agents with true autonomy and agency, working together to accomplish complex tasks through role-based collaboration. Crews enable:
- Natural, autonomous decision-making between agents
- Dynamic task delegation and collaboration
- Specialized roles with defined goals and expertise
- Flexible problem-solving approaches
Flows: Production-ready, event-driven workflows that deliver precise control over complex automations. Flows provide:
- Fine-grained control over execution paths for real-world scenarios
- Secure, consistent state management between tasks
- Clean integration of AI agents with production Python code
- Conditional branching for complex business logic

The true power of CrewAI emerges when combining Crews and Flows. This synergy allows you to:

Build complex, production-grade applications
Balance autonomy with precise control
Handle sophisticated real-world scenarios
Maintain clean, maintainable code structure

Getting Started with Installation

To get started with CrewAI, follow these simple steps:

1. Installation

Ensure you have Python >=3.10 <3.14 installed on your system. CrewAI uses UV for dependency management and package handling, offering a seamless setup and execution experience.

First, install CrewAI:

`1`	`pip install crewai`

If you want to install the ‘crewai’ package along with its optional features that include additional tools for agents, you can do so by using the following command:

`1`	`pip install 'crewai[tools]'`

The command above installs the basic package and also adds extra components which require more dependencies to function.

Troubleshooting Dependencies

If you encounter issues during installation or usage, here are some common solutions:

Common Issues

ModuleNotFoundError: No module named ’tiktoken’
- Install tiktoken explicitly: pip install 'crewai[embeddings]'
- If using embedchain or other tools: pip install 'crewai[tools]'
Failed building wheel for tiktoken
- Ensure Rust compiler is installed (see installation steps above)
- For Windows: Verify Visual C++ Build Tools are installed
- Try upgrading pip: pip install --upgrade pip
- If issues persist, use a pre-built wheel: pip install tiktoken --prefer-binary

2. Setting Up Your Crew with the YAML Configuration

To create a new CrewAI project, run the following CLI (Command Line Interface) command:

`1`	`crewai create crew <project_name>`

This command creates a new project folder with the following structure:

my_project/
├── .gitignore
├── pyproject.toml
├── README.md
├── .env
└── src/
    └── my_project/
        ├── __init__.py
        ├── main.py
        ├── crew.py
        ├── tools/
        │   ├── custom_tool.py
        │   └── __init__.py
        └── config/
            ├── agents.yaml
            └── tasks.yaml

You can now start developing your crew by editing the files in the src/my_project folder. The main.py file is the entry point of the project, the crew.py file is where you define your crew, the agents.yaml file is where you define your agents, and the tasks.yaml file is where you define your tasks.

To customize your project, you can:

Modify src/my_project/config/agents.yaml to define your agents.
Modify src/my_project/config/tasks.yaml to define your tasks.
Modify src/my_project/crew.py to add your own logic, tools, and specific arguments.
Modify src/my_project/main.py to add custom inputs for your agents and tasks.
Add your environment variables into the .env file.

Example of a simple crew with a sequential process:

Instantiate your crew:

`1`	`crewai create crew latest-ai-development`

Modify the files as needed to fit your use case:

agents.yaml

# src/my_project/config/agents.yaml
researcher:
  role: >
    {topic} Senior Data Researcher
  goal: >
    Uncover cutting-edge developments in {topic}
  backstory: >
    You're a seasoned researcher with a knack for uncovering the latest
    developments in {topic}. Known for your ability to find the most relevant
    information and present it in a clear and concise manner.

reporting_analyst:
  role: >
    {topic} Reporting Analyst
  goal: >
    Create detailed reports based on {topic} data analysis and research findings
  backstory: >
    You're a meticulous analyst with a keen eye for detail. You're known for
    your ability to turn complex data into clear and concise reports, making
    it easy for others to understand and act on the information you provide.

tasks.yaml

# src/my_project/config/tasks.yaml
research_task:
  description: >
    Conduct a thorough research about {topic}
    Make sure you find any interesting and relevant information given
    the current year is 2025.
  expected_output: >
    A list with 10 bullet points of the most relevant information about {topic}
  agent: researcher

reporting_task:
  description: >
    Review the context you got and expand each topic into a full section for a report.
    Make sure the report is detailed and contains any and all relevant information.
  expected_output: >
    A fully fledge reports with the mains topics, each with a full section of information.
    Formatted as markdown without '```'
  agent: reporting_analyst
  output_file: report.md

crew.py

# src/my_project/crew.py
from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from crewai_tools import SerperDevTool
from crewai.agents.agent_builder.base_agent import BaseAgent
from typing import List

@CrewBase
class LatestAiDevelopmentCrew():
	"""LatestAiDevelopment crew"""
	agents: List[BaseAgent]
	tasks: List[Task]

	@agent
	def researcher(self) -> Agent:
		return Agent(
			config=self.agents_config['researcher'],
			verbose=True,
			tools=[SerperDevTool()]
		)

	@agent
	def reporting_analyst(self) -> Agent:
		return Agent(
			config=self.agents_config['reporting_analyst'],
			verbose=True
		)

	@task
	def research_task(self) -> Task:
		return Task(
			config=self.tasks_config['research_task'],
		)

	@task
	def reporting_task(self) -> Task:
		return Task(
			config=self.tasks_config['reporting_task'],
			output_file='report.md'
		)

	@crew
	def crew(self) -> Crew:
		"""Creates the LatestAiDevelopment crew"""
		return Crew(
			agents=self.agents, # Automatically created by the @agent decorator
			tasks=self.tasks, # Automatically created by the @task decorator
			process=Process.sequential,
			verbose=True,
		)

main.py

#!/usr/bin/env python
# src/my_project/main.py
import sys
from latest_ai_development.crew import LatestAiDevelopmentCrew

def run():
    """
    Run the crew.
    """
    inputs = {
        'topic': 'AI Agents'
    }
    LatestAiDevelopmentCrew().crew().kickoff(inputs=inputs)

3. Running Your Crew

Before running your crew, make sure you have the following keys set as environment variables in your .env file:

An OpenAI API key (or other LLM API key): OPENAI_API_KEY=sk-...
A Serper.dev API key: SERPER_API_KEY=YOUR_KEY_HERE

Lock the dependencies and install them by using the CLI command but first, navigate to your project directory:

1
2

cd my_project
crewai install (Optional)

To run your crew, execute the following command in the root of your project:

`1`	`crewai run`

`1`	`python src/my_project/main.py`

If an error happens due to the usage of poetry, please run the following command to update your crewai package:

`1`	`crewai update`

You should see the output in the console and the report.md file should be created in the root of your project with the full final report.

In addition to the sequential process, you can use the hierarchical process, which automatically assigns a manager to the defined crew to properly coordinate the planning and execution of tasks through delegation and validation of results. See more about the processes here.

Key Features

CrewAI stands apart as a lean, standalone, high-performance multi-AI Agent framework delivering simplicity, flexibility, and precise control—free from the complexity and limitations found in other agent frameworks.

Standalone & Lean: Completely independent from other frameworks like LangChain, offering faster execution and lighter resource demands.
Flexible & Precise: Easily orchestrate autonomous agents through intuitive Crews or precise Flows, achieving perfect balance for your needs.
Seamless Integration: Effortlessly combine Crews (autonomy) and Flows (precision) to create complex, real-world automations.
Deep Customization: Tailor every aspect—from high-level workflows down to low-level internal prompts and agent behaviors.
Reliable Performance: Consistent results across simple tasks and complex, enterprise-level automations.
Thriving Community: Backed by robust documentation and over 100,000 certified developers, providing exceptional support and guidance.

Choose CrewAI to easily build powerful, adaptable, and production-ready AI automations.

Examples

You can test different real life examples of AI crews in the CrewAI-examples repo:

Quick Tutorial

Using Crews and Flows Together

CrewAI’s power truly shines when combining Crews with Flows to create sophisticated automation pipelines. CrewAI flows support logical operators like or_ and and_ to combine multiple conditions. This can be used with @start, @listen, or @router decorators to create complex triggering conditions.

or_: Triggers when any of the specified conditions are met.
and_Triggers when all of the specified conditions are met.

Here’s how you can orchestrate multiple Crews within a Flow:

from crewai.flow.flow import Flow, listen, start, router, or_
from crewai import Crew, Agent, Task, Process
from pydantic import BaseModel

# Define structured state for precise control
class MarketState(BaseModel):
    sentiment: str = "neutral"
    confidence: float = 0.0
    recommendations: list = []

class AdvancedAnalysisFlow(Flow[MarketState]):
    @start()
    def fetch_market_data(self):
        # Demonstrate low-level control with structured state
        self.state.sentiment = "analyzing"
        return {"sector": "tech", "timeframe": "1W"}  # These parameters match the task description template

    @listen(fetch_market_data)
    def analyze_with_crew(self, market_data):
        # Show crew agency through specialized roles
        analyst = Agent(
            role="Senior Market Analyst",
            goal="Conduct deep market analysis with expert insight",
            backstory="You're a veteran analyst known for identifying subtle market patterns"
        )
        researcher = Agent(
            role="Data Researcher",
            goal="Gather and validate supporting market data",
            backstory="You excel at finding and correlating multiple data sources"
        )

        analysis_task = Task(
            description="Analyze {sector} sector data for the past {timeframe}",
            expected_output="Detailed market analysis with confidence score",
            agent=analyst
        )
        research_task = Task(
            description="Find supporting data to validate the analysis",
            expected_output="Corroborating evidence and potential contradictions",
            agent=researcher
        )

        # Demonstrate crew autonomy
        analysis_crew = Crew(
            agents=[analyst, researcher],
            tasks=[analysis_task, research_task],
            process=Process.sequential,
            verbose=True
        )
        return analysis_crew.kickoff(inputs=market_data)  # Pass market_data as named inputs

    @router(analyze_with_crew)
    def determine_next_steps(self):
        # Show flow control with conditional routing
        if self.state.confidence > 0.8:
            return "high_confidence"
        elif self.state.confidence > 0.5:
            return "medium_confidence"
        return "low_confidence"

    @listen("high_confidence")
    def execute_strategy(self):
        # Demonstrate complex decision making
        strategy_crew = Crew(
            agents=[
                Agent(role="Strategy Expert",
                      goal="Develop optimal market strategy")
            ],
            tasks=[
                Task(description="Create detailed strategy based on analysis",
                     expected_output="Step-by-step action plan")
            ]
        )
        return strategy_crew.kickoff()

    @listen(or_("medium_confidence", "low_confidence"))
    def request_additional_analysis(self):
        self.state.recommendations.append("Gather more data")
        return "Additional analysis required"

This example demonstrates how to:

Use Python code for basic data operations
Create and execute Crews as steps in your workflow
Use Flow decorators to manage the sequence of operations
Implement conditional branching based on Crew results

Connecting Your Crew to a Model

CrewAI supports using various LLMs through a variety of connection options. By default your agents will use the OpenAI API when querying the model. However, there are several other ways to allow your agents to connect to models. For example, you can configure your agents to use a local model via the Ollama tool.

Please refer to the Connect CrewAI to LLMs page for details on configuring your agents’ connections to models.

How CrewAI Compares

CrewAI’s Advantage: CrewAI combines autonomous agent intelligence with precise workflow control through its unique Crews and Flows architecture. The framework excels at both high-level orchestration and low-level customization, enabling complex, production-grade systems with granular control.

LangGraph: While LangGraph provides a foundation for building agent workflows, its approach requires significant boilerplate code and complex state management patterns. The framework’s tight coupling with LangChain can limit flexibility when implementing custom agent behaviors or integrating with external systems.

P.S. CrewAI demonstrates significant performance advantages over LangGraph, executing 5.76x faster in certain cases like this QA task example (see comparison) while achieving higher evaluation scores with faster completion times in certain coding tasks, like in this example (detailed analysis).

Autogen: While Autogen excels at creating conversational agents capable of working together, it lacks an inherent concept of process. In Autogen, orchestrating agents’ interactions requires additional programming, which can become complex and cumbersome as the scale of tasks grows.
ChatDev: ChatDev introduced the idea of processes into the realm of AI agents, but its implementation is quite rigid. Customizations in ChatDev are limited and not geared towards production environments, which can hinder scalability and flexibility in real-world applications.

Contribution

CrewAI is open-source and we welcome contributions. If you’re looking to contribute, please:

Fork the repository.
Create a new branch for your feature.
Add your feature or improvement.
Send a pull request.
We appreciate your input!

Installing Dependencies

1
2

uv lock
uv sync

Virtual Env

uv venv

Pre-commit hooks

`1`	`pre-commit install`

Running Tests

`1`	`uv run pytest .`

Running static type checks

`1`	`uvx mypy src`

Packaging

`1`	`uv build`

Installing Locally

`1`	`pip install dist/*.tar.gz`

Telemetry

CrewAI uses anonymous telemetry to collect usage data with the main purpose of helping us improve the library by focusing our efforts on the most used features, integrations and tools.

It’s pivotal to understand that NO data is collected concerning prompts, task descriptions, agents’ backstories or goals, usage of tools, API calls, responses, any data processed by the agents, or secrets and environment variables, with the exception of the conditions mentioned. When the share_crew feature is enabled, detailed data including task descriptions, agents’ backstories or goals, and other specific attributes are collected to provide deeper insights while respecting user privacy. Users can disable telemetry by setting the environment variable OTEL_SDK_DISABLED to true.

Data collected includes:

Version of CrewAI
- So we can understand how many users are using the latest version
Version of Python
- So we can decide on what versions to better support
General OS (e.g. number of CPUs, macOS/Windows/Linux)
- So we know what OS we should focus on and if we could build specific OS related features
Number of agents and tasks in a crew
- So we make sure we are testing internally with similar use cases and educate people on the best practices
Crew Process being used
- Understand where we should focus our efforts
If Agents are using memory or allowing delegation
- Understand if we improved the features or maybe even drop them
If Tasks are being executed in parallel or sequentially
- Understand if we should focus more on parallel execution
Language model being used
- Improved support on most used languages
Roles of agents in a crew
- Understand high level use cases so we can build better tools, integrations and examples about it
Tools names available
- Understand out of the publicly available tools, which ones are being used the most so we can improve them

Users can opt-in to Further Telemetry, sharing the complete telemetry data by setting the share_crew attribute to True on their Crews. Enabling share_crew results in the collection of detailed crew and task execution data, including goal, backstory, context, and output of tasks. This enables a deeper insight into usage patterns while respecting the user’s choice to share.

License

CrewAI is released under the MIT License.

Frequently Asked Questions (FAQ)

General

Features and Capabilities

Resources and Community

Enterprise Features

Q: What exactly is CrewAI?

A: CrewAI is a standalone, lean, and fast Python framework built specifically for orchestrating autonomous AI agents. Unlike frameworks like LangChain, CrewAI does not rely on external dependencies, making it leaner, faster, and simpler.

Q: How do I install CrewAI?

A: Install CrewAI using pip:

`1`	`pip install crewai`

For additional tools, use:

`1`	`pip install 'crewai[tools]'`

Q: Does CrewAI depend on LangChain?

A: No. CrewAI is built entirely from the ground up, with no dependencies on LangChain or other agent frameworks. This ensures a lean, fast, and flexible experience.

Q: Can CrewAI handle complex use cases?

A: Yes. CrewAI excels at both simple and highly complex real-world scenarios, offering deep customization options at both high and low levels, from internal prompts to sophisticated workflow orchestration.

Q: Can I use CrewAI with local AI models?

A: Absolutely! CrewAI supports various language models, including local ones. Tools like Ollama and LM Studio allow seamless integration. Check the LLM Connections documentation for more details.

Q: What makes Crews different from Flows?

A: Crews provide autonomous agent collaboration, ideal for tasks requiring flexible decision-making and dynamic interaction. Flows offer precise, event-driven control, ideal for managing detailed execution paths and secure state management. You can seamlessly combine both for maximum effectiveness.

Q: How is CrewAI better than LangChain?

A: CrewAI provides simpler, more intuitive APIs, faster execution speeds, more reliable and consistent results, robust documentation, and an active community—addressing common criticisms and limitations associated with LangChain.

Q: Is CrewAI open-source?

A: Yes, CrewAI is open-source and actively encourages community contributions and collaboration.

Q: Does CrewAI collect data from users?

A: CrewAI collects anonymous telemetry data strictly for improvement purposes. Sensitive data such as prompts, tasks, or API responses are never collected unless explicitly enabled by the user.

Q: Where can I find real-world CrewAI examples?

A: Check out practical examples in the CrewAI-examples repository, covering use cases like trip planners, stock analysis, and job postings.

Q: How can I contribute to CrewAI?

A: Contributions are warmly welcomed! Fork the repository, create your branch, implement your changes, and submit a pull request. See the Contribution section of the README for detailed guidelines.

Q: What additional features does CrewAI Enterprise offer?

A: CrewAI Enterprise provides advanced features such as a unified control plane, real-time observability, secure integrations, advanced security, actionable insights, and dedicated 24/7 enterprise support.

Q: Is CrewAI Enterprise available for cloud and on-premise deployments?

A: Yes, CrewAI Enterprise supports both cloud-based and on-premise deployment options, allowing enterprises to meet their specific security and compliance requirements.

Q: Can I try CrewAI Enterprise for free?

A: Yes, you can explore part of the CrewAI Enterprise Suite by accessing the Crew Control Plane for free.

Q: Does CrewAI support fine-tuning or training custom models?

A: Yes, CrewAI can integrate with custom-trained or fine-tuned models, allowing you to enhance your agents with domain-specific knowledge and accuracy.

Q: Can CrewAI agents interact with external tools and APIs?

A: Absolutely! CrewAI agents can easily integrate with external tools, APIs, and databases, empowering them to leverage real-world data and resources.

Q: Is CrewAI suitable for production environments?

A: Yes, CrewAI is explicitly designed with production-grade standards, ensuring reliability, stability, and scalability for enterprise deployments.

Q: How scalable is CrewAI?

A: CrewAI is highly scalable, supporting simple automations and large-scale enterprise workflows involving numerous agents and complex tasks simultaneously.

Q: Does CrewAI offer debugging and monitoring tools?

A: Yes, CrewAI Enterprise includes advanced debugging, tracing, and real-time observability features, simplifying the management and troubleshooting of your automations.

Q: What programming languages does CrewAI support?

A: CrewAI is primarily Python-based but easily integrates with services and APIs written in any programming language through its flexible API integration capabilities.

Q: Does CrewAI offer educational resources for beginners?

A: Yes, CrewAI provides extensive beginner-friendly tutorials, courses, and documentation through learn.crewai.com, supporting developers at all skill levels.

Q: Can CrewAI automate human-in-the-loop workflows?

A: Yes, CrewAI fully supports human-in-the-loop workflows, allowing seamless collaboration between human experts and AI agents for enhanced decision-making.

rl-swarm

Sat, 28 Jun 2025 15:28:05 +0800

gensyn-ai/rl-swarm

RL Swarm

RL Swarm is a peer-to-peer system for reinforcement learning. It allows you to train models collaboratively with others in the swarm, leveraging their collective intelligence. It is open source and permissionless, meaning you can run it on a consumer laptop at home or on a powerful GPU in the cloud. You can also connect your model to the Gensyn Testnet to receive an on-chain identity that tracks your progress over time.

Currently, we are running the reasoning-gym swarm on the Testnet. This swarm is designed to train models to solve a diverse set of reasoning tasks using the reasoning-gym dataset. The current list of default models includes:

Models:

Gensyn/Qwen2.5-0.5B-Instruct
Qwen/Qwen3-0.6B
nvidia/AceInstruct-1.5B
dnotitia/Smoothie-Qwen3-1.7B
Gensyn/Qwen2.5-1.5B-Instruct

This iteration of rl-swarm is powered by the GenRL-Swarm library. It is a fully composable framework for decentralized reinforcement learning which enables users to create and customize their own swarms for reinforcement learning with multi-agent multi-stage environments.

Requirements

Your hardware requirements will vary depending on a number of factors including model size and the accelerator platform you use. Users running large NVIDIA GPU will be assigned a model from the large model pool, while users running less powerful hardware will be assigned a model from the small model pool. This design decision is intended to allow users to advance at a similar rate regardless of the hardware they use, maximizing their utility to the swarm.

Supported Hardware

arm64 or x86 CPU with minimum 32gb ram (note that if you run other applications during training it might crash training).

CUDA devices (officially supported):
- RTX 3090
- RTX 4090
- RTX 5090
- A100
- H100

With either configuration, you will need Python >=3.10 (for Mac, you will likely need to upgrade).

⚠️ Please read before continuing ⚠️

This software is experimental and provided as-is for users who are interested in using (or helping to develop) an early version of the Gensyn Protocol for training models.

If you care about on-chain participation, you must read the Identity Management section below.

If you encounter issues, please first check Troubleshooting. If you cannot find a solution there, please check if there is an open (or closed) Issue. If there is no relevant issue, please file one and include 1) all relevant logs, 2) information about your device (e.g. which GPU, if relevant), and 3) your operating system information.

Instructions

Run the Swarm

The easiest way to run RL Swarm is using Docker. This ensures a consistent setup across all operating systems with minimal dependencies.

1. Clone this repo

`1`	`git clone https://github.com/gensyn-ai/rl-swarm`

2. Install Docker

Make sure you have Docker installed and the Docker daemon is running on your machine. To do that, follow these instructions according to your OS. Ensure you allot sufficient memory to the Docker containers. For example if using Docker Desktop, this can be done by going to Docker Desktop Settings > Resources > Advanced > Memory Limit, and increasing it to the maximum possible value.

3. Start the Swarm

Run the following commands from the root of the repository.

CPU support

If you’re using a Mac or if your machine has CPU-only support:

`1`	`docker-compose run --rm --build -Pit swarm-cpu`

GPU support

If you’re using a machine with an officially supported GPU:

`1`	`docker-compose run --rm --build -Pit swarm-gpu`

Docker compose issue

If docker-compose does not work when running the above commands, please try docker compose (no hyphen) instead. I.e. docker compose run --rm --build -Pit swarm-gpu. This issue sometimes occurs on users running Ubuntu.

Experimental (advanced) mode

If you want to experiment with the GenRL-Swarm library and its configurable parameters, we recommend you run RL Swarm via shell script:

1
2
3

python3 -m venv .venv
source .venv/bin/activate
./run_rl_swarm.sh

To learn more about experimental mode, check out our getting started guide.

A browser window will pop open (you’ll need to manually navigate to http://localhost:3000/ if you’re on a VM).
Click ’login'.
Login with your preferred method.

Huggingface

If you would like to upload your model to Hugging Face, enter your Hugging Face access token when prompted. You can generate one from your Hugging Face account, under Access Tokens.

Initial peering and training

From this stage onward your device will begin training. You should see your peer register and vote on-chain here.

You can also track your training progress in real time:

On The RL-Swarm Dashboard: dashboard.gensyn.ai

Identity management

Introduction

On-chain identity is managed via an Alchemy modal sign-in screen. You need to supply an email address or login via a supported method (e.g. Google). This creates an EOA public/private key (which are stored by Alchemy). You will also receive local session keys in the userApiKey. Note that these aren’t your EOA public/private keys.

During the initial set-up process, you will also create a swarm.pem file which maintains the identity of your peer. This is then registered on chain using the EOA wallet hosted in Alchemy, triggered using your local api keys. This links the swarm.pem to the email address (and corresponding EOA in Alchemy).

If you want to link multiple nodes to a single EOA, simply sign up each node using the same email address. You will get a new peer ID for each node, however they will all be linked to the same EOA that your email is linked to.

Please note: if you are using a fork of this repo, or a service organised by someone else (e.g. a ‘one click deployment’ provider) the identity management flow below is not guaranteed.

What this means

In the following two scenarios, everything will work (i.e. you will have an on-chain identity linked with your RL Swarm peer training):

The very first time you run the node from scratch with a new email address. The smart account will be created fresh and linked with the swarm.pem that is also fresh.
If you run it again with a swarm.pem AND login the original email address used with that swarm.pem. Note: this will throw an error into the log on registration but will still be able to sign transactions.

In the following two scenarios, it will not work (i.e. you won’t have an on-chain identity linked with your RL Swarm peer training):

If you keep your swarm.pem and try to link it to an email address distinct from the one with which it was first registered.

Therefore, you should do these actions in the following scenarios

Signed up with email address, generated swarm.pem, BUT lost swarm.pem OR You want to run multiple nodes at once: run from scratch with the same email address and generate a new swarm.pem.
Signed up with email address, generated swarm.pem, kept swarm.pem -> you can re-run a single node using this pair if you’ve still got them both.

Troubleshooting

How do I find my logs? You can find them inside the /logs directory:
- yarn.log: This file contains logs for the modal login server.
- swarm.log: This is the main log file for the RL Swarm application.
- wandb/: This directory contains various logs related to your training runs, including a debug.log file. These can be updated to Weights & Biases (only available if you log_with wandb).
My peer ‘skipped a round’: this occurs when your device isn’t fast enough to keep up with the pace of the swarm. For example, if you start training at round 100 and by the time you finish training the rest of the swarm reaches round 102, you will skip round 101 and go straight to 102. This is because your peer is more valuable if it is participating in the active round.
My model doesn’t seem to be training?
- If you’re using a consumer device (e.g. a MacBook), it is likely just running slowly - check back in 20 minutes.
Logging in with a new account after previous login?
- Make sure you click ‘Logout’ on the login screen before you leave your previous session
- Make sure you delete swarm.pem from the root directory (try sudo rm swarm.pem). If you don’t do this, and you previously registered with the peer-id stored in this file, it will disrupt the training process.
Issues with the Login screen
- Upgrade viem: some users report issues with the viem package. There are two fixes:
  - in the modal-login/package.json update: "viem": "2.25.0"
  - in the terminal cd /root/rl-swarm/modal-login/ && yarn upgrade && yarn add next@latest && yarn add viem@latest
I’m getting lots of warnings
- This is expected behaviour and usually the output of the package managers or other dependencies. The most common is the below Protobuf warning - which can be ignored
  1
  
  WARNING: The candidate selected for download or install is a yanked version: 'protobuf' candidate...
Issues on VMs/VPSs?
- How do I access the login screen if I’m running in a VM?: port forwarding. Add this SSH flag: -L 3000:localhost:3000 when connecting to your VM. E.g. gcloud compute ssh --zone "us-central1-a" [your-vm] --project [your-project] -- -L 3000:localhost:3000. Note, some VPSs may not work with rl-swarm. Check the Gensyn discord for up-to-date information on this.
- Disconnection/general issues: If you are tunneling to a VM and suffer a broken pipe, you will likely encounter OOM or unexpected behaviour the first time you relaunch the script. If you control + c and kill the script it should spin down all background processes. Restart the script and everything should work normally.
Issues with npm/general installation?
- Try npm install -g node@latest
OOM errors on MacBook?
- Try this (experimental) fix to increase memory:
  1
  
  export PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0
I have a Windows machine, can I still train a model on the swarm?: Yes - but this is not very well tested and may require you to do some debugging to get it set up properly. Install WSL and Linux on your Windows machine using the following instructions: https://learn.microsoft.com/en-us/windows/wsl/install
I want to move my to a different machine and/or restart with a fresh build of the repo, but I want my animal name/peer id to persist.: To achieve this simply backup the swarm.pem file on your current machine and then put it in the corresponding location on your new machine/build of the repo.
I have multiple GPUs on one machine, can I run multiple peers?: Yes - but you’ll need to manually change things. You’ll need to isolate each GPU, install this repo for each GPU, and expose each peer under a different port to pass the modal onboard.
My round/stage is behind the smart contract/other peers?: This is expected behaviour given the different speeds of machines in the network. Once your machine completes it’s current round, it will move to the the current round.
I want to use a bigger and/or different model in the RL swarm, can I do that?: Yes - but we only recommend doing so if you are comfortable understanding what size model can reasonably run on your hardware. If you elect to bring a custom model, just paste the repo/model name into the command line when prompted.
I am running a model in the swarm on my CPU, have received a python RuntimeError, and my training progress seems to have stopped.: There are several possible causes for this, but before trying anything please wait long enough to be sure your training actually is frozen and not just slow (e.g., wait longer than a single training iteration has previously taken on your machine). If you’re sure training is actually frozen, then some things to try are:
- Set this (experimental) fix: export PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0 && ./run_rl_swarm.sh

agent-squad

Fri, 09 May 2025 15:28:15 +0800

awslabs/agent-squad

Agent Squad

Flexible, lightweight open-source framework for orchestrating multiple AI agents to handle complex conversations.

📢 New Name Alert: Multi-Agent Orchestrator is now Agent Squad! 🎉
Same powerful functionalities, new catchy name. Embrace the squad!

📚 Explore Full Documentation

🔖 Features

🧠 Intelligent intent classification — Dynamically route queries to the most suitable agent based on context and content.
🔤 Dual language support — Fully implemented in both Python and TypeScript.
🌊 Flexible agent responses — Support for both streaming and non-streaming responses from different agents.
📚 Context management — Maintain and utilize conversation context across multiple agents for coherent interactions.
🔧 Extensible architecture — Easily integrate new agents or customize existing ones to fit your specific needs.
🌐 Universal deployment — Run anywhere - from AWS Lambda to your local environment or any cloud platform.
📦 Pre-built agents and classifiers — A variety of ready-to-use agents and multiple classifier implementations available.

What’s the Agent Squad ❓

The Agent Squad is a flexible framework for managing multiple AI agents and handling complex conversations. It intelligently routes queries and maintains context across interactions.

The system offers pre-built components for quick deployment, while also allowing easy integration of custom agents and conversation messages storage solutions.

This adaptability makes it suitable for a wide range of applications, from simple chatbots to sophisticated AI systems, accommodating diverse requirements and scaling efficiently.

🏗️ High-level architecture flow diagram

The process begins with user input, which is analyzed by a Classifier.
The Classifier leverages both Agents’ Characteristics and Agents’ Conversation history to select the most appropriate agent for the task.
Once an agent is selected, it processes the user input.
The orchestrator then saves the conversation, updating the Agents’ Conversation history, before delivering the response back to the user.

Introducing SupervisorAgent: Agents Coordination

The Agent Squad now includes a powerful new SupervisorAgent that enables sophisticated team coordination between multiple specialized agents. This new component implements a “agent-as-tools” architecture, allowing a lead agent to coordinate a team of specialized agents in parallel, maintaining context and delivering coherent responses.

Key capabilities:

🤝 Team Coordination - Coordonate multiple specialized agents working together on complex tasks
⚡ Parallel Processing - Execute multiple agent queries simultaneously
🧠 Smart Context Management - Maintain conversation history across all team members
🔄 Dynamic Delegation - Intelligently distribute subtasks to appropriate team members
🤖 Agent Compatibility - Works with all agent types (Bedrock, Anthropic, Lex, etc.)

The SupervisorAgent can be used in two powerful ways:

Direct Usage - Call it directly when you need dedicated team coordination for specific tasks
Classifier Integration - Add it as an agent within the classifier to build complex hierarchical systems with multiple specialized teams

Here are just a few examples where this agent can be used:

Customer Support Teams with specialized sub-teams
AI Movie Production Studios
Travel Planning Services
Product Development Teams
Healthcare Coordination Systems

Learn more about SupervisorAgent →

💬 Demo App

In the screen recording below, we demonstrate an extended version of the demo app that uses 6 specialized agents:

Travel Agent: Powered by an Amazon Lex Bot
Weather Agent: Utilizes a Bedrock LLM Agent with a tool to query the open-meteo API
Restaurant Agent: Implemented as an Amazon Bedrock Agent
Math Agent: Utilizes a Bedrock LLM Agent with two tools for executing mathematical operations
Tech Agent: A Bedrock LLM Agent designed to answer questions on technical topics
Health Agent: A Bedrock LLM Agent focused on addressing health-related queries

Watch as the system seamlessly switches context between diverse topics, from booking flights to checking weather, solving math problems, and providing health information. Notice how the appropriate agent is selected for each query, maintaining coherence even with brief follow-up inputs.

The demo highlights the system’s ability to handle complex, multi-turn conversations while preserving context and leveraging specialized agents across various domains.

🎯 Examples & Quick Start

Get hands-on experience with the Agent Squad through our diverse set of examples:

Demo Applications:
- Streamlit Global Demo: A single Streamlit application showcasing multiple demos, including:
  - AI Movie Production Studio
  - AI Travel Planner
- Chat Demo App:
  - Explore multiple specialized agents handling various domains like travel, weather, math, and health
- E-commerce Support Simulator: Experience AI-powered customer support with:
  - Automated response generation for common queries
  - Intelligent routing of complex issues to human support
  - Real-time chat and email-style communication
  - Human-in-the-loop interactions for complex cases
Sample Projects: Explore our example implementations in the examples folder:
- chat-demo-app: Web-based chat interface with multiple specialized agents
- ecommerce-support-simulator: AI-powered customer support system
- chat-chainlit-app: Chat application built with Chainlit
- fast-api-streaming: FastAPI implementation with streaming support
- text-2-structured-output: Natural Language to Structured Data
- bedrock-inline-agents: Bedrock Inline Agents sample
- bedrock-prompt-routing: Bedrock Prompt Routing sample code

Examples are available in both Python and TypeScript. Check out our documentation for comprehensive guides on setting up and using the Agent Squad framework!

📚 Deep Dives: Stories, Blogs & Podcasts

Discover creative implementations and diverse applications of the Agent Squad:

From ‘Bonjour’ to ‘Boarding Pass’: Multilingual AI Chatbot for Flight Reservations

This article demonstrates how to build a multilingual chatbot using the Agent Squad framework. The article explains how to use an Amazon Lex bot as an agent, along with 2 other new agents to make it work in many languages with just a few lines of code.
Beyond Auto-Replies: Building an AI-Powered E-commerce Support system

This article demonstrates how to build an AI-driven multi-agent system for automated e-commerce customer email support. It covers the architecture and setup of specialized AI agents using the Agent Squad framework, integrating automated processing with human-in-the-loop oversight. The guide explores email ingestion, intelligent routing, automated response generation, and human verification, providing a comprehensive approach to balancing AI efficiency with human expertise in customer support.
Speak Up, AI: Voicing Your Agents with Amazon Connect, Lex, and Bedrock

This article demonstrates how to build an AI customer call center. It covers the architecture and setup of specialized AI agents using the Agent Squad framework interacting with voice via Amazon Connect and Amazon Lex.
Unlock Bedrock InvokeInlineAgent API’s Hidden Potential

Learn how to scale Amazon Bedrock Agents beyond knowledge base limitations using the Agent Squad framework and InvokeInlineAgent API. This article demonstrates dynamic agent creation and knowledge base selection for enterprise-scale AI applications.
Supercharging Amazon Bedrock Flows

Learn how to enhance Amazon Bedrock Flows with conversation memory and multi-flow orchestration using the Agent Squad framework. This guide shows how to overcome Bedrock Flows’ limitations to build more sophisticated AI workflows with persistent memory and intelligent routing between flows.

🎙️ Podcast Discussions

🇫🇷 Podcast (French): L’orchestrateur multi-agents : Un orchestrateur open source pour vos agents IA
- Platforms:
  - Apple Podcasts
  - Spotify
🇬🇧 Podcast (English): An Orchestrator for Your AI Agents
- Platforms:
  - Apple Podcasts
  - Spotify

TypeScript Version

Installation

🔄 multi-agent-orchestrator becomes agent-squad

`1`	`npm install agent-squad`

Usage

The following example demonstrates how to use the Agent Squad with two different types of agents: a Bedrock LLM Agent with Converse API support and a Lex Bot Agent. This showcases the flexibility of the system in integrating various AI services.

import { AgentSquad, BedrockLLMAgent, LexBotAgent } from "agent-squad";

const orchestrator = new AgentSquad();

// Add a Bedrock LLM Agent with Converse API support
orchestrator.addAgent(
  new BedrockLLMAgent({
      name: "Tech Agent",
      description:
        "Specializes in technology areas including software development, hardware, AI, cybersecurity, blockchain, cloud computing, emerging tech innovations, and pricing/costs related to technology products and services.",
      streaming: true
  })
);

// Add a Lex Bot Agent for handling travel-related queries
orchestrator.addAgent(
  new LexBotAgent({
    name: "Travel Agent",
    description: "Helps users book and manage their flight reservations",
    botId: process.env.LEX_BOT_ID,
    botAliasId: process.env.LEX_BOT_ALIAS_ID,
    localeId: "en_US",
  })
);

// Example usage
const response = await orchestrator.routeRequest(
  "I want to book a flight",
  'user123',
  'session456'
);

// Handle the response (streaming or non-streaming)
if (response.streaming == true) {
    console.log("\n** RESPONSE STREAMING ** \n");
    // Send metadata immediately
    console.log(`> Agent ID: ${response.metadata.agentId}`);
    console.log(`> Agent Name: ${response.metadata.agentName}`);
    console.log(`> User Input: ${response.metadata.userInput}`);
    console.log(`> User ID: ${response.metadata.userId}`);
    console.log(`> Session ID: ${response.metadata.sessionId}`);
    console.log(
      `> Additional Parameters:`,
      response.metadata.additionalParams
    );
    console.log(`\n> Response: `);

    // Stream the content
    for await (const chunk of response.output) {
      if (typeof chunk === "string") {
        process.stdout.write(chunk);
      } else {
        console.error("Received unexpected chunk type:", typeof chunk);
      }
    }

} else {
    // Handle non-streaming response (AgentProcessingResult)
    console.log("\n** RESPONSE ** \n");
    console.log(`> Agent ID: ${response.metadata.agentId}`);
    console.log(`> Agent Name: ${response.metadata.agentName}`);
    console.log(`> User Input: ${response.metadata.userInput}`);
    console.log(`> User ID: ${response.metadata.userId}`);
    console.log(`> Session ID: ${response.metadata.sessionId}`);
    console.log(
      `> Additional Parameters:`,
      response.metadata.additionalParams
    );
    console.log(`\n> Response: ${response.output}`);
}

Python Version

🔄 multi-agent-orchestrator becomes agent-squad

# Optional: Set up a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows use `venv\Scripts\activate`
pip install agent-squad[aws]

Default Usage

Here’s an equivalent Python example demonstrating the use of the Agent Squad with a Bedrock LLM Agent and a Lex Bot Agent:

import sys
import asyncio
from agent_squad.orchestrator import AgentSquad
from agent_squad.agents import BedrockLLMAgent, BedrockLLMAgentOptions, AgentStreamResponse

orchestrator = AgentSquad()

tech_agent = BedrockLLMAgent(BedrockLLMAgentOptions(
  name="Tech Agent",
  streaming=True,
  description="Specializes in technology areas including software development, hardware, AI, \
  cybersecurity, blockchain, cloud computing, emerging tech innovations, and pricing/costs \
  related to technology products and services.",
  model_id="anthropic.claude-3-sonnet-20240229-v1:0",
))
orchestrator.add_agent(tech_agent)


health_agent = BedrockLLMAgent(BedrockLLMAgentOptions(
  name="Health Agent",
  streaming=True,
  description="Specializes in health and well being",
))
orchestrator.add_agent(health_agent)

async def main():
    # Example usage
    response = await orchestrator.route_request(
        "What is AWS Lambda?",
        'user123',
        'session456',
        {},
        True
    )

    # Handle the response (streaming or non-streaming)
    if response.streaming:
        print("\n** RESPONSE STREAMING ** \n")
        # Send metadata immediately
        print(f"> Agent ID: {response.metadata.agent_id}")
        print(f"> Agent Name: {response.metadata.agent_name}")
        print(f"> User Input: {response.metadata.user_input}")
        print(f"> User ID: {response.metadata.user_id}")
        print(f"> Session ID: {response.metadata.session_id}")
        print(f"> Additional Parameters: {response.metadata.additional_params}")
        print("\n> Response: ")

        # Stream the content
        async for chunk in response.output:
            async for chunk in response.output:
              if isinstance(chunk, AgentStreamResponse):
                  print(chunk.text, end='', flush=True)
              else:
                  print(f"Received unexpected chunk type: {type(chunk)}", file=sys.stderr)

    else:
        # Handle non-streaming response (AgentProcessingResult)
        print("\n** RESPONSE ** \n")
        print(f"> Agent ID: {response.metadata.agent_id}")
        print(f"> Agent Name: {response.metadata.agent_name}")
        print(f"> User Input: {response.metadata.user_input}")
        print(f"> User ID: {response.metadata.user_id}")
        print(f"> Session ID: {response.metadata.session_id}")
        print(f"> Additional Parameters: {response.metadata.additional_params}")
        print(f"\n> Response: {response.output.content}")

if __name__ == "__main__":
  asyncio.run(main())

These examples showcase:

The use of a Bedrock LLM Agent with Converse API support, allowing for multi-turn conversations.
Integration of a Lex Bot Agent for specialized tasks (in this case, travel-related queries).
The orchestrator’s ability to route requests to the most appropriate agent based on the input.
Handling of both streaming and non-streaming responses from different types of agents.

Modular Installation Options

The Agent Squad is designed with a modular architecture, allowing you to install only the components you need while ensuring you always get the core functionality.

Installation Options

1. AWS Integration:

`1`	`pip install "agent-squad[aws]"`

Includes core orchestration functionality with comprehensive AWS service integrations (BedrockLLMAgent, AmazonBedrockAgent, LambdaAgent, etc.)

2. Anthropic Integration:

`1`	`pip install "agent-squad[anthropic]"`

3. OpenAI Integration:

`1`	`pip install "agent-squad[openai]"`

Adds OpenAI’s GPT models for agents and classification, along with core packages.

4. Full Installation:

`1`	`pip install "agent-squad[all]"`

Includes all optional dependencies for maximum flexibility.

🙌 We Want to Hear From You!

Have something to share, discuss, or brainstorm? We’d love to connect with you and hear about your journey with the Agent Squad framework. Here’s how you can get involved:

🙌 Show & Tell: Got a success story, cool project, or creative implementation? Share it with us in the Show and Tell section. Your work might inspire the entire community! 🎉
💬 General Discussion: Have questions, feedback, or suggestions? Join the conversation in our General Discussions section. It’s the perfect place to connect with other users and contributors.
💡 Ideas: Thinking of a new feature or improvement? Share your thoughts in the Ideas section. We’re always open to exploring innovative ways to make the orchestrator even better!

Let’s collaborate, learn from each other, and build something incredible together! 🚀

📝 Pull Request Guidelines

Issue-First Policy

This repository follows an Issue-First policy:

Every pull request must be linked to an existing issue
If there isn’t an issue for the changes you want to make, please create one first
Use the issue to discuss proposed changes before investing time in implementation

How to Link Pull Requests to Issues

When creating a pull request, you must link it to an issue using one of these methods:

Include a reference in the PR description using keywords:
- Fixes #123
- Resolves #123
- Closes #123
Manually link the PR to an issue through GitHub’s UI:
- On the right sidebar of your PR, click “Development” and then “Link an issue”

Automated Enforcement

We use GitHub Actions to automatically verify that each PR is linked to an issue. PRs without linked issues will not pass required checks and cannot be merged.

This policy helps us:

Maintain clear documentation of changes and their purposes
Ensure community discussion before implementation
Keep a structured development process
Make project history more traceable and understandable

🤝 Contributing

⚠️ Note: Our project has been renamed from Multi-Agent Orchestrator to Agent Squad. Please use the new name in your contributions and discussions.

⚠️ We value your contributions! Before submitting changes, please start a discussion by opening an issue to share your proposal.

Once your proposal is approved, here are the next steps:

📚 Review our Contributing Guide
💡 Create a GitHub Issue
🔨 Submit a pull request

✅ Follow existing project structure and include documentation for new features.

🌟 Stay Updated: Star the repository to be notified about new features, improvements, and exciting developments in the Agent Squad framework!

Authors

👥 Contributors

Big shout out to our awesome contributors! Thank you for making this project better! 🌟 ⭐ 🚀

Please see our contributing guide for guidelines on how to propose bugfixes and improvements.

📄 LICENSE

This project is licensed under the Apache 2.0 licence - see the LICENSE file for details.

📄 Font License

This project uses the JetBrainsMono NF font, licensed under the SIL Open Font License 1.1. For full license details, see FONT-LICENSE.md.