Plugins
Your team’s best agent setup, on every machine
Package the skills and MCP servers your team relies on into a plugin. Assign it to the org, a squad, or named developers. Edgee writes it into each coding agent on the next launch, in the format that agent expects.
Delivered to Claude Code, Codex, OpenCode, CodeBuddy, and Crush.
$
Agents are only as good as the context you give them
Most teams already know what good looks like. The problem is getting it onto every machine, in every agent, and keeping it current.
The good setup lives on one laptop
Your best engineer has a review checklist, a migration playbook, and three MCP servers wired just right. Nobody else has any of it, and it leaves when they do.
Onboarding is a Slack thread
Copy this file into that folder, paste this server URL, restart the agent. Every new hire repeats it, half of them get it wrong, and nobody updates the thread.
Every agent wants a different format
Claude Code, Codex, and OpenCode each keep skills and MCP config in their own place and their own schema. A mixed fleet multiplies the work by the number of tools.
Anatomy of a plugin
Write it once. Every agent reads it.
A plugin is a named package of the conventions your team already follows. You author it in the console, and a per-agent preview shows exactly which files each assistant will receive.
Skills
Markdown instructions with a name, a description, and an optional "when to use". A review checklist, a release procedure, your house style for migrations. The agent loads them when the task calls for it.
MCP servers
Remote HTTP servers your team relies on, with no auth, static headers, or OAuth. Declared once in the plugin, written into each agent in the shape that agent expects.
Subagents and hooks are in early access for selected organizations.
Code review
code-review
When to use: before opening or approving a pull request
## Review checklist - Migrations are reversible - New endpoints have an auth test - No secrets in logs or fixtures
https://mcp.example.com/mcp
Claude Code preview
- ~/.edgee/plugins/<profile>/claude/
- code-review/
- skills/review-checklist/SKILL.md
- .mcp.json
Distribute “Code review”
Choose who receives this plugin on their next launch.
Whole organization
Every member of the organization
Squads
platform · payments
Members
Pick people by name or email
Distribution
Roll it out the way you roll out anything else
Saving a plugin and choosing who gets it are separate steps. Start with one squad, check the result, then widen it to the org.
Target the org, a squad, or named people
Start with one squad, check the result, widen later. Squad membership decides who gets what, so moving someone between squads moves their plugins with them.
Admins author, members receive
Only administrators create, edit, and assign plugins. A targeted member gets the plugin on their next launch and cannot opt out, so a standard stays a standard.
Everyone can see what they have
Members see the plugins assigned to them in the console and from the CLI. Nobody has to guess which version of the checklist their agent is running.
No secrets in skill text
MCP servers carry their own authentication mode. Credentials stay in the supported mechanism, not pasted into instructions that land on every machine.
Compatibility
One plugin, translated for each agent
Each coding agent keeps skills and MCP config in its own place and its own schema. The Edgee CLI writes the plugin where each one looks. Where an agent needs a different shape, the plugin is translated rather than dropped.
Skills:Delivered
claude --plugin-dir
MCP servers:Delivered
claude --plugin-dir
Skills:Delivered
CODEBUDDY_PLUGIN_DIRS
MCP servers:Delivered
CODEBUDDY_PLUGIN_DIRS
Skills:Delivered
CODEX_HOME mirror
MCP servers:Translated
codex -c mcp_servers.…
Skills:Delivered
opencode skills.paths
MCP servers:Translated
opencode mcp config
Skills:Delivered
crush options.skills_paths
MCP servers:Translated
crush mcp config
Skills:Not yet
MCP servers:Not yet
Skills:Not yet
MCP servers:Not yet
- Claude Code receives the plugin for the session only. Nothing is written to your own ~/.claude.
- Codex skills are delivered on macOS and Linux.
- MCP servers are remote HTTP endpoints, with no auth, static headers, or OAuth.
- Cursor and GitHub Copilot run through the relay, so there is no launch to attach a plugin to yet.
How it works
Three steps. No dotfiles repo. No install script per agent.
- 1
Author the plugin in the console
Give it a name and a description, then add skills and MCP servers. A per-agent file preview shows exactly what will land on disk for each assistant.
- 2
Assign it to the people who need it
Pick the whole organization, one or more squads, or named members. Saving content and choosing recipients are separate steps, so nothing ships by accident.
- 3
Developers launch as usual
On the next edgee launch, the CLI syncs every assigned plugin into the agent being started. No install step, no file to copy, no restart dance.
Check it from any machine
Developers and admins can see exactly what is assigned and what each agent receives. When an agent cannot take a component, the CLI says why instead of silently dropping it.
Read the plugins docs$
Shared dotfiles vs Edgee plugins
What sharing agent setup looks like before and after.
| Dotfiles and wikis | Edgee plugins | |
|---|---|---|
| Where the setup lives | Dotfiles, wikis, and Slack threads | One plugin, managed in the console |
| Getting it to a new hire | Copy-paste instructions | Assigned automatically on their next launch |
| Mixed agent fleet | Rewrite per tool, by hand | Written once, translated per agent by the CLI |
| Updating a skill | Ask everyone to pull again | Save once, every targeted launch picks it up |
| Who has what | Nobody knows | Recipients visible in the console and the CLI |
| Scope | All or nothing | Organization, squad, or named members |
Write the standard once. Ship it everywhere.
About 5 minutes to install. Works with your existing agent setup. No credit card.
Questions platform teams ask
Part of the Edgee Agent Gateway
The same CLI that delivers your plugins cuts the bill.
Edgee routes requests against the budgets you set, compresses what is left to send, and observes every session at team level. Routing and compression combined, up to 70% lower token costs.