CLI Commands

Structured Help

Add --json to any help invocation to return machine-readable command metadata instead of terminal-formatted help:

allagents --help --json
allagents mcp --help --json
allagents mcp add --help --json

Structured help is progressively disclosed:

1. Root help returns a concise index of top-level commands and groups.
2. Group help returns only its immediate commands and nested groups.
3. Each index entry provides a help_command for the next level.
4. Leaf help returns the complete contract: when to use the command, positionals, options, examples, interaction requirements, expected output, output schema, and JSON field allowlist.

This keeps command discovery small while making side effects, automation requirements, and output expectations available before execution. --help --json and --json --help are equivalent when they follow the command path. Field selection with --json=<fields> is not supported for help output.

Top-Level Commands

allagents update [--offline] [--dry-run] [--client <client>] [--profile <name>...]
allagents status

update

Updates plugins in the workspace using non-destructive sync. By default, remote plugins are updated to their latest version. Also available as allagents workspace update or allagents workspace sync.

Flag	Description
--offline	Use cached plugins without fetching latest from remote
--dry-run	Preview changes without applying them
-c, --client <client>	Sync only the specified client (e.g., opencode, claude)
--profile <name>	Reconcile only this installed global profile; repeatable

Ordinary user, installed profile, and current project reconciliation are selected automatically; allagents update does not take a scope flag.

Without --profile, update independently attempts the user workspace, every installed profile that still has a declaration, and the current project workspace, in that order. A failure in one pass does not skip later passes, but the command exits nonzero after all applicable work completes.

Using one or more --profile filters validates the entire selected set before mutation, updates only those installed and still-declared profiles, and skips ordinary user and project sync. --profile cannot be combined with --client.

Non-destructive behavior:

• First sync overlays files without deleting existing user files
• Subsequent syncs only remove files previously synced by AllAgents
• User files (not from plugins) are never deleted

Sync state is tracked in .allagents/sync-state.json.

For clients configured with native install mode, sync first inspects the real client inventory, then delegates only the required scoped install, update, or removal. Pi package and OMP marketplace-plugin effects are included in human and JSON output. Native state is tracked separately from copied files so AllAgents only removes resources whose ownership it can corroborate.

When vscode is in the clients list, sync also generates a .code-workspace file with repository paths resolved to absolute paths. See the Workspaces guide for details.

profile

allagents profile install <name> [--yes] [--dry-run] [--offline]
allagents profile list
allagents profile status [name]
allagents profile remove <name> [--yes] [--dry-run] [--offline]

Profile declarations exist only in ~/.allagents/workspace.yaml. install and remove display a complete plan before mutation and require confirmation; scripts and JSON mode must pass --yes. --dry-run emits the same resolved plan without writing profile state, client files, native package state, or launchers.

list inventories every declared profile plus installed profiles whose declaration is missing. It never opens a selector or changes files or native state. Human and JSON output include overall status, declared and installed state, clients, and each launcher’s client, name, absolute path, and PATH status.

status remains the detailed single-profile diagnostic for declared, installed, missing, drifted, partial, unsupported, and declaration-missing resources. Omitting the name opens a selector only on an interactive terminal; non-interactive and JSON callers must provide it.

Removal works from ownership state even after the declaration is deleted. It deletes only unchanged managed resources, releases referenced resources, and retains modified, shared, failed, or uncorroborated resources for inspection and retry. There is intentionally no allagents profile update; use repeatable allagents update --profile <name>.

status

Show the sync status of all configured plugins and skills.

allagents status

Lists every configured entry with its availability, type, and configured clients. Each entry includes a Type label of either plugin or skill:

• plugin — standard plugin repository (has a skills/ directory or no SKILL.md at the root)
• skill — standalone skill repository (root-level SKILL.md, no skills/ subdirectory)

With --json, each entry in the plugins array includes a kind field ("plugin" or "skill"):

{
  "plugins": [
    { "source": "owner/repo", "type": "github", "kind": "skill", "available": true }
  ],
  "clients": ["claude"]
}

allagents workspace status is accepted as a backwards-compatible alias.

Workspace Commands

allagents workspace init <path> [--from <source>]
allagents workspace setup
allagents workspace status  # alias for `allagents status`
allagents workspace plugin install <plugin@marketplace> [--scope <scope>]
allagents workspace plugin remove <plugin> [--scope <scope>]

workspace init

Initialize a new workspace from a template:

