# Solace Agent Mesh: an event-driven multi-agent framework that is now deprecated

> Solace Agent Mesh routes agent-to-agent traffic over a Solace event broker instead of direct HTTP calls. The Python repository is deprecated and will be archived, so the decision is whether to adopt it or the successor product.

**SolaceLabs/solace-agent-mesh** — An event-driven framework designed to build and orchestrate multi-agent AI systems. It enables seamless integration of AI agents with real-world data sources and systems, facilitating complex, multi-step workflows.

- Repository: https://github.com/SolaceLabs/solace-agent-mesh
- Website: https://solacelabs.github.io/solace-agent-mesh/
- Stars: 4,924 · Forks: 278
- Language: Python
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/solacelabs-solace-agent-mesh

## The problem Solace Agent Mesh was built for

Most multi-agent demos wire agents together with direct function calls or HTTP requests. That works until an agent is slow, a tool returns a large artifact, or you want three agents listening to the same event. Solace Agent Mesh takes the opposite approach: agents publish and subscribe through a Solace event broker, and the framework handles discovery and delivery. The README describes it as a standardized communication layer where agents delegate tasks to peers, share data and artifacts, and execute multi-step workflows with minimal coupling.

The intended audience is teams that already run Solace Platform infrastructure, or that need asynchronous, decoupled agent execution rather than a single process holding a conversation. The README names two concrete agent examples: a Database Agent that makes SQL queries, and a MultiModal Agent that produces images, audio and reports. The repository topics list A2A, MCP, RAG and enterprise, which reflects where the project aimed.

The important framing is that this Python repository is deprecated. The README states it is no longer under active development and will not receive new features, bug fixes or security updates, and that the repository will be archived read-only. The last push to the repository was on 2026-09-10, and the most recent release listed is 1.28.8 on 2026-08-28. A deprecation notice plus a successor product changes what a review of this code is for: it is a reference implementation and an existing-deployment concern, not a greenfield choice.

## How the event mesh sits between agents

The architecture stacks three layers. At the bottom is the Solace AI Connector (SAC), which connects Solace Platform event brokers to AI models and services. In the middle is Google's Agent Development Kit (ADK), which supplies the AI logic and tool integrations. Solace Agent Mesh sits on top, exposing what the README calls a Universal A2A Agent Host and using the Agent2Agent (A2A) Protocol for agent discovery and delegation.

The practical consequence is that an agent does not need a reference to its peers. It emits a task onto the broker, and whichever agent is subscribed and capable picks it up. An Orchestrator agent breaks complex tasks down and delegates the pieces, according to the README's description of agent orchestration. Gateways translate between the mesh and the outside world: the README lists REST API, a web UI and Slack, and notes that you can build your own.

This is a real architectural difference, not a packaging detail. Direct-call frameworks give you a stack trace when something fails; an event mesh gives you a broker topic and a delivery guarantee you have to reason about. The trade is decoupling and horizontal scale for observability that depends on your broker tooling. The README asserts scalability and reliability as outcomes, but it does not document failure semantics or delivery guarantees, so treat those as things to verify against Solace's own broker documentation rather than something this repository proves.

## Installing Solace Agent Mesh and running a first project

The README requires Python 3.10.16 through 3.13.x, pip, macOS, Linux or Windows with WSL, and an LLM API key from any major provider or a custom endpoint. pyproject.toml narrows the range to >=3.10.16,<3.14, so a Python 3.14 interpreter will not install it. Start by creating a project directory and a virtual environment.

```bash
mkdir my-sam && cd my-sam
python3 -m venv .venv && source .venv/bin/activate
```

Then check whether an older version is already present, because the README is explicit that upgrading is not officially supported and that you should uninstall and start from scratch instead.

```bash
sam -v
pip3 uninstall solace-agent-mesh
pip3 install solace-agent-mesh
```

Initialization runs through a browser-based tool. The README notes that this UI listens on port 5002, which is worth knowing if that port is already taken on your machine.

```bash
sam init --gui
```

Once the project is initialized, `sam run` starts it. The chat interface is served at http://localhost:8000, and the README's verification step is to open that address and ask a question. Adding components after the fact uses the same GUI pattern: `sam add agent --gui` creates a new agent, and `sam plugin add <your-component-name> --plugin <plugin-name>` installs an existing plugin. The repository also ships a Makefile with a `make dev-setup` target that requires uv, which is the path for working on the framework itself rather than building on it.

## The deprecation is the first thing to weigh

The README opens with a deprecation banner, and pyproject.toml carries the classifier "Development Status :: 7 - Inactive". That combination is unambiguous: this is not a project where you file an issue and wait for a patch. The banner states there will be no bug fixes or security updates, which matters more here than in a typical library because the dependency list is pinned to exact versions with CVE annotations. Several entries, including mcp==1.28.1, click==8.3.3, idna==3.15, jwcrypto==1.5.7 and python-liquid==2.2.1, carry comments naming specific CVEs fixed by the pin. Those pins were maintained while the project was active. They will not be maintained now.

