Swarm

Swarm: Lightweight Multi-Agent Orchestration Framework

What is Swarm?

Swarm is an experimental, educational framework developed by OpenAI for exploring ergonomic, lightweight multi-agent orchestration. It focuses on making agent coordination and execution lightweight, highly controllable, and easily testable. Swarm achieves this through two primitive abstractions: Agents and handoffs.

Note: Swarm has been replaced by the OpenAI Agents SDK, which is a production-ready evolution of Swarm. It's recommended to migrate to the Agents SDK for production use cases.

How does Swarm work?

Swarm operates by enabling Agents to encompass instructions and tools. At any point, an Agent can choose to hand off a conversation to another Agent. These primitives are powerful enough to express rich dynamics between tools and networks of agents, allowing you to build scalable, real-world solutions.

Swarm Agents are powered by the Chat Completions API and are stateless between calls. The client.run() function implements a loop that:

1. Gets a completion from the current Agent.
2. Executes tool calls and appends results.
3. Switches Agent if necessary.
4. Updates context variables if necessary.
5. Returns if no new function calls are made.

Why choose Swarm?

Swarm explores patterns that are lightweight, scalable, and highly customizable by design. It is best suited for situations dealing with a large number of independent capabilities and instructions that are difficult to encode into a single prompt.

Key Features and Concepts

• Agents: Encompass instructions and tools. They can represent specific workflows or steps defined by instructions and functions.
• Handoffs: Agents can hand off execution to another Agent.
• Functions: Swarm Agents can call Python functions directly. Functions should usually return a string (values will be attempted to be cast as a string).
• Context Variables: Agents can access and update context variables, allowing them to maintain state and share information.
• Streaming: Swarm supports streaming responses, providing real-time updates.

How to use Swarm?

1. Installation:

   pip install git+ssh://git@github.com/openai/swarm.git
   

   or

   pip install git+https://github.com/openai/swarm.git
   

2. Instantiate a Swarm client:

   from swarm import Swarm
   
   client = Swarm()
   

3. Define Agents:

   from swarm import Agent
   
   agent_a = Agent(
       name="Agent A",
       instructions="You are a helpful agent.",
       functions=[transfer_to_agent_b],
   )
   
   agent_b = Agent(
       name="Agent B",
       instructions="Only speak in Haikus.",
   )
   
   def transfer_to_agent_b():
       return agent_b
   

4. Run the Swarm:

   response = client.run(
       agent=agent_a,
       messages=[{"role": "user", "content": "I want to talk to agent B."}],
   )
   
   print(response.messages[-1]["content"])
   

Who is Swarm for?

Swarm is an educational resource for developers curious to learn about multi-agent orchestration. It is suitable for those dealing with a large number of independent capabilities and instructions that are difficult to encode into a single prompt.

Examples

• basic: Simple examples of fundamentals like setup, function calling, handoffs, and context variables.
• triage_agent: Simple example of setting up a basic triage step to hand off to the right agent.
• weather_agent: Simple example of function calling.
• airline: A multi-agent setup for handling different customer service requests in an airline context.
• support_bot: A customer service bot which includes a user interface agent and a help center agent with several tools.
• personal_shopper: A personal shopping agent that can help with making sales and refunding orders.

Conclusion

While Swarm has been succeeded by the OpenAI Agents SDK, it remains a valuable educational resource for understanding multi-agent orchestration. It provides a foundation for building scalable and customizable AI workflows. The Agents SDK is a production-ready solution for developers seeking built-in memory management and retrieval, representing a significant evolution from Swarm.