  ▄▀█ ▀▄▀ █▀▄▀█
  █▀█ █ █ █ ▀ █
  Agent Extension Manager by AgentXM

  https://axm.sh | https://agentxm.ai

Extension manager for coding agents and AI assistants

Name: axm
Rating: 69.7 (1 reviews)
Author: agentxm

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 be included in the test user group, reach out to hello@agentxm.ai.

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
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:

curl -fsSL https://axm.sh/install.sh | sh

Windows (PowerShell):

irm https://axm.sh/install.ps1 | iex

Windows (CMD):

curl -fsSL -o install.cmd https://axm.sh/install.cmd && install.cmd

Homebrew:

brew install agentxm/tap/axm

npm:

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.yaml, while .axm/ is runtime scratch. AXM leaves Git attributes and formatter policy to the repository; exclude agent_extensions/ from tools that rewrite files.

axm setup

See what's recommended for your project:

axm discover

Install an extension and AXM wires it into every agent in your workspace:

axm install @acme/skills/code-review

Extension types

Type	What it is	Governing standard
Skills	Package reusable agent skills with SKILL.md metadata and instructions.	Agent Skills
MCP Servers	Configure Model Context Protocol servers for agents.	Model Context Protocol
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
Hooks	Install lifecycle hook extensions into an agent's native hook system.	—
Knowledge	Package portable Open Knowledge Format concept bundles.	Open Knowledge Format 0.2

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.

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.

Subcommands

Examples below use skills; the same shape applies to every type.

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:

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:

axm install                          # Sync extensions from 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.

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; verify existing 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. For an existing immutable version, --on-existing verify rebuilds that archive and requires its SHA-512 digest to match the Registry release before reporting a successful no-op. Installed external packages represent the source identity recorded in axm-lock.yaml. 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 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.

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

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 use device-code sign-in and say why; pass --device-code to select that flow explicitly. Device-code sign-in shows the one-time code, the link that already carries it, the plain verification page, and the expiry. 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 reuses 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, 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 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 and we'll add it.

Development

This is an Nx monorepo.

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 for the full development workflow.

Open Agents, Open Standards, Open Source.

License

AXM is licensed under the Functional Source License (FSL), a Fair Source license that converts to a MIT license after two years.

axm

PLUG IN

README