```
▄▀█ ▀▄▀ █▀▄▀█
█▀█ █ █ █ ▀ █
Agent Extension Manager by AgentXM
https://axm.sh | https://agentxm.ai
```
[](https://www.npmjs.com/package/axm.sh)
[](https://github.com/agentxm/axm/actions/workflows/ci.yml)
[](./LICENSE)
# Extension manager for coding agents and AI assistants
- Manage agent skills, subagents, MCP servers, rules, hooks, knowledge, and packs.
- Bundle extensions with packs to share workflows across projects, teams, and others.
- Switch effortlessly between coding agents, bringing your workflow with you. Avoid lock-in.
> [!WARNING]
> AXM is in **early alpha** testing. Capabilities and APIs may change. To report
> a problem or request a feature,
> [open an issue](https://github.com/agentxm/axm/issues/new/choose).
- **Multi-tool** — a unified context-engineering toolkit for managing skills,
subagents, MCP servers, rules, hooks, knowledge, and packs
- **Multi-agent** — share workflows across Claude Code, Codex, Cursor,
Gemini CLI, GitHub Copilot, OpenCode, and
[nearly 40 others](#supported-agents)
- **Cross-platform** — discover and distribute agent skills and extensions
across package ecosystems including JavaScript, Python, Java, .NET, Go,
Rust, Ruby, and more
## Installation
**Ask your agent to install AXM:**
```
Follow these install instructions to set up AXM: https://axm.sh/install.md
```
**macOS / Linux:**
```bash
curl -fsSL https://axm.sh/install.sh | sh
```
**Windows (PowerShell):**
```powershell
irm https://axm.sh/install.ps1 | iex
```
**Windows (CMD):**
```cmd
curl -fsSL -o install.cmd https://axm.sh/install.cmd && install.cmd
```
**Homebrew:**
```bash
brew install agentxm/tap/axm
```
**npm:**
```bash
npm install -g axm.sh
```
## Getting started
Initialize AXM in your project. AXM detects your installed agents and creates
root `axm.json`; acquired packages and accepted external resolutions are kept
in `agent_extensions/` and `axm.lock`, while `.axm/` is runtime scratch.
AXM leaves Git attributes and formatter policy to the repository; exclude
`agent_extensions/` from tools that rewrite files.
```bash
axm setup
```
See what's recommended for your project:
```bash
axm discover
```
Install an extension and AXM wires it into every agent in your workspace:
```bash
axm install @acme/skills/code-review
```
## Extension types
<!-- axm:extension-types-table -->
| Type | What it is | Governing standard |
| ------------------- | ---------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| **Skills** | Package reusable agent skills with SKILL.md metadata and instructions. | [Agent Skills](https://agentskills.io) |
| **MCP Servers** | Configure Model Context Protocol servers for agents. | [Model Context Protocol](https://modelcontextprotocol.io) |
| **Subagents** | Install specialized agent profiles into an agent's native subagent system. | — |
| **Rules** | Sync instruction files and distribute rule extensions that inject into them. | [AGENTS.md](https://agents.md) |
| **Hook extensions** | Install lifecycle hook extensions into an agent's native hook system. | — |
| **Knowledge** | Package portable Open Knowledge Format concept bundles. | [Open Knowledge Format 0.2](https://github.com/GoogleCloudPlatform/knowledge-catalog/blob/main/okf/SPEC.md) |
<!-- /axm:extension-types-table -->
**Packs** are the container type: a pack curates any of the above into one
bundle teams install and keep in sync, such as
`@acme/packs/frontend-tools` — the frontend guild's standard skills and
commands.
<!-- axm:extension-type-namespaces -->
Every type has its own subcommand namespace (`axm skills`, `axm mcps`, `axm subagents`, `axm rules`, `axm hooks`, `axm knowledge`, `axm packs`) sharing a common shape: `install`, `uninstall`, `list`, `update`, `new`, `publish`, plus `enable`/`disable` where it applies.
<!-- /axm:extension-type-namespaces -->
## Subcommands
Examples below use `skills`; the same shape applies to every type.
```bash
axm skills new my-skill # Scaffold a new skill
axm skills install @acme/skills/code-review
axm skills list
axm skills disable my-skill # Turn off without uninstalling
axm skills enable my-skill
axm skills import ./external-skill @acme/skills/my-skill
axm fork @acme/skills/code-review @me/skills/code-review-custom
axm skills publish # Publish authored skills
```
Installed and enabled skills are always materialized in `.agents/skills/` for
the agentskills.io format, plus any declared agent-native skill directories.
`axm packs` adds bundling commands:
```bash
axm packs add my-pack @acme/skills/code-review
axm packs add my-pack "effect-*" # Add all matching extensions
```
Run `axm --help` for the top-level command list, or `axm <command> --help`
for options on any subcommand.
## Workspace
Top-level commands work across every extension type and infer the target from
your input:
```bash
axm sync # Realize extensions declared by axm.json
axm install @acme/skills/code-review # Install a single extension
axm update # Pull latest versions
axm list # Inventory extensions across all types
axm list --outdated # Show extensions with available updates
axm list --deprecated # Show deprecated installed extensions
axm uninstall @acme/skills/code-review
axm adopt @acme/skills/retained-package # Make a canonical package authoritative
axm demote @acme/skills/review ./upstream # Explicitly return to external source management
axm lint # Report intrinsic workspace facts
axm sync --preview # Preview reconciliation without writing
axm sync # Reconcile desired, accepted, and observed state
axm upgrade # Update axm itself
```
## Publishing
Extensions publish to the registry in four steps.
```bash
axm skills new my-skill # 1. Scaffold
# 2. Author content in the scaffolded directory
axm lint # 3. Check the publish gate locally
axm publish # 4. Publish new authored versions; skip published ones
```
Authorship is derived from the exact intrinsic `workspace` settings source,
the project `owner`, the settings map key, the extension type, and the matching
manifest in that type's authored root. Bare, filtered, and explicit selections
publish only workspace-authored packages. Adopt a retained canonical package
when this workspace should own it, or fork an installed package to publish it
under a new identity.
AXM builds a deterministic archive from each selected authored package whose
version the Registry does not have yet. A version the Registry already has,
yanked included, is skipped as already published without being rebuilt or
validated, so bump the version (`axm version <fqn> patch`) to ship local edits.
Installed external packages represent the source identity recorded
in `axm.lock`. `axm lint` checks their current contents against that accepted
identity. Publication reads workspace-authored packages.
`axm lint` checks the same rules the registry enforces — see
[Lint](#lint) for details.
## Lint
`axm lint` evaluates workspace and per-extension invariants against a shared
rule catalog — the same one that drives the registry publish gate.
```bash
axm lint # Report findings against the current project
axm lint --fix # Apply every autofixable finding non-interactively
axm lint --scope user # Lint the user-scope workspace
axm lint --strict # Exit non-zero on warnings as well as errors
axm lint --json # Machine-readable findings envelope
```
Project scope is the default. Local `lint.rules` overrides in
`axm.json` affect `axm lint` only — the registry publish gate
remains authoritative.
## Authentication
Sign in to a registry to publish, install private extensions, or attribute
usage to your account:
```bash
axm login # Sign in to the default registry
axm login --device-code # Sign in from SSH or a headless machine
axm whoami # Show the current identity
axm logout
axm token --output token # Write only the current token to stdout
```
`axm login` starts a local loopback PKCE flow, prints a manual authorization
URL, and then tries to open your browser. SSH without a display, CI,
Codespaces, and Linux with none of `DISPLAY`, `WAYLAND_DISPLAY`, or `BROWSER`
set (WSL excepted) automatically sign in with a code and say why; pass
`--device-code` to select that flow explicitly. Signing in from your terminal
asks you to open a link that already carries the code and check that the page
shows the same code; it also offers the plain page for typing the code by hand
and counts down until the code expires. It never touches your clipboard on its
own: press `c` while it waits to copy the link — over SSH, through the terminal
(OSC 52) to the clipboard of the machine you are typing on. Retrying the
command, or running `axm login` after you stop waiting, picks up the same
unexpired request; use `--restart` only when you intentionally want to replace
it. `axm login --device-code --wait-for-human 300` starts or reuses the
request and waits up to 300 seconds in the same command; a bounded wait always
uses device-code sign-in.
`axm token create --output token` writes only a new token to stdout for a
pipe; `axm help environment` shows a guarded recipe for storing it.
A GitHub Actions job granted `permissions: id-token: write` needs no stored
secret: register its repository and workflow as a trusted publisher in
[AgentXM settings](https://agentxm.ai/u/settings/trusted-publishers), and AXM
exchanges the job's ID token for a short-lived workload token scoped to that
trusted publisher. `AXM_TOKEN` and `AXM_TOKEN_FILE` still take precedence, and
`AXM_TRUSTED_PUBLISHING=0` turns the exchange off. See
[Publishing from GitHub Actions](https://github.com/agentxm/axm/blob/HEAD/apps/cli/site-content/docs/quickstart.md#publishing-from-github-actions)
for a workflow, and `axm help environment` for the full credential order.
## Supported agents
AXM supports nearly 40 agents — Claude Code, Codex, Cursor,
Gemini CLI, GitHub Copilot, OpenCode, Windsurf, Cline, Continue, Roo, Goose,
and more. If your agent isn't there,
[open an issue](https://github.com/agentxm/axm/issues/new/choose) and we'll add it.
## Development
This is an Nx monorepo.
```bash
pnpm install # Install dependencies
pnpm build # Build all packages
pnpm test # Run tests
pnpm typecheck # Type check
pnpm lint # Lint
```
Use `pnpm build:affected`, `pnpm test:affected`, or `pnpm lint:affected` to
only operate on packages changed since `main`.
See [CONTRIBUTING.md](https://github.com/agentxm/axm/blob/HEAD/CONTRIBUTING.md) for the full development workflow.
---
**Open Agents, Open Standards, Open Source.**
## License
AXM is licensed under the [Functional Source License](https://fsl.software/) (FSL), a [Fair Source](https://fair.io) license that converts to a MIT license after two years.
FSL-1.1-MIT © 2025-2026 AgentXM, Inc. — see [LICENSE](https://github.com/agentxm/axm/blob/HEAD/LICENSE).
