Creating agents in Solace Agent Mesh

Solace Agent Mesh
1

Lets talk about the different ways to create agents in Solace Agent Mesh!

Whats your favourite method to create agents in Solace Agent Mesh? Comment below! :backhand_index_pointing_down:

Agents are the core intelligence units in Solace Agent Mesh, serving as specialized processing components that perform specific tasks and provide domain-specific knowledge or capabilities. They are build around ADK and leverage A2A protocol for standardized communication across the mesh.

Each agent is equipped with tools that enable it to accomplish user requests, from querying databases and calling external APIs to performing data analysis and generating visualizations. What makes Agent Mesh powerful is its flexibility: you can create agents in multiple ways depending on your use case, technical expertise, and deployment requirements.

For more information on agents and their anatomy, check out this blog post: Anatomy of Agents in Solace Agent Mesh

Regardless of which process you take to create an agent in Solace Agent Mesh, all agents share the same fundamental configuration components. Understanding these key elements will help you design effective agents:

  • Agent identity: name, description, and agent card that defines the agent’s capabilities
  • LLM model configuration: which language model the agent uses
  • Tools: built-in tools, custom Python functions, or MCP integrations
  • Instructions: the system prompt that defines the agent’s behavior and personality
  • Lifecycle functions: optional initialization and cleanup functions for resource management
  • Services: session management and artifact storage configurations

TLDR: Summary Table

The following table summarizes the different ways to create agents in Solace Agent Mesh

Method Distribution Deployment Best Use Case
1. CLI Standalone Agent Project-only Self-managed Quick prototyping, project-specific needs
2. CLI Plugin (Create) Python package Self-managed Reusable agents, team sharing
3. CLI Plugin (Add from Repository) Pre-built Self-managed Leverage existing community agents
4. Enterprise Agent Builder Kubernetes Automated Enterprise deployments, non-technical users
5. A2A Agent Remote HTTPS Hybrid Third-party integration, legacy systems

1. CLI: Scaffold Standalone Agent

The Solace Agent Mesh CLI provides a quick way to scaffold a new agent directly in your project using the sam add agent command.

sam add agent my-agent

You can also launch a guided browser-based interface by adding the --gui flag:

sam add agent my-agent --gui

This interface is particularly useful for developers who prefer guided forms over manual YAML editing. The browser interface opens at http://localhost:5002/?config_mode=addAgent and guides you through the agent creation process with forms for configuring the agent’s name, description, instructions, tools, and other settings. The UI generates the necessary configuration files and Python scaffolding based on your inputs.

This process creates the following structure in your project:

  • A YAML configuration file in your project’s configs/agents/ directory
  • Configuration that references shared_config.yaml for common settings like broker connection and model configurations

The CLI handles the scaffolding, allowing you to focus on implementing your agent’s specific logic and tools. After creation, you can customize the generated files to add custom tools, modify the system prompt, or adjust the agent’s behavior.

Best for: Quick prototyping, project-specific agents, and simple use cases.

For more details on understanding the core Agent architecture see the Creating Agents documentation.

2. CLI Plugin: Create Your Own with Custom Tools

If you need to build agents with custom tools that can be shared across multiple projects or with the community, creating an agent as a plugin is the recommended approach. Plugins are packaged as standard Python packages that can be installed using pip or other package managers.

To create a new agent plugin, use the sam plugin create command:

sam plugin create my-hello-agent --type agent

This creates a complete Python package structure with:

  • config.yaml configuration file
  • src/ directory containing your Python modules (tools and lifecycle functions)
  • pyproject.toml for dependency management and versioning
  • Standard Python project files

After developing your agent, you build it into a distributable wheel file:

sam plugin build

The resulting wheel file can be shared with others, published to PyPI, or distributed through a Git repository. This approach promotes code reuse and follows software engineering best practices for versioning and dependency management.

Best for: Reusable agents across projects, team and community sharing, enterprise asset libraries where agents are treated as standardized organizational assets.

To understand the difference between standalone agents and plugins in depth, check out the Plugins documentation.

3. CLI Plugin: Add from Repository

Instead of building agents from scratch, you can leverage pre-built agents (with custom tools) from the community or official Solace Core Plugins. The sam plugin add command installs agents and makes them available in your project.

sam plugin add <component-name> --plugin <plugin-name>

The --plugin flag accepts multiple sources:

  • Official core plugins: from the Solace Agent Mesh Core Plugins repository by name
  • Local path: Point to a plugin directory or wheel file on your filesystem
  • Git repository URL: Install directly from GitHub or other Git hosting services following the git+https://github.com/{user}/{repo}={dir_to_pyproject.toml} notation

