Skip to main content
Powerboards is a (soon to be) open-source, AI-native app built entirely on MeshAgent. You can use Powerboards as-is to share your agents today, or adapt the source code into your own MeshAgent-powered application. Powerboards is included in your MeshAgent account and gives teams a shared space to collaborate, create, and grow together. While MeshAgent Studio is a great tool for developers building agents with MeshAgent, Powerboards is designed for your end users so they can easily interact with the agents you build from day one. Since the app will be open-source you can also adapt it to your needs! The fastest way to install an agent in Powerboards is from a link. When you click an install link:
  1. Powerboards prompts you to sign in or create an account.
  2. You select a Project and Room to deploy the agent.
  3. The agent is installed into the Room and ready to use!
Install links look like this: https://app.powerboards.com/install?url=SERVICE_TEMPLATE_SPEC_URL If you already have an install link you can start using the agent immediately, you don’t need to write any code or use the CLI. Just click the link and follow the prompts. The rest of this page explains how to make agents show up in Powerboards and package an agent so that it can be shared with an install link.

​
How agents get into Powerboards

Conversational agents (ChatBots and VoiceBots) deployed with MeshAgent can be used in Powerboards automatically. Once deployed, your agent appears in the Powerboards agents dropdown alongside the built-in defaults (assistant, voice, developer, transcriber) and users can install it into their Room. There are two ways to get agents into Powerboards:
  1. Share your agent with anyone via install link
    • Use a ServiceTemplate YAML file hosted publicly.
    • Anyone can click the link and install the agent into their own Project and Room. This allows you to easily share agents at scale.
  2. Deploy directly to a Room you control
  • Use a Service YAML file and the MeshAgent CLI.
  • You deploy the agent into a specific Room in a Project you own, then install it from the Powerboards UI.
Both approaches rely on the same core idea: Package your agent as a MeshAgent service, mark it as a ChatBot or VoiceBot, and expose a meshagent endpoint. Powerboards then makes it installable.

​
Prerequisites

Before sharing agents in Powerboards, you should understand: Use MeshAgent base images when possible. They are optimized for common scenarios and published to: Check out the optimzing containers documentation to learn more about improving agent/service start time for custom images. Use this path when you want anyone to be able to install your agent, even in Projects you don’t control. You will:
  1. Write a ServiceTemplate manifest that describes your agent.
  2. Host that YAML file at a URL accessible by the browser.
  3. Construct and share an install link that points to that URL.

​
1. Create a ServiceTemplate YAML

Your ServiceTemplate must include:
  • meshagent.service.id under annotations in the service metadata.
  • meshagent.agent.type set to ChatBot or VoiceBot.
  • A meshagent endpoint with the appropriate identity.
Example ServiceTemplate for an agent that always responds in Spanish
yaml
version: v1
kind: ServiceTemplate
metadata:
  name: spanish
  description: An agent that speaks spanish
  repo: 
  icon: 
  annotations:
    meshagent.service.id: spanish
agents:
- name: spanish
  description: 
  annotations:
    meshagent.agent.type: ChatBot
variables: []
ports:
- num: "*"
  type: http
  endpoints:
  - path: "/agent"
    meshagent:
      identity: spanish
      api: 
    mcp: 
  liveness: "/"
container:
  environment: 
  image: us-central1-docker.pkg.dev/meshagent-life/meshagent-public/cli:{SERVER_VERSION}-esgz
  command: "/usr/bin/meshagent/meshagent chatbot service --agent-name=spanish --image-generation=gpt-image-1 --require-read-only-storage --model=gpt-5.1 --rule='speak spanish' -rr=/agents/spanish/rules.txt"
  storage: 
external:

​
2. Host the template (recommended: GitHub Gist)

The easiest way to host a ServiceTemplate for Powerboards is using a GitHub Gist.
  1. Create a public or secret GitHub Gist (either is fine, as long as anyone with the link can read it).
  2. Paste your YAML.
  3. Name the file (for example meshagent.yaml).
  4. Save the gist.
  5. Click Raw and copy the raw file URL from the browser bar.
Powerboards loads the template from the browser, so the URL must be accessible over CORS.
Raw GitHub Gist URLs already work with CORS by default, so you don’t have to configure anything. You can also use any other public URL, but if you’re hosting it yourself you’ll need to make sure:
  • The YAML is publicly reachable.
  • The server allows cross-origin GET requests from the Powerboards web app.
