An Open-Source Platform for Multi-Agent AI Orchestration

#ai #python #opensource

Bluemarz is a new python written AI framework; it’s also an open-source platform specifically designed for managing and orchestrating multiple AI agents. It brings a measure of scalability and flexibility that’s been lacking in the Ai open-source industry.

From its stateless architecture to its support for multiple language models (such as OpenAI, Anthropic Claude, and Google Gemini), Bluemarz offers a robust solution to meet enterprise needs around scalability, security, and privacy — all crucial for projects/organizations handling sensitive data and complex workflows. Let’s briefly dive into what makes Bluemarz a unique and powerful tool for developers looking to deploy Ai agents at scale.

Getting Started with Bluemarz

Installation: You can get Bluemarz running by installing it from GitHub using pip:

pip install git+https://github.com/StartADAM/bluemarz.git

Basic Workflow: Bluemarz introduces three main concepts: Agent, Session, and Assignment. These allow developers to set up a flexible workflow where multiple agents can interact within the same session, pulling from different LLMs as needed. Here’s an example of a simple session from its repo: https://github.com/StartADAM/bluemarz):

import bluemarz as bm
import asyncio

async def procedural_example():
    # Initialize an agent using OpenAI
    agent = bm.openai.OpenAiAssistant.from_id(api_key, assistant_id)

    # Start a session
    session = bm.openai.OpenAiAssistantNativeSession.new_session(api_key)

    # Assign the agent to the session
    task = bm.Assignment(agent, session)
    task.add_message(bm.SessionMessage(role=bm.MessageRole.USER, text="What can you do?"))

    # Run the task and display the result
    res = await task.run_until_breakpoint()
    print(res)

asyncio.run(procedural_example())

Key Benefits of Bluemarz

Bluemarz addresses significant limitations that other platforms like LangChain, LangGraph, and Chainlit haven’t fully solved, especially around multi-agent, multi-LLM support, and session scalability.

What Sets Bluemarz Apart

Stateless and Scalable: Running Bluemarz in a Kubernetes cluster or on any cloud platform is simple due to its stateless design, which doesn’t require session retention, thus enhancing scalability.
Multi-Agent Flexibility: You can assign multiple agents in a single session and add or remove agents dynamically. This means that if an AI agent for translation is needed mid-session, it can be added on the fly without interrupting ongoing conversations.
Enterprise-Ready Security: Bluemarz is built to fit into corporate environments, with compliance and privacy controls already accounted for.
Dynamic Agent Selection: Either through code or with an AI-powered Selector (coming soon), developers can manage agent workflows with ease, adding a layer of control over task assignment and performance.

Core Components

Providers: These are the LLMs Bluemarz supports, including OpenAI, Anthropic Claude, and Google Gemini, with the flexibility to work with on-premises models.

Sessions: Sessions represent interactions that are entirely stateless in Bluemarz, running and storing sessions within your LLM provider’s infrastructure.

Agents and Assignments: Agents can be defined and assigned to sessions dynamically. Bluemarz supports both manual and programmatic agent assignments, allowing real-time changes during active sessions.

Extending Bluemarz with Tools

One of the most powerful features of Bluemarz is the ability to define reusable tools. Tools extend the capabilities of LLMs by connecting them to external systems, data sources, or services. Here’s an example of a tool that converts Celsius to Kelvin:

class TemperatureConverter(bm.SyncTool):
    def __init__(self):
        self._spec = bm.ToolSpec.model_validate({
            "id": "convert_celsius_to_kelvin",
            "name": "Convert Celsius to Kelvin",
            "description": "Converts a temperature from Celsius to Kelvin",
            "toolType": "sync",
            "variables": {
                "temperature": {
                    "type": "string",
                    "description": "Temperature in Celsius",
                },
            },
        })

     def call(self, tool_call: bm.ToolCall) -> bm.ToolCallResult:
        temp_celsius = int(tool_call.arguments.get("temperature", "0"))
        kelvin = temp_celsius + 273.15
        return bm.ToolCallResult(tool_call=tool_call, text=str(kelvin))

Once defined, this tool can be used across different agents and sessions, providing a single point of configuration for any agent needing temperature conversions.

Real-World Use Cases for Bluemarz

Customer Support Automation: Bluemarz’s multi-agent support allows for agents specialized in different domains to collaborate in real-time within a single session, improving response times and relevance.
R&D: Devs can use Bluemarz to configure research sessions where agents access documents or datasets dynamically.
Cost Control and Optimization: Bluemarz’s agent flexibility means only the necessary agents are deployed, reducing compute costs for organizations.

Conclusion

If you’re looking to contribute to a new, powerful, and flexible, open-source solution check it out: https://github.com/StartADAM/bluemarz. Since its stateless, adaptable, and ready for corporate-grade deployments, it should be a great project on a portfolio and an easy win into contributing to the Ai band-wagon. Whether you’re orchestrating a single, complex task across multiple agents or need to ensure scalability and security, Bluemarz can provide the infrastructure to support and grow the AI agent ecosystem.