Example using a Git repository:

sam plugin add my_ip --plugin git+https://github.com/solacecommunity/solace-agent-mesh-plugins#subdirectory=find-my-ip

If you only pass the plugin name without a source, the CLI first looks in the .sam directory for locally cached plugins, then checks the official core plugins repository.

Best for: Leveraging community-built or official agents without creating from scratch, accelerating development by reusing existing capabilities, and standardizing on proven agent implementations.

4. Enterprise Agent Builder

Solace Agent Mesh Enterprise provides a web-based Agent Builder with advanced features for creating, configuring, and deploying agents. This tool is designed for enterprise environments where agents need to be deployed to Kubernetes clusters.

Business Users can easily build their own agents without writing a line of code, while developers can code more sophisticated agents.

The Enterprise Agent Builder offers two creation paths:

AI-Assisted Creation

Describe what you want your agent to do in natural language, and the AI assistant suggests initial configuration values including:

  • Agent name and description
  • System instructions that define agent behavior
  • Recommended toolsets (Artifact Management, Data Analysis, Web)
  • Suggested connectors for databases and APIs

You can review and modify all AI-generated suggestions before finalizing the agent.

Manual Creation

Enter all configuration details yourself through structured forms that guide you through:

  • Agent details including name and description
  • Instructions that serve as the system prompt
  • Toolset selection from available built-in capabilities
  • Connector configuration for external data sources

Agents created through the Enterprise Agent Builder are deployed using the Agent Deployer in Kubernetes environments, providing automated lifecycle management and scalability.

Best for: Non-technical users who need to create agents without writing code, enterprise deployments with Kubernetes and Helm infrastructure, rapid visual configuration with optional AI assistance, and teams that require governance and standardized deployment processes.

For more information, see the Agent Builder documentation.

5. Connect External Agents via A2A Proxy

If you have existing agents that run on separate infrastructure or want to integrate third-party A2A-compliant agents, you can connect them to your mesh using a proxy. The proxy acts as a protocol bridge, translating between A2A over HTTPS (used by external agents) and A2A over Solace event mesh (used by agents in your deployment).

Enterprise UI Method

The Enterprise edition provides a guided wizard for connecting external agents. Navigate to the “Connect External Agent” feature and configure:

  • Agent URL and agent card location
  • Authentication settings (Bearer token, API key, OAuth 2.0)
  • Custom HTTP headers
  • Agent skills and capabilities

The wizard validates the configuration by fetching the agent card and guides you through deployment.

YAML Proxy Method

For manual configuration or advanced use cases, create a proxy configuration file:

apps:
  - name: my-a2a-proxy
    app_module: solace_agent_mesh.agent.proxies.a2a.app
    app_config:
      namespace: "myorg/production"
      proxied_agents:
        - name: "external-agent"
          url: "https://api.example.com/agent"
          authentication:
            type: "static_bearer"
            token: "${TOKEN}"

A single proxy can manage multiple external agents, each with its own URL, authentication, and timeout settings. The proxy handles agent discovery, authentication management, artifact flow, and task lifecycle management automatically.

Best for: Third-party agent integration, hybrid cloud architectures where agents run in different environments, legacy system integration, gradual migration scenarios, and maintaining service isolation while enabling collaboration.

For detailed proxy configuration options, see the Proxies documentation and Connect External Agents guide.

Note on connecting to external MCP tools

Every agent you create in Solace Agent Mesh has the capability to expose MCP tools. As mentioned in this community post MCP + Solace Agent Mesh: The Deep Dive, integrating MCP tools is as simple as adding a tool block with an MCP definition in the agent configuration.

Choosing the Right Approach

The best method for creating agents depends on your specific needs:

  • For rapid prototyping: Use CLI standalone agents or the Community Edition UI
  • For reusable components: Create agent plugins that can be shared and versioned
  • For leveraging existing work: Install agents from the core plugins repository or community
  • For enterprise deployments: Use the Enterprise Agent Builder with Kubernetes deployment
  • For integration scenarios: Connect external agents using proxies
  • For maximum control: Write YAML configurations manually

Each approach integrates seamlessly with the same Agent Mesh runtime, so you can mix and match methods based on your requirements. Start with the approach that matches your current needs, and evolve your agents as your use cases become more sophisticated.

For comprehensive guides and tutorials, visit the Solace Agent Mesh documentation.

If you made it this far, thanks for reading! Please comment on this post if you found this helpful and which method is your favourite.

Cheers,
Tamimi

5 Likes