Next add the link to your the raw file URL to the install part. https://app.powerboards.com/install?url=SERVICE_TEMPLATE_SPEC_URL Where SERVICE_TEMPLATE_SPEC_URL is the URL-encoded version of your YAML file’s URL (for example, the raw Gist URL). Now you can share the link with anyone! They will be prompted to choose a Project and Room to install their agent!

​
Path 2: Deploy an agent directly to your own Room

Use this path when you control the Project and Room and want to deploy an agent directly, without a public link. You will:
  1. Write a Service manifest that describes your agent.
  2. Deploy it to a Room with the MeshAgent CLI.
  3. Install it from the Powerboards UI.
  4. Invite teammates.

​
1: Package your agent

Create a service definition file (meshagent.yaml) that includes:
  • A meshagent.service.id under annotations in the metadata section
  • An agents entry with a valid meshagent.agent.type annotation (either ChatBot or VoiceBot).
  • Expose a meshagent endpoint in the ports section
These fields are what make the service show up as an installable agent in Powerboards. Example Agent Service YAML
meshagent.yaml
kind: Service
version: v1
metadata:
  name: chatbot
  description: "ChatBot with custom rules for Studio and Powerboards"
  annotations:
    meshagent.service.id: "meshagent.chatbot"  # required for agent to appear in Powerboards
agents:                                        # section required for agent to appear in Powerboards
  - name: chatbot
    annotations:
      meshagent.agent.type: "ChatBot"
ports:
  - num: "*"
    type: http
    liveness: "/"
    endpoints:
      - path: /agent
        meshagent:                             # section required for agent to appear in Powerboards
          identity: chatbot
container:
  image: "meshagent/cli:latest"                # use MeshAgent CLI image
  command: 
    "/usr/bin/meshagent/meshagent chatbot service
    --agent-name=chatbot
    --rule="You are a MeshAgent ChatBot running inside Powerboards. Powerboards is an AI-native collaboration app built entirely on MeshAgent, the operating layer for agentic AI. Use the same language the user is using; do not switch languages unless they do. If you need context about the room or project, ask concise follow-up questions first."  # optional: applies base rules to agent
    --room-rules=agents/chatbot/rules.txt   # optional: makes rules editable by room members
    --web-search"                          # optional: enable web search tool

​
2. Deploy the agent

Next deploy it to a specific room using the MeshAgent CLI
bash
meshagent service create --file meshagent.yaml --room myroom
Once deployed, the agent automatically appears in MeshAgent Studio where you can test it. It will also appear in Powerboards where room owners can choose to install it.

​
3. Install the agent in Powerboards

After deploying the agent, room owners can install it in Powerboards:
  1. Go to Powerboards
  2. Open your Room (myroom)
  3. Select the Agents dropdown —> Manage Agents —> Install agent
  4. Choose your deployed agent and install it.

​
4. Invite team members

Once your agent is installed, invite people to your Room to use the agent with you:
  1. Select the Room menu —> Permissions
  2. Invite users via email (they must be members of the project already or you must be a project admin to invite them)
  3. Invited users can instantly join the room and interact with your agents

​
Editable agent rules and collaboration in Powerboards

Powerboards lets Room members customize agent behavior together. The default agents (assistant, developer, voice) each have an editable rules.txt file in Room storage that users can edit to steer the agent’s behavior. When you create your own agents and share them in Powerboards, you control if and how editable those rules are. In the example above, we deployed a ChatBot to Powerboards using a Service YAML that points to the MeshAgent CLI image. You can pass tools and rules to the ChatBot by adding flags like --web-search and --rule to the meshagent chatbot service command. To enable collaboration on rules, use the --room-rules flag. This will add a rules.txt file for your agent to the room so that anyone in the Room can edit the agent’s rules. Rules options
  • --rule: Inline, non-editable rules baked into the service definition. Best for fixed instructions.
  • --room-rules: Allow team members to edit the agents rules as they work with it in the Room. Passing this flag will create a path in room storage (e.g., agents/chatbot/rules.txt) that room members can edit to customize agent behavior.
  • --rules-file: Reads a file baked into your Docker image (non-editable by room). Useful for custom images and fixed instructions.
Using --room-rules enables true collaboration - team members can refine the agent’s instructions during the session without redeploying the ChatBot service. Once the service is deployed (as described above) and installed in Powerboards (Agents → Manage agents → Install agent), Room members can edit the rules file (for example agents/chatbot/rules.txt) directly in Powerboards to customize the agent’s behavior.