Flag	Description
--from <source>	Copy workspace.yaml from local path or GitHub URL

Source formats:

• Local path: ./path/to/template or /absolute/path
• GitHub URL: https://github.com/owner/repo/tree/branch/path
• GitHub shorthand: owner/repo/path or owner/repo

When using a GitHub source, AllAgents fetches workspace.yaml from .allagents/workspace.yaml or workspace.yaml in the target path.

workspace setup

Run setup entries from .allagents/workspace.yaml that match the current platform and architecture:

allagents workspace setup

This explicit action is the only path that executes setup commands. workspace init, update, and workspace sync never run them because workspace templates may come from untrusted remote sources. Review every command before running setup.

String entries run everywhere. Object entries may restrict execution with platforms using Node platform names such as linux, darwin, and win32, and with architectures using names such as x64 and arm64. When both are present, both must match. Nonmatching commands are reported as skipped.

Matching commands are shown immediately before they run, execute sequentially from the workspace root with inherited terminal I/O, and stop on the first nonzero exit or terminating signal.

With --json, stdout contains one deterministic result document preserving declaration order. Each entry reports succeeded, failed, or skipped, its nullable exit code and signal, and a skip reason when applicable. Command announcements and command output are forwarded to stderr.

workspace plugin install / remove

Flag	Description
-s, --scope <scope>	Installation scope: project (default) or user

When --scope user is used, the plugin is added to the user-level config at ~/.allagents/workspace.yaml instead of the project workspace. User-scoped plugins sync to user directories (~/.claude/, ~/.codex/, etc.) and are available across all projects.

Self Commands

allagents self update [--npm] [--bun]

self update

Update AllAgents to the latest published version.

Flag	Description
--npm	Force update using npm
--bun	Force update using bun

If neither flag is provided, AllAgents auto-detects the package manager used during installation.

Automatic Update Notifications

When running the interactive TUI (allagents with no arguments), AllAgents checks the npm registry for newer versions in the background. If an update is available, a notice is shown on the next startup:

allagents v0.13.4

  ℹ Update available: 0.13.4 → 0.14.0
    Run `allagents self update` to upgrade.

The check runs at most once every 24 hours and never blocks startup. Results are cached at ~/.allagents/version-check.json.

Plugin Commands

allagents plugin list
allagents plugin validate <path>
allagents plugin install <plugin> [--skill <name>] [--scope <scope>] [--client <clients>] [--yes]
allagents plugin uninstall <plugin> [--scope <scope>]
allagents plugin marketplace add <source> [--name <name>] [--branch <branch>]
allagents plugin marketplace list
allagents plugin marketplace remove <name>
allagents plugin marketplace update [name]
allagents skill list [--scope <scope>]
allagents skill remove <skill> [--plugin <plugin>] [--scope <scope>]
allagents skill add <skill> [--from <source>] [--plugin <plugin>] [--scope <scope>] [--client <clients>] [--yes]
allagents skill update [skill...] [--scope <scope>] [--yes]

plugin list

List installed plugins and standalone skills from user and project scopes.

allagents plugin list

Human-readable output keeps plugin@marketplace as the heading for marketplace entries and uses a friendly final-segment name for direct GitHub and local entries. Every entry retains Type and Scope; Clients appears when at least one configured file target or tracked native installation is present. Direct entries also show a compact effective Source, including a configured Git ref; marketplace entries omit that redundant line. Native clients are labeled explicitly, such as native claude.

With --json, each entry includes the friendly name, raw configured spec, marketplace, scope, and kind, plus clients and nativeClients when present. Internal effective sources, refs, versions, and status are not exposed:

{
  "success": true,
  "command": "plugin list",
  "data": {
    "plugins": [
      {
        "name": "research",
        "spec": "https://github.com/acme/toolbox/tree/main/plugins/research",
        "marketplace": "",
        "scope": "project",
        "kind": "plugin",
        "clients": ["codex"]
      }
    ],
    "total": 1
  }
}

plugin install

Install a plugin, then sync the selected scope.

Flag	Description
-s, --scope <scope>	Installation scope: project or user
-c, --client <clients>	Comma-separated clients for this plugin
-y, --yes	Skip the final install confirmation
--skill <name>	Only enable specific skills from the plugin (can be repeated)

On an interactive terminal, omitted target flags open scope and client choosers. AllAgents then shows the config path, clients, effective install methods, and targeting behavior; confirmation defaults to Yes, so Enter continues with the displayed plan. --scope and --client bypass only their respective choosers. --yes skips only the final confirmation.

