Team packages

A team package is a single definition of a team: its bots, their skills, the channels they work in, their playbooks and routines, and what the team needs to run. Every team in Murage's team library is a package, and so is every team you export. Because it's one format, a team you build and export can travel exactly like a library team.

For the everyday steps of sharing a team with staff, see Share a team with your staff. This page explains what's inside the file.

Three ways to hold a package#

• JSON: the raw definition. Files in Murage's library are JSON.
• ZIP package (.zip): the definition plus skill instructions, skill files and routines. Best for sharing with staff.
• EmberBot Markdown (.emberbot.md): a readable version, with frontmatter that starts emberbot: 1 and sections for the mission, roles, coordination and so on. Good for reading and for putting in a GitHub repository.

All three import the same way, and they all describe the same underlying format.

The top of the file#

A JSON package starts like this:

{
  "format": "murage.package",
  "version": 1,
  "package": {
    "id": "founder-setup",
    "release": "1.0.0",
    "name": "Founder Setup",
    "tagline": "A practical setup plan for a new business.",
    "summary": "For founders establishing a new business...",
    "category": "Run",
    "author": { "name": "Ferrox Labs", "url": "https://murage.ai" },
    "license": "Apache-2.0",
    "outcomes": ["A founder-ready starter pack."],
    "setupMinutes": 2,
    "requirements": { "apps": [], "capabilities": [] },
    "agents": [ ... ],
    "rooms": [ ... ],
    "playbooks": [ ... ]
  }
}

Package fields#

• format and version: always murage.package and 1. Anything else is refused with "This is not a Murage package" or "Package version is not supported".
• id: a lowercase slug, such as founder-setup.
• release: the package's own version, as three numbers (1.2.0). Raise it each time you send out an update, so people importing it can see what changed.
• name, tagline (up to 160 characters) and summary (up to 2,000): what people see when they browse or preview.
• category: the shelf it sits on, such as Run, Sell or Research.
• author: a name and an optional web address.
• license: the license you're sharing it under. Library packages use Apache-2.0.
• outcomes: one to twelve short lines on what the team delivers.
• setupMinutes: a rough setup time, from 1 to 240.
• tags and featured: optional.
• examples: optional sample inputs and outputs, up to twelve.

Requirements

requirements tells people what the team needs before they import it. Murage shows this in the preview.

• apps: connected apps the team uses. Each has a slug, a label, a reason (why the team needs it) and an optional optional: true. Up to 30.
• capabilities: other things it needs, as short text. Up to 20.
• platforms: optional, the systems it's meant for.

Requirements are a description, not a grant. Importing a package never connects an app or signs anyone in.

Agents (the bots)

agents lists the bots, from 1 to 200. Each has:

• key: a short internal id, lowercase, used to refer to the bot elsewhere in the file.
• name, title and description. The description is the bot's instructions, up to 4,000 characters.
• appearance: a color (green, blue, red, orange, purple, cyan, pink, yellow, teal or coral), plus an optional mascot expression and body.
• skills: the skill ids the bot uses.
• playbooks: the playbook keys the bot uses.
• role and team: optional. Role can be individual, member, leader or chief. It records intent only; importing never gives a bot authority to coordinate others.

A package can also name a chiefOfStaff. On import, that bot arrives as an ordinary bot and your current Chief stays in charge.

Rooms (channels)

rooms sets up group channels, up to 30. Each has a key, a name, its members (bot keys), an optional bulletin (the channel's standing brief, up to 12,000 characters) and a defaultResponder, which decides who answers a message in the channel:

• { "kind": "mentions" }: whoever is mentioned;
• { "kind": "everyone" }: every member;
• { "kind": "agent", "agent": "<key>" }: one named bot.

Playbooks

playbooks are instructions that only load when a message matches them, so they don't crowd every turn. Each has a key, a name, a summary, one to thirty triggers (the words that bring it in) and the instructions, up to 24,000 characters. At most three playbooks join any one turn.

Routines

routines are schedules, up to 50. Each names the bot (agent), a prompt, where it runs (runOn) and a schedule:

• once at a set time;
• daily at an HH:MM time on chosen weekdays (0 is Sunday);
• interval, every 5 to 1,440 minutes.

Each routine also has a run duration (5 to 240 minutes). enabledAfterInstall must be false: a routine always arrives paused, and the person who imported it switches it on.

Build a package

The easiest way is to build the team in Murage and export it:

1. Set up the bots, write their instructions, add skills, channels and routines, and use the team on real work.
2. Choose + in the sidebar, then Export bots….
3. Pick ZIP package (.zip) or Markdown (.md), tick the bots (or Select team), then tick the skill instructions, skill files and routines to include.
4. Choose Preview selection, read the review, and download.

You can also write or edit the JSON by hand. Keep keys lowercase, keep every bot key referenced by rooms and routines, and raise release when you change it.

What a package never holds

Credentials, conversations, memory, permission grants, engine sessions and connected accounts are never exported. Murage scans exports for known secret patterns, such as API keys, and blocks the export if it finds one. The scan only knows patterns, so read the file before you share it.

Preview and import

1. Choose +, then New Team, then Open a file…, and pick the JSON, ZIP or Markdown file. A GitHub link to a repository with an EmberBot.md at its root also works.
2. Under Import selected package contents, tick the Bots, Skills, Instructions and Routines you want.
3. Choose Preview selection. The preview lists the members, what the team needs and anything left out.
4. Choose Import package.

After import, every bot has a fresh identity and starts on Ask. Skills arrive switched off and routines arrive paused. No apps, computers or Chief role are granted. If you import a newer release of a package you've imported before, Murage shows a Package version comparison of what was added, changed or left out. The import adds a new copy, so nothing you changed locally is overwritten.

Beyond your own staff

Because the team library and your exports use the same format, a package you build can be shared like any other file or published in a repository. A public hub for browsing and publishing packages isn't part of Murage yet. To offer a team for Murage's built-in library, see Writing a skill or team for the library.