There is a second constraint that is easy to miss. The framework is built on Solace Platform event brokers, so running it as designed means running broker infrastructure. The README's local quickstart gets you a working chat interface, but the event-driven architecture it describes is the point of the project, and that part depends on the broker. A team without Solace infrastructure is evaluating a framework whose central mechanism it cannot exercise.

Finally, the README directs new work elsewhere: a successor version documented at docs.solace.com, and a free edition of a desktop app. Anyone arriving at this repository today is arriving at a migration decision, whether they realize it or not.

## Where a direct-call framework is the better fit

The clearest alternative is to skip the mesh entirely and use Google's Agent Development Kit directly, since Solace Agent Mesh already builds on it. ADK gives you agent definitions and tool integrations in-process, with ordinary Python control flow between them. The difference is not quality, it is topology: with ADK alone, agent A calling agent B is a function call you can step through in a debugger. With Solace Agent Mesh, that call becomes a message on a broker, and the value you get in return is that A and B can be deployed, scaled and restarted independently.

If your agents all live in one service, run for seconds, and share memory, the mesh adds a broker dependency and an asynchronous failure mode without buying you much. If your agents are owned by different teams, run for minutes, or need to fan out to multiple consumers, the event-driven model is the reason to look at this project at all.

A second consideration is protocol. The project uses A2A for agent-to-agent discovery and MCP for tool access, with dependencies a2a-sdk[http-server]==0.3.7 and mcp==1.28.1 pinned. If your tooling already speaks one of those protocols, the integration surface is smaller than it looks. If you have standardized on something else, you are writing adapters against a codebase that will not accept upstream fixes.

## Licence and what the pinned dependencies imply

The project is Apache-2.0, both in the repository metadata and via the license classifier in pyproject.toml. That permits commercial use, modification and redistribution under the usual Apache terms, including the patent grant and the notice requirements. The repository also carries a THIRD_PARTY_LICENSES directory, which is where you would look for the obligations attached to the pinned dependencies. Nothing in the repository suggests a copyleft obligation, but the dependency set is large and pinned exactly, so a licence scan of those pins is a reasonable step before shipping.

One packaging detail deserves attention because it is unusual to see stated so plainly. The build system requires hatchling<1.32, and the comment in pyproject.toml explains why: version 1.32 defaults core metadata to 2.5, which current PyPI upload tooling rejects. That is a build-time constraint for anyone forking and republishing, not a runtime one. Combined with the deprecation, it means a fork is a real maintenance commitment: you inherit the dependency pins, the build constraint and the security patching that upstream has stopped doing.

## Conclusion

Adopt it only for evaluation, for reading the architecture, or to keep an existing deployment running; the README states the Python version will receive no new features, bug fixes or security updates, and pyproject.toml classifies it as Inactive. Do not start a new production system on it. Before committing to anything, check the successor documentation at docs.solace.com, confirm whether your Python version falls inside the pyproject.toml range of >=3.10.16,<3.14, and verify that your LLM provider works through the google-adk path the project pins.

## FAQ

### What is Solace Agent Mesh?

It is an open-source Python framework for building event-driven multi-agent AI systems, where specialized agents delegate tasks, share artifacts and run multi-step workflows over a Solace event broker. It is built on the Solace AI Connector and Google's Agent Development Kit, and uses the A2A protocol for agent-to-agent communication. The README states the Python version is now deprecated.

### What is mesh AI used for?

In this project, the mesh is the communication layer between agents. The README describes agents publishing tasks, delegating to peer agents, sharing data and artifacts, and connecting to interfaces such as REST, a web UI and Slack. The Orchestrator agent breaks complex tasks down and delegates the pieces.

### What is Solace in software?

Solace Platform is the event broker product the framework is built on. The README states that Solace Agent Mesh uses the event messaging of Solace Platform for scalability and reliability, and that the Solace AI Connector lets Solace Platform Event Brokers connect to AI models and services.

### What are the 7 types of AI agents?

The README does not define a taxonomy of agent types. It describes specific agents in this framework instead: an Orchestrator agent that breaks down and delegates tasks, a Database Agent that makes SQL queries, and a MultiModal Agent that creates images, audio files and reports.

### Who owns Solace software?

The repository is published by SolaceLabs, and pyproject.toml lists the author as SolaceLabs with the contact solacelabs@solace.com. The README points to Solace Platform and to docs.solace.com for the successor version.

## Sources

- [License: Apache-2.0](https://github.com/SolaceLabs/solace-agent-mesh/blob/main/LICENSE)
- [Project website](https://solacelabs.github.io/solace-agent-mesh/)
- [README](https://github.com/SolaceLabs/solace-agent-mesh/blob/main/README.md)
- [Releases](https://github.com/SolaceLabs/solace-agent-mesh/releases)
- [SolaceLabs/solace-agent-mesh on GitHub](https://github.com/SolaceLabs/solace-agent-mesh)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/solacelabs-solace-agent-mesh