JSON, CI, and non-TTY runs never prompt. Omitted target flags retain the command’s deterministic defaults. A new scope uses the selected clients as its top-level clients list; otherwise, a plugin-level clients override is written only when the selection differs from the scope default.

--skill <name>

Only enable specific skills from the plugin. Can be specified multiple times:

allagents plugin install superpowers@marketplace --skill brainstorming --skill tdd

When used, all other skills from the plugin are implicitly disabled. Skills can be added later with skill add.

When the selected client uses native install mode, this command validates the runtime, source, scope, and live inventory before editing workspace.yaml. Supported native resources include Pi npm/Git/local packages and OMP marketplace plugins. Use plugin@owner/marketplace-repository or plugin@https://github.com/owner/marketplace-repository for OMP. Both forms use the normal marketplace registration flow; the URL form is normalized to the canonical GitHub source before registration and deduplication.

skill list

List all skills from installed plugins with their enabled/disabled status.

Flag	Description
-s, --scope <scope>	Scope: project (default) or user

skill remove

Disable a skill, preventing it from being synced to the workspace.

Flag	Description
-p, --plugin <plugin>	Plugin name (required if skill exists in multiple plugins)
-s, --scope <scope>	Scope: project (default) or user

After disabling, the skill is added to disabledSkills in workspace.yaml and sync is run to remove it.

skill add

Add skills from a GitHub repo, re-enable a previously disabled skill, or add a skill from a specific plugin. The positional argument is interpreted by context:

Flag	Description
-f, --from <source>	Plugin source (GitHub URL, owner/repo, or plugin@marketplace) to install if the skill is not already available
--skill <names>	Comma-separated skill names to install when the positional is a plugin source
--all	Install every skill from the source
--list	List available skills at the source without installing
-p, --plugin <plugin>	Plugin name (required if skill exists in multiple plugins)
-s, --scope <scope>	Installation scope for a new source: project or user
-c, --client <clients>	Comma-separated clients for a new source-backed declaration
-y, --yes	Skip the final install confirmation

When this command introduces a source-backed declaration, it uses the same interactive target review as plugin install: scope, config path, clients, effective install methods, targeting behavior, and a final confirmation that defaults to No. Explicit --scope and --client values bypass those choosers; --yes skips only confirmation. JSON, CI, and non-TTY runs remain prompt-free.

These target options do not apply when merely re-enabling a skill from an already installed plugin; that path preserves the existing declaration.

Skill-first: install all skills from a repo

Pass owner/repo directly with no flags — all skills in that repo are installed automatically. This mirrors how npx skills add treats a package as a transport for its skills, not a named entity:

# Install all skills from a repo (standalone skill or multi-skill bundle)
allagents skill add ReScienceLab/opc-skills
allagents skill add https://github.com/owner/repo
allagents skill add gh:owner/repo

This works for:

• Standalone skill repos — a single SKILL.md at the root (no skills/ subdirectory)
• Multi-skill bundles — repos with a skills/ directory containing multiple skill files

Use --list first to preview what’s available before installing:

allagents skill add ReScienceLab/opc-skills --list

Installing a specific named skill

To install only one skill from a multi-skill repo:

allagents skill add reddit --from ReScienceLab/opc-skills
allagents skill add ReScienceLab/opc-skills --skill reddit

To install multiple by name:

allagents skill add ReScienceLab/opc-skills --skill reddit,terraform

To install a skill from a specific file URL:

allagents skill add https://github.com/owner/repo/tree/main/skills/my-skill

Re-enabling a disabled skill

allagents skill add brainstorming
allagents skill add brainstorming --plugin superpowers

After enabling, the skill is removed from disabledSkills and sync is run to restore it.

skill update

Check installed remote skills for upstream changes, update surviving skills, and safely reconcile skills that were deleted upstream.

allagents skill update
allagents skill update code-review glow-api
allagents skill update --scope user
allagents skill update --scope all
allagents skill update --yes
allagents --json skill update --scope project

Argument or flag	Description
[skill...]	Update only the physical sources containing the named enabled skills. Names, qualified paths, and plugin:path selectors are accepted. All enabled siblings sharing a selected source are still checked for deletion safety.
-s, --scope <scope>	Scope: project (default when a project config exists), user, or all.
-y, --yes	Run without prompts. This does not authorize deletion: a source with upstream deletions is retained and skipped.

AllAgents performs a read-only preflight against disposable checkouts before changing a config or plugin cache. When an installed skill has disappeared upstream, interactive terminals list the affected skill copies and ask once for the shared physical source:

• Yes removes the deleted skill selectors or standalone skill entries, advances that source to the inspected revision, and updates its surviving skills.
• No keeps the local copies and skips every update from that physical source, including survivor updates.
• Cancelling any confirmation stops the whole operation before the first mutation.

Non-interactive runs—including --yes, redirected input/output, CI, and --json—behave like No for sources with deletions. This makes unattended updates safe by default. Sources without deletion candidates can still update normally.

Plugin subpaths, marketplace entries, and project/user installs can share one physical cache. A decision therefore applies to the complete connected cache unit rather than only the config spelling that selected it. If an update in one scope would affect a deleted skill in an unselected scope, AllAgents keeps the cache unchanged and asks you to rerun with --scope all. A failed or declined unit does not prevent independent physical sources from updating.

After accepted caches advance, AllAgents syncs affected clients from those exact cached revisions in offline mode. Declined caches are not refreshed indirectly by the final sync.

With --json, each physical source result has one of these statuses:

Status	Meaning
updated	The source advanced and surviving skills were synced; no deletion was required.
removed	Confirmed deleted skills were removed and surviving skills were updated.
retained	Deleted local copies were kept, so the complete shared source was left unchanged.
skipped	A physical update unit was intentionally skipped without an operational failure.
failed	Preflight, transaction, or offline sync failed for this source. Independent sources may still succeed.
cancelled	Confirmation was cancelled before any changes were made.

Local plugin sources are listed separately in data.skippedLocalSources. The JSON summary reports per-skill updated, removed, and retained counts plus physical-source skipped, failed, and cancelled counts. Usage errors exit with status 2, operational failures with status 1, and safe retained/skipped results with status 0.

Tip

allagents skill ... is the canonical singular form. The plural alias allagents skills ... is also accepted and produces identical output.

MCP Commands

allagents mcp add <name> <commandOrUrl> [options] [--scope project|user | --profile <name>]
allagents mcp reauth <name> [--scope project|user | --profile <name>]
allagents mcp remove <name> [--scope project|user | --profile <name>]
allagents mcp list [--scope project|user | --profile <name>]
allagents mcp get <name> [--scope project|user | --profile <name>]
allagents mcp update [--offline] [--scope project|user | --profile <name>]
allagents mcp tools <server> [--search <text>] [--scope project|user | --profile <name>]
allagents mcp call <server> <tool> [tool options | --input <json>] [--scope project|user | --profile <name>]

Every MCP command selects one declaration destination. With no selector, AllAgents uses the current project’s .allagents/workspace.yaml. From the home directory that path aliases the ordinary user config, so an unflagged command resolves to user scope and explicit --scope project is rejected. Use --scope user to select top-level MCP fields in ~/.allagents/workspace.yaml; --profile <name> selects profiles.<name> in that same file. --scope and --profile are mutually exclusive.

Run allagents without arguments and choose MCP Servers to manage the same project, user, and named-profile destinations interactively. Each destination lists its servers directly, with add, inspect, reauthenticate, and remove actions. Client configuration updates automatically after mutations; if an update fails after the declaration changes, the TUI offers a contextual retry. Credential values remain hidden from summaries and selection screens.

Codex and Copilot materialize the selected destination at these exact paths:

Destination	Codex	Copilot CLI
Project	.codex/config.toml	.github/mcp.json
User	~/.codex/config.toml	~/.copilot/mcp-config.json
Profile	~/.allagents/profiles/<name>/clients/codex/home/<name>.config.toml	~/.allagents/profiles/<name>/clients/copilot/home/mcp-config.json

mcp add

Add a new MCP server to the selected destination and immediately update its client configuration. For HTTP servers, AllAgents connects first, completes OAuth when required, and routes selected clients through its built-in MCP client.

Flag	Description
--transport <type>	Transport type: http or stdio (auto-detected from URL by default)
--arg <value>	Argument for the stdio command (repeatable)
-e, --env <KEY=VALUE>	Environment variable for stdio transport (repeatable)
--header <KEY=VALUE>	HTTP header for HTTP transport (repeatable)
--client <client[,client...]>	Client selector; repeatable and comma-compatible. Values are deduplicated in first-seen order. Defaults to every eligible client in the selected destination.
--scope <scope>	Destination scope: project (default) or user
--profile <name>	Named profile destination; cannot be combined with --scope
-f, --force	Replace an existing server with the same name

Transport auto-detection: if <commandOrUrl> starts with http:// or https://, HTTP transport is selected; otherwise stdio is selected. Passing --transport stdio with a URL, or --transport http with a non-URL command, is rejected.

Non-interactive HTTP adds perform the same connection check without starting a browser. They can use cached credentials, but fail before mutation when fresh OAuth consent is required.

Profile header values must be exact environment references such as 'Authorization=${TRADINGVIEW_TOKEN}'. Generated bridge configs retain only the header-to-variable binding; the value is resolved when the bridge connects. Missing variables fail before a request is sent.

# Project HTTP server
allagents mcp add deepwiki https://mcp.deepwiki.com/mcp

# Repeatable and comma-compatible client filters
allagents mcp add internal https://mcp.internal.corp \
  --header Authorization=Bearer-token \
  --client claude --client codex,copilot

# User destination
allagents mcp add deepwiki https://mcp.deepwiki.com/mcp --scope user

# Profile destination
allagents mcp add tradingview https://mcp.tradingview.com/mcp --profile markets

# stdio server with args and env vars
allagents mcp add gh-server npx --arg=-y --arg=@modelcontextprotocol/server-github -e GH_TOKEN=ghp_xxx

# Replace an existing server
allagents mcp add deepwiki https://new.example.com --force

mcp reauth

Force a fresh OAuth login for an HTTP MCP server in the selected destination:

allagents mcp reauth tradingview
allagents mcp reauth tradingview --scope user
allagents mcp reauth tradingview --profile markets

AllAgents clears only the selected credential cache, opens a browser, and verifies a new connection. Project and ordinary user declarations share the ordinary URL-keyed cache. Each named profile has an isolated cache. Removing a local cache does not revoke the grant at the remote authorization provider. If the browser is on another device, paste the complete loopback callback URL into the waiting terminal prompt.

The HTTP-to-stdio bridge written into generated client configs is an internal implementation detail; users do not need to run it directly.

mcp tools

Discover the complete live tool catalog from one configured server:

# Current project
allagents mcp tools deepwiki

# Case-insensitive search over tool name, title, and description
allagents mcp tools deepwiki --search docs

# Ordinary user declaration as a complete JSON record
allagents --json mcp tools deepwiki --scope user

# Named-profile declaration, reduced for automation
allagents --json --jq '.data.tools[] | {name, description}' \
  mcp tools trading --profile markets

mcp tools reads only the inline declaration from the selected destination; it does not merge declarations from other destinations or plugins. It connects directly to that declaration, consumes every tools/list page, closes the connection, and then renders the filtered or unfiltered result in discovery order. An empty catalog and a search with no matches are both successful.

HTTP declarations connect directly to their configured endpoint rather than through the generated AI-client bridge. They reuse the same destination-owned headers and OAuth cache as managed client connections, including valid cached tokens and refreshable expired tokens. Runtime commands never start fresh OAuth consent. If authorization is required, run the destination-specific recovery command reported by the error:

allagents mcp reauth deepwiki
allagents mcp reauth deepwiki --scope user
allagents mcp reauth trading --profile markets

For a stdio declaration, the command starts the configured executable directly with its literal arguments and configured environment. Environment references in configured environment values are resolved at launch; references in arguments are rejected because their resolved values would be visible in the host process list. Treat a stdio declaration as executable code you trust.

Human output prints one block per matching tool with its exact name, optional title and description, and a fully qualified mcp call ... --help command. --json returns the AllAgents envelope plus complete parsed tool records, including input and output schemas, annotations, execution metadata, icons, and _meta when the server supplies them. Exit status is 0 for a catalog, empty catalog, or no matches; 1 for an operational or cleanup failure; and 2 for invalid usage.

mcp call

Inspect or synchronously invoke one exact, case-sensitive tool name. The command discovers the current catalog and uses the same direct connection for the call:

# Connect and inspect the current contract without invoking the tool
allagents mcp call deepwiki ask_question --help
allagents mcp call deepwiki ask_question --help --json

# Generated flags for a wholly safe primitive schema
allagents mcp call remote primitive_echo \
  --text hello \
  --number 1.25 \
  --integer 7 \
  --enabled=false \
  --mode safe \
  --tags first \
  --tags second

# Exact JSON object fallback for a complex schema
allagents mcp call remote complex_echo \
  --input '{"payload":{"nested":["λ",null,""]},"unusual key":null}'

# User destination and structured output
allagents --json mcp call catalog search \
  --scope user \
  --query docs \
  --limit 5

# Profile destination and jq extraction
allagents --json --jq '.data.result.structuredContent' \
  mcp call trading quote --profile markets --symbol AAPL

Server and tool names are exact protocol data. If either name begins with -, put every runtime option before --, then place the remaining server or tool name after the separator:

allagents mcp tools --scope user -- --staging
allagents mcp call --help --profile markets -- --trading -quote
allagents mcp call --input '{"symbol":"AAPL"}' trading -- -quote

Fully qualified help is live: mcp call <server> <tool> --help connects to the selected HTTP server or starts the configured stdio process, discovers the current descriptor, and closes the connection without invoking the tool. Human help shows the description, exact input schema, required fields, and either the generated flags or the reason the tool requires --input. Add --json for the same live contract as structured data. Root help, mcp --help, and bare mcp call --help remain static and do not connect.

Generated flags are all-or-nothing. AllAgents creates them only when the entire input schema is a straightforward top-level object whose property names are portable, non-reserved long-option names and whose properties are strings, finite numbers, safe integers, booleans, homogeneous primitive enums, or homogeneous primitive arrays. Required properties are enforced locally; omitted optional properties remain absent. Booleans take explicit true or false, and an array flag is repeatable with occurrence order preserved. If any property is nested, ambiguous, colliding, nullable, referenced, composed, or otherwise unsafe, no generated subset is exposed and the whole tool remains callable through --input.

--input <json> accepts exactly one JSON object. AllAgents passes its keys and values without flattening, inserting defaults, normalizing names, or rebuilding the object from the schema; integer literals must remain within the JavaScript safe-integer range. It cannot be combined with generated tool flags, although destination selectors, --json, and --json --jq output remain compatible. If a generated flag’s value begins with -, attach it with = so it cannot be mistaken for another flag:

allagents mcp call catalog echo --value=--json

Human call output preserves content order, prints sanitized text items directly, prints each non-text item as JSON, and prints structuredContent once under a separate label. --json preserves the complete parsed result under data.result, including content, structuredContent, isError, _meta, and top-level extension fields; --jq filters that envelope. A completed result with isError: true is still emitted but exits with status 1. Successful calls exit 0, operational, tool, authorization, or cleanup failures exit 1, and invalid usage exits 2. Calls are synchronous; a tool that requires the deferred MCP task lifecycle is rejected before invocation.

mcp remove

Remove a server from the selected declaration destination and reconcile its client configs. Only entries tracked by AllAgents are removed; pre-existing user-managed servers in client MCP configs are preserved.

allagents mcp remove deepwiki
allagents mcp remove deepwiki --scope user
allagents mcp remove tradingview --profile markets

mcp list

List inline MCP declarations from exactly one selected destination. Header, environment, URL credential, and sensitive query values are redacted in both human and JSON output.

allagents mcp list
allagents mcp list --profile markets

mcp get

Print one inline declaration from exactly one selected destination as redacted YAML, or as redacted structured data with --json.

allagents mcp get deepwiki
allagents mcp get tradingview --profile markets

Exits with status 1 if the server is not defined at that destination. Plugin-provided declarations are not included by list or get.

mcp update

Reconcile MCP servers without touching skills, agents, hooks, or other plugin artifacts. Project and ordinary user destinations run MCP-only reconciliation. An installed profile runs its ownership-aware profile reconciliation because some clients store settings and MCP in the same managed file. A declared but uninstalled profile is not implicitly installed.

Flag	Description
--offline	Use cached plugins without fetching from remote marketplaces
--scope <scope>	Destination scope: project (default) or user
--profile <name>	Named profile destination; cannot be combined with --scope

allagents mcp update
allagents mcp update --scope user
allagents mcp update --profile markets
allagents mcp update --offline

To modify a server definition, use allagents mcp add <name> ... --force.

Ownership model

AllAgents only tracks MCP servers it added:

• mcp add records ownership in the selected destination’s sync or profile state.
• mcp remove only removes servers from client MCP configs that AllAgents originally added. User-managed servers are never touched.
• If a same-name client entry existed before AllAgents managed it, the entry remains user-owned and is skipped with a warning.

See CLAUDE.md — MCP Server Sync for the full ownership rule.