# Athenode (npm · @athenode/cli)

Spec-driven development for AI coding agents: specs, skills, agents, rules and MCP servers.

- Trust score: 71/100 (medium)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- npm · `@athenode/cli`: 71/100 (this document), [markdown](https://verifymcp.io/servers/com-athenode-cli/athenode-cli.md), [page](https://verifymcp.io/servers/com-athenode-cli/athenode-cli)

## Channel facts

- Registry: `npm`
- Package: `@athenode/cli`
- Version: `0.10.7`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 81/100
  - No malware found by supply-chain analysis.
  - CVE check failed: a known high-severity CVE affects zod 4.6.5, a direct dependency. A fixed version is available.
  - No install/post-install scripts declared.
  - 39 of 115 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 19/100
  - Repository check failed: no source repository is declared.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 21 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 60/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 15625 tokens (~248/item across 63 items; 63 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 100/100
  - No destabilizing schema changes in the last 30 days.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 98/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 9 of 10 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "library_merge_preview" implies "merge" and declares readOnlyHint instead, contradicting what its own name says it does.
  - An AI judge read all 64 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Athenode MCP server?

Athenode runs locally as an npm package, launched with npx -y @athenode/cli mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add com-athenode-cli -- npx -y @athenode/cli mcp
```

### Cursor

```json
{
  "mcpServers": {
    "com-athenode-cli": {
      "command": "npx",
      "args": [
        "-y",
        "@athenode/cli",
        "mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-athenode-cli": {
      "command": "npx",
      "args": [
        "-y",
        "@athenode/cli",
        "mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add com-athenode-cli -- npx -y @athenode/cli mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-athenode-cli": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@athenode/cli",
        "mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-athenode-cli --command npx --arg -y --arg @athenode/cli --arg mcp
```

### Hermes

```yaml
mcp_servers:
  com-athenode-cli:
    command: "npx"
    args: ["-y", "@athenode/cli", "mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "com-athenode-cli": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@athenode/cli",
        "mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-athenode-cli -t stdio -c npx -a -y @athenode/cli mcp
```

### Other

```json
{
  "mcpServers": {
    "com-athenode-cli": {
      "command": "npx",
      "args": [
        "-y",
        "@athenode/cli",
        "mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 71, +5)

- [security improvement] Stability: fail → pass

### 2026-11-19 (score 66, −1)

No change was recorded against any check on this day. Stability & Change Management went from 75 to 69.

### 2026-11-12 (score 67, +1)

No change was recorded against any check on this day. Stability & Change Management went from 68 to 72.

### 2026-11-10 (score 66, +1)

No change was recorded against any check on this day. Stability & Change Management went from 62 to 65.

### 2026-11-08 (score 65, +1)

No change was recorded against any check on this day. Stability & Change Management went from 55 to 58.

### 2026-11-05 (score 64, +1)

No change was recorded against any check on this day. Stability & Change Management went from 45 to 48.

### 2026-11-03 (score 63, +1)

No change was recorded against any check on this day. Stability & Change Management went from 38 to 42.

### 2026-11-01 (score 62, +1)

No change was recorded against any check on this day. Stability & Change Management went from 32 to 35.

## MCP tools (63)

### `specs_list` (~136 tokens)

List specifications

List the project's specifications, optionally filtered by status (draft | prepared | processing | completed) and scoped to a parent (`parentId`, CLI --parent) or to the top level (`topLevel`, CLI --top-level); the two are mutually exclusive. To find specs by topic, use specs_tree with `query` instead of walking this list. Returns an array ({items} in structuredContent).

Input parameters:

- `parentId` (string): Only direct children of this id (CLI: --parent).
- `status` (string): Filter by status.
- `topLevel` (boolean): Only specs without a parent (CLI: --top-level).

### `specs_search` (~89 tokens)

Search specifications

Flat search over the project's specifications: matches only, without ancestors or filters. The query must not be empty. Each match's `snippet` holds the matched text when the server found the match by meaning, and is otherwise null or absent. Prefer specs_tree with `query` for matches nested with their ancestors. Returns an array ({items} in structuredContent).

Input parameters:

- `query` (string, required): Search text.

### `specs_tree` (~419 tokens)

Specification tree

Fetch specifications as a tree, in one of four modes. Default: the subtree rooted at `id`. `branch`: a single chain from the top-level ancestor down to `id`, which is the deepest node. `query`: ranked search matches (at most 20) nested with their ancestors in one call, so there is no need to walk specs_list; `id` optionally scopes matches to its direct children; a match's `snippet` holds the matched text when the server found the match by meaning, and is otherwise null or absent; if a query finds little, retry with other wording. `executionOrder`: the unfiltered subtree under `id` plus the order in which its leaves can be implemented and the blockers holding them back. Only prepared/processing leaves are planned; draft leaves count as unprepared blockers. A root without children is its own only candidate, so call it on a leaf to get that leaf's blockers. Leaves inherit blockers from their ancestors up to and including the root. A cycle yields an empty order instead of an error. The result is a consistent one-time snapshot. `status` (draft | prepared | processing | completed) prunes branches without a matching node. Mode rules (errors use CLI flags): --execution-order requires an id and cannot combine with --branch, --query or --status; --query and --branch are exclusive and the query must not be empty; --branch cannot combine with --status. Returns an array of nodes, or `{tree, plan}` with executionOrder.

Input parameters:

- `branch` (boolean): Ancestor chain mode (CLI: --branch).
- `executionOrder` (boolean): Execution order mode (CLI: --execution-order).
- `id` (string): Root specification id (optional only in query mode).
- `includeContent` (boolean): Include each node's content (CLI: --include-content).
- `query` (string): Search mode (CLI: --query).
- `status` (string): Keep nodes with this status or a matching descendant (CLI: --status).

### `specs_get` (~35 tokens)

Get specification

Get one specification by id, with its content, status, implementation plan and direct blockers.

Input parameters:

- `id` (string, required): Specification id.

### `specs_create` (~323 tokens)

Create specification

Create a specification (status draft | prepared | processing | completed; content inline). `blockedBy` lists specs that must be completed first; the spec and its blockers are created atomically. Adding is all-or-nothing. A blocker that is missing, in another project, the spec itself, already completed, or an ancestor or descendant is rejected with 400; a link that already exists or would create a cycle with 409, so remove wrong links before adding new ones. Children inherit their ancestors' blockers. `todoCardId` creates the spec from a ToDo card, linking the two in the same request.

Input parameters:

- `blockedBy` (array): Blocker ids (CLI: --blocked-by, repeatable).
- `content` (string): Full specification content (Markdown).
- `parentId` (string): Parent specification id (CLI: --parent).
- `status` (string): Initial status.
- `summary` (string): Short summary.
- `title` (string, required): Specification title.
- `todoCardId` (string): Id of the ToDo card the specification is created from (CLI: --todo-card). The backend records the new specification as the card's resulting specification in the same request. A missing card or a card…

### `specs_update` (~243 tokens)

Update specification

Update a specification; only supplied fields change, and `null` clears `summary`, `content` or `parentId` (CLI: --clear-summary, --clear-content, --clear-parent). `blockedBy` adds to the existing blockers, never replacing them; it is a second request, and its failure reports in `patchApplied` whether the field update was saved. Adding is all-or-nothing. A blocker that is missing, in another project, the spec itself, already completed, or an ancestor or descendant is rejected with 400; a link that already exists or would create a cycle with 409, so remove wrong links before adding new ones. Children inherit their ancestors' blockers.

Input parameters:

- `blockedBy` (array): Ids to add as blockers (CLI: --blocked-by, repeatable).
- `content` (string|null): New content; null clears it.
- `id` (string, required): Specification id.
- `parentId` (string|null): New parent id; null clears it (CLI: --parent / --clear-parent).
- `summary` (string|null): New summary; null clears it.
- `title` (string): New title.

### `specs_delete` (~74 tokens)

Delete specification

Delete a specification and all its descendants, without confirmation. Refused, listing the dependents, while other specs are blocked by it or its descendants, unless `force` is true.

Input parameters:

- `force` (boolean): Delete even when other specs depend on it (CLI: --force).
- `id` (string, required): Specification id.

### `specs_set_status` (~42 tokens)

Set specification status

Set the status of a specification (draft | prepared | processing | completed).

Input parameters:

- `id` (string, required): Specification id.
- `status` (string, required): New status.

### `specs_set_plan` (~67 tokens)

Set implementation plan

Set the implementation plan of a specification; this overwrites any previous plan, and `plan: null` clears it (CLI: --plan / --clear-plan).

Input parameters:

- `id` (string, required): Specification id.
- `plan` (string|null, required): Plan text, or null to clear it.

### `specs_get_plan` (~32 tokens)

Get implementation plan

Get the implementation plan of a specification (null when none is set).

Input parameters:

- `id` (string, required): Specification id.

### `specs_qa_list` (~48 tokens)

List questions

List the questions and answers of a specification; an unanswered question has a null `answer`. Returns an array ({items} in structuredContent).

Input parameters:

- `specificationId` (string, required): Specification id.

### `specs_qa_add` (~56 tokens)

Add question

Add a question to a specification. `question` is a single string, so put any answer options inside it as Markdown.

Input parameters:

- `question` (string, required): Question text (Markdown).
- `specificationId` (string, required): Specification id.

### `specs_qa_answer` (~49 tokens)

Answer question

Answer a question previously added to a specification.

Input parameters:

- `answer` (string, required): The answer text.
- `questionId` (string, required): Question id.
- `specificationId` (string, required): Specification id.

### `specs_blockers_list` (~46 tokens)

List blockers

List the specifications `id` is directly blocked by (not those inherited from ancestors). Returns an array ({items} in structuredContent).

Input parameters:

- `id` (string, required): Specification id.

### `specs_blockers_add` (~132 tokens)

Add blockers

Mark `id` as blocked by each of `blockerIds`, returning the updated blocker list. Adding is all-or-nothing. A blocker that is missing, in another project, the spec itself, already completed, or an ancestor or descendant is rejected with 400; a link that already exists or would create a cycle with 409, so remove wrong links before adding new ones. Children inherit their ancestors' blockers. Returns an array ({items} in structuredContent).

Input parameters:

- `blockerIds` (array, required): Ids of the specs that must be completed first.
- `id` (string, required): Specification id.

### `specs_blockers_remove` (~66 tokens)

Remove blocker

Remove the direct link that blocks `id` by `blockerId`; 404 when no such link exists. Blockers inherited from an ancestor must be removed on that ancestor.

Input parameters:

- `blockerId` (string, required): Blocker id.
- `id` (string, required): Specification id.

### `todos_list` (~152 tokens)

List ToDo cards

List the project's ToDo cards. Without `status` only `open` cards are returned; closed cards (`done`, `dismissed`) only when asked for. `specificationId` keeps the cards whose origin or resulting specification is that one. Rows are full cards including `description` and `questions` (each card's open questions with their answers), ordered by priority, then newest. Returns an array ({items} in structuredContent).

Input parameters:

- `specificationId` (string): Only cards whose origin or resulting specification is this id (CLI: --specification).
- `status` (array): Statuses to return (open | done | dismissed); omitted or empty means open (CLI: --status, repeatable).

### `todos_get` (~84 tokens)

Get ToDo card

Get one ToDo card by id, with its `status`, its `resultingSpecificationId` (null until the card is converted into a specification) and its `questions`: the card's open questions, each with its `answer` (null while unanswered). A 403 can also mean that no such card exists.

Input parameters:

- `id` (string, required): ToDo card id.

### `todos_create` (~369 tokens)

Create ToDo card

Create a ToDo card. Every card starts `open` (a project token creates it with source `agent`), so there is no status parameter. `type` defaults to `idea` and `priority` to `medium`. `questions` gives the card up to 3 open questions, and only when a decision that only the user can make blocks the card; this is the only way for an agent to add a question, since there is no tool to add one to an existing card. The Free plan's card limit is reported as a plan-limit error.

Input parameters:

- `description` (string): Card description, at most 10000 characters.
- `originSpecificationId` (string): Specification whose work the card came out of (CLI: --origin-specification).
- `priority` (string): Card priority (low | medium | high); default medium.
- `questions` (array): Open questions of the card, at most 3; each is one string, Markdown, with its answer options inside the text (CLI: --question, repeatable). A card's open questions are decisions to make before it is…
- `title` (string, required): Card title, at most 200 characters.
- `type` (string): Card type (follow-up | tech-debt | bug | idea); default idea.

### `todos_set_status` (~144 tokens)

Set ToDo card status

Set the status of a ToDo card (open | done | dismissed). A project token may only close an `open` card, as `done` (carried out, with or without a resulting specification) or `dismissed` (closed without being carried out); reopening a card and moving it between `done` and `dismissed` are refused with 403. Repeating the closed status a card already has succeeds unchanged. A 403 can also mean that no such card exists.

Input parameters:

- `id` (string, required): ToDo card id.
- `status` (string, required): New status; a project token may only set done or dismissed, on an open card.

### `todos_qa_answer` (~124 tokens)

Answer ToDo card question

Record the answer to one unanswered open question of a ToDo card; the question ids come with the card (`questions` of `todos_get` and `todos_list`). A project token cannot change an existing answer: answering a question that already has one is refused with 403. A question id that does not belong to the card is a 404. A 403 can also mean that no such card exists.

Input parameters:

- `answer` (string, required): The answer text.
- `id` (string, required): ToDo card id.
- `questionId` (string, required): Question id.

### `plugins_files_list` (~115 tokens)

List plugin files

List the files and directories directly inside a directory of the installed plugin's file tree (the project's own plugin copy), or the root without `path`. `pluginId` targets another plugin of the project instead of the installed one. Returns an array ({items} in structuredContent).

Input parameters:

- `path` (string): Directory path, e.g. "settings"; root if omitted.
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).

### `plugins_files_get` (~109 tokens)

Get plugin file

Get one file of the installed plugin's file tree by path, with its content and summary. Workflow settings are read this way, e.g. "settings/SETTINGS.md". `pluginId` targets another plugin of the project instead of the installed one.

Input parameters:

- `path` (string, required): File path, e.g. "settings/testing.md".
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).

### `plugins_files_create` (~160 tokens)

Create plugin file

Create a file, or a directory with `dir: true`, in the installed plugin's file tree, creating missing parents. File content is inline, at most 50000 characters; directories have no content. `pluginId` targets another plugin of the project instead of the installed one.

Input parameters:

- `content` (string): The file's content (empty if omitted).
- `dir` (boolean): Create a directory instead of a file (CLI: --dir).
- `path` (string, required): Path of the new file or directory.
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).
- `summary` (string): Short summary of the file or directory.

### `plugins_files_update` (~127 tokens)

Update plugin file

Replace a file's content and/or summary; only given fields change. Content is inline, at most 50000 characters. Directories cannot be updated. `pluginId` targets another plugin of the project instead of the installed one.

Input parameters:

- `content` (string): The file's new content.
- `path` (string, required): Path of the file.
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).
- `summary` (string|null): The new summary; null or "" clears it.

### `plugins_files_delete` (~115 tokens)

Delete plugin file

Delete a file or empty directory, without confirmation; a non-empty directory needs `recursive: true` and is deleted with everything under it. `pluginId` targets another plugin of the project instead of the installed one.

Input parameters:

- `path` (string, required): Path of the file or directory.
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).
- `recursive` (boolean): Allow deleting a non-empty directory (CLI: --recursive).

### `plugins_clone` (~291 tokens)

Clone plugin

Clone a plugin under a new name in the project, keeping its description. The whole plugin is copied: agents and skills as independent copies, rules, files and the MCP servers with their stored `env`/`headers` values. It counts against the plan limits (plugins, and agents, skills and MCP servers per plugin); a breach creates nothing. `source` is a plugin name, or an id with `byId: true`. The installed plugin is not changed. Without `slug` the server derives one from the new name. A `slug` is refused, writing nothing, with code `plugin_slug_conflict` (409: another plugin of the project has it), `plugin_slug_forbidden` (a reserved slug), `plugin_slug_locked` (the slug of this plugin cannot be changed) or `plugin_slug_invalid` (not a valid slug).

Input parameters:

- `byId` (boolean): The given value is a plugin id, not a name (CLI: --by-id <id>).
- `name` (string, required): The new cloned plugin's name, at most 200 characters.
- `slug` (string): The new cloned plugin's slug (CLI: --slug). Unique in the project; it is the name of the plugin package and the prefix of its commands.
- `source` (string, required): Name (or, with byId, id) of the plugin to clone.

### `plugins_create` (~169 tokens)

Create plugin

Create an empty plugin in the project. Without `slug` the server derives one from the name. A `slug` is refused, writing nothing, with code `plugin_slug_conflict` (409: another plugin of the project has it), `plugin_slug_forbidden` (a reserved slug), `plugin_slug_locked` (the slug of this plugin cannot be changed) or `plugin_slug_invalid` (not a valid slug).

Input parameters:

- `description` (string): The new plugin's description, at most 25000 characters.
- `name` (string, required): The new plugin's name, at most 200 characters.
- `slug` (string): The new plugin's slug (CLI: --slug). Unique in the project; it is the name of the plugin package and the prefix of its commands.

### `plugins_list` (~100 tokens)

List plugins

List all plugins in the project, each with its `slug` (unique in the project: the name of the plugin package and the prefix of its commands). A plugin added from the plugin library has a `libraryOrigin` (`null` otherwise) naming its origin entry, its `version`, the entry's `latestVersion` and whether an update is on offer (`updateAvailable`; see library_update_preview). Returns an array ({items} in structuredContent).

### `plugins_update` (~305 tokens)

Update plugin

Change a plugin's name, description and/or slug (at least one); omitted fields keep their value. `target` is a plugin name, or an id with `byId: true`, never a slug. A changed slug renames the plugin package and its commands: the result then has a warning naming the old and the new slug. It does not regenerate the install, even for the installed plugin: the local install follows at the next `athenode init` or regeneration. A `slug` is refused, writing nothing, with code `plugin_slug_conflict` (409: another plugin of the project has it), `plugin_slug_forbidden` (a reserved slug), `plugin_slug_locked` (the slug of this plugin cannot be changed) or `plugin_slug_invalid` (not a valid slug).

Input parameters:

- `byId` (boolean): The given value is a plugin id, not a name (CLI: --by-id <id>).
- `description` (string): The plugin's new description, at most 25000 characters.
- `name` (string): The plugin's new name, at most 200 characters.
- `slug` (string): The plugin's new slug (CLI: --slug); the current one is kept if omitted. Unique in the project; it is the name of the plugin package and the prefix of its commands.
- `target` (string, required): Name (or, with byId, id) of the plugin to update.

### `plugins_pull_preview` (~333 tokens)

Preview plugin pull

Preview pulling another plugin of the project into a plugin, changing nothing: per kind (skills, agents, MCP servers, files) the items it would `add`, those in `conflict` with the plugin (and whether they are `replaceable`) and the `identical` ones, the state of the rules, and the `sourceFingerprint` and `fingerprint` that plugins_pull needs with decisions. The source is read as it is now; an item's `libraryItemId` is the id of the source plugin's item. `source` is the plugin the content is taken from and `plugin` the one that receives it: each is the plugin's exact, case-sensitive name, or its id with `sourceById: true` / `pluginById: true` (see plugins_list). Both are required, both are plugins of the project and they must differ; the installed plugin is never assumed. A plugin of another project cannot be the source (pulling across projects exists only in the web app); for a library entry use library_merge.

Input parameters:

- `plugin` (string, required): Name of the plugin that receives the content, or its id with pluginById (CLI: --plugin). Required.
- `pluginById` (boolean): `plugin` is a plugin id, not a name (CLI: --plugin-by-id).
- `source` (string, required): Name of the plugin to pull from, or its id with sourceById. Required.
- `sourceById` (boolean): `source` is a plugin id, not a name (CLI: --source-by-id).

### `plugins_pull` (~646 tokens)

Pull plugin into plugin

Pull another plugin of the project into a plugin, in one transaction, and return what was added and replaced per kind. It is a one-time copy: skills and agents become new, independent items of the plugin, nothing is ever deleted from it, nothing about the source is recorded and no update is offered later. Without `decisions` (safe mode) it previews and applies in one call: every new item is added, nothing is replaced and the rules are kept. `decisions` is an object in the preview's shape: `sourceFingerprint` and `fingerprint` from the preview, and per kind (`skills`, `agents`, `mcpServers`, `files`) the lists `add` and `replace` of `{name}` items (`{path}` for files). A kind without an `add` list adds everything new; a present `add` list, even an empty one, adds exactly its items. `replace` overwrites conflicting items of the plugin and needs `confirmReplace: true`. `rules` is `keep` (default), `append` (under a heading with the source plugin's name) or `replace`. A whole preview may be passed back as `decisions`: it adds every new item and replaces nothing. A `library_merge_stale` error means `plugin` or `source` changed since the preview: repeat plugins_pull_preview and apply with its values. A refusal writes nothing. `source` is the plugin the content is taken from and `plugin` the one that receives it: each is the plugin's exact, case-sensitive name, or its id with `sourceById: true` / `pluginById: true` (see plugins_list). Both are required, both are plugins of the project and they must differ; the installed plugin is never assumed. A plugin of another project cannot be the source (pulling across projects exists only in the web app); for a library entry use library_merge. When `plugin` is the installed plugin, it is then regenerated locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`); if that fails, the backend change is still saved and the tool returns an error. Any other plugin is changed on the server only.

Input parameters:

- `decisions` (object): Decisions in the preview's shape: {sourceFingerprint, fingerprint, confirmReplace?, skills?, agents?, mcpServers?, files?, rules?}, each kind as {add?: [...], replace?: [...]} and rules one of keep |…
- `plugin` (string, required): Name of the plugin that receives the content, or its id with pluginById (CLI: --plugin). Required.
- `pluginById` (boolean): `plugin` is a plugin id, not a name (CLI: --plugin-by-id).
- `source` (string, required): Name of the plugin to pull from, or its id with sourceById. Required.
- `sourceById` (boolean): `source` is a plugin id, not a name (CLI: --source-by-id).

### `plugins_external_import_preview` (~349 tokens)

Preview external plugin import

Preview importing an external plugin, changing no plugin of the project: the plugins its package offers (`candidates`; `picked` is null while one must be chosen with `pick`), what the picked one brings (skills, agents, MCP servers, rules), its licence and attribution, `warnings`, `ignored` parts and the proposed slug and name of a new plugin. With `plugin` also the merge preview into that plugin (`merge`), whose `previewId`, `sourceFingerprint` and `fingerprint` plugins_external_import takes as decisions. A preview expires after an hour. `source` is a public GitHub or GitLab repository URL (a tree URL picks a ref and a sub-folder), or the path of a local external plugin folder, resolved against the project root, which is zipped (without .git, node_modules and links) and uploaded. Formats: Agent Plugins (`plugin.json`), Claude Code plugins (`.claude-plugin/plugin.json`), marketplaces and `plugins/*` folders; skills, agents, MCP servers and the root `AGENTS.md` (as the rules) are imported, hooks, commands and the like are listed as ignored.

Input parameters:

- `pick` (string): The external plugin to import of a package that offers several (a marketplace or a plugins/ folder) (CLI: --pick).
- `plugin` (string): Name of the plugin, or its id with pluginById (CLI: --plugin).
- `pluginById` (boolean): `plugin` is a plugin id, not a name (CLI: --plugin-by-id).
- `source` (string, required): Repository URL, or the path of a local external plugin folder.

### `plugins_external_import` (~630 tokens)

Import external plugin

Import an external plugin. Without `plugin` into a new plugin, with `slug` and `name` or the proposed ones (nothing is regenerated); a package with several plugins needs `pick`. With `plugin` (its exact name, or its id with `pluginById`) it is merged into that plugin: without `decisions` (safe mode) every new item is added, nothing is replaced and the rules are kept; `decisions` is the merge preview's shape (`previewId`, `sourceFingerprint`, `fingerprint`, per kind `add`/`replace` of `{name}` items, `confirmReplace`, `rules` keep | append | replace for the external plugin's AGENTS.md). The plugin records the external plugin as a source (plugins_external_sources) for later updates. `source` is a public GitHub or GitLab repository URL (a tree URL picks a ref and a sub-folder), or the path of a local external plugin folder, resolved against the project root, which is zipped (without .git, node_modules and links) and uploaded. Formats: Agent Plugins (`plugin.json`), Claude Code plugins (`.claude-plugin/plugin.json`), marketplaces and `plugins/*` folders; skills, agents, MCP servers and the root `AGENTS.md` (as the rules) are imported, hooks, commands and the like are listed as ignored. A `slug` is refused, writing nothing, with code `plugin_slug_conflict` (409: another plugin of the project has it), `plugin_slug_forbidden` (a reserved slug), `plugin_slug_locked` (the slug of this plugin cannot be changed) or `plugin_slug_invalid` (not a valid slug). When `plugin` is the installed plugin, it is then regenerated locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`); if that fails, the backend change is still saved and the tool returns an error. Any other plugin is changed on the server only.

Input parameters:

- `decisions` (object): Decisions of a merge into `plugin`: {previewId?, sourceFingerprint, fingerprint, confirmReplace?, skills?, agents?, mcpServers?, rules?} (CLI: --decisions). Safe mode if omitted.
- `name` (string): The new plugin's name, at most 200 characters.
- `pick` (string): The external plugin to import of a package that offers several (a marketplace or a plugins/ folder) (CLI: --pick).
- `plugin` (string): Name of the plugin, or its id with pluginById (CLI: --plugin).
- `pluginById` (boolean): `plugin` is a plugin id, not a name (CLI: --plugin-by-id).
- `slug` (string): The new plugin's slug (CLI: --slug). Unique in the project; it is the name of the plugin package and the prefix of its commands.
- `source` (string, required): Repository URL, or the path of a local external plugin folder.

### `plugins_external_sources` (~113 tokens)

List external plugin sources

List the external plugins a plugin was imported from: the URL and revision or the uploaded zip, the external plugin's name, licence class and the items it owns in the plugin. The installed plugin without `plugin`. Returns an array ({items} in structuredContent).

Input parameters:

- `plugin` (string): Name of the plugin, or its id with pluginById (CLI: --plugin).
- `pluginById` (boolean): `plugin` is a plugin id, not a name (CLI: --plugin-by-id).

### `plugins_external_update_preview` (~257 tokens)

Preview external plugin update

Check an external plugin source of a plugin for a new version and preview the update, changing no item: `upToDate`, else per kind the items to `add`, those that `change` (status changed, conflict, edited, other_source or unowned), the `unchanged` ones and those the new version no longer has (`remove`), with the `previewId`, `sourceFingerprint` and `fingerprint` plugins_external_update takes as decisions. An external plugin imported from a URL is checked by its URL; an uploaded one needs `path`. `plugin` is required.

Input parameters:

- `path` (string): Folder of the new version of an uploaded external plugin, resolved against the project root (CLI: --path); an external plugin imported from a URL is checked by its URL.
- `plugin` (string, required): Name of the plugin, or its id with pluginById (CLI: --plugin). Required.
- `pluginById` (boolean): `plugin` is a plugin id, not a name (CLI: --plugin-by-id).
- `pluginSource` (string, required): The external plugin source: its id, or its name when the plugin has one source of that name (see plugins_external_sources).

### `plugins_external_update` (~433 tokens)

Update external plugin

Update an external plugin source of a plugin to its new version. Without `decisions` (safe mode) it checks and applies: every new item is added, nothing is replaced or removed, the rules are kept and the source moves to the new version; an up-to-date source changes nothing. `decisions` is the update preview's shape: `previewId`, `sourceFingerprint`, `fingerprint`, per kind (`skills`, `agents`, `mcpServers`) the lists `add`, `replace`, `remove` (delete from the plugin) and `keep` (keep as the plugin's own) of `{name}` items, `confirmReplace` (required to replace or remove) and `rules` keep | append | replace. A `library_merge_stale` error means the plugin changed since the preview: repeat it. `plugin` is required. When `plugin` is the installed plugin, it is then regenerated locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`); if that fails, the backend change is still saved and the tool returns an error. Any other plugin is changed on the server only.

Input parameters:

- `decisions` (object): Decisions: {previewId, sourceFingerprint, fingerprint, confirmReplace?, skills?, agents?, mcpServers?, rules?}, each kind as {add?, replace?, remove?, keep?} (CLI: --decisions). Safe mode if omitted.
- `path` (string): Folder of the new version of an uploaded external plugin, resolved against the project root (CLI: --path); an external plugin imported from a URL is checked by its URL.
- `plugin` (string, required): Name of the plugin, or its id with pluginById (CLI: --plugin). Required.
- `pluginById` (boolean): `plugin` is a plugin id, not a name (CLI: --plugin-by-id).
- `pluginSource` (string, required): The external plugin source: its id, or its name when the plugin has one source of that name (see plugins_external_sources).

### `plugins_delete` (~93 tokens)

Delete plugin

Delete a plugin immediately, without confirmation. `target` is a plugin name, or an id with `byId: true`. Deleting the installed plugin adds a warning.

Input parameters:

- `byId` (boolean): The given value is a plugin id, not a name (CLI: --by-id <id>).
- `target` (string, required): Name (or, with byId, id) of the plugin to delete.

### `agents_create` (~422 tokens)

Create agent

Create an agent and attach it to the installed plugin. `prompt` is the inline prompt/instructions; `description` is usually required metadata, and missing required metadata fails instead of prompting. Then regenerates the installed plugin locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`, whose `pluginChanges` lists the tools whose plugin package or declaration was rewritten, with `suppressedIn` naming another tool's local settings file the plugin was switched off in; `missingEnvVars` is checked against the MCP server's environment, not your shell). If regeneration fails, the backend change is still saved and the tool returns an error. Requires an installed plugin (`npx @athenode/cli init`), unless `pluginId` names another plugin of the project: that one is changed on the server only, with no local regeneration.

Input parameters:

- `description` (string): Agent description.
- `metadata` (object): Metadata fields to set, as {key: value}; "<target>.<field>" sets a per-target field (target: claudecode, codexcli, cursor, copilot, copilotcli, opencode, antigravity-ide, antigravity-cli, devin, juni…
- `name` (string, required): Agent name.
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).
- `prompt` (string): Inline prompt/instructions content (CLI: --prompt).

### `agents_update` (~523 tokens)

Update agent

Fork-update an agent of the installed plugin (by name, or id with `byId`): a new backend row gets the changes, keeping unchanged fields and metadata, and replaces the old row in the plugin in the same request; the server deletes the old row unless another plugin still links it. A `rename` to the name of another one in the plugin is refused (409, code `agent_name_conflict`) and changes nothing. Then regenerates the installed plugin locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`, whose `pluginChanges` lists the tools whose plugin package or declaration was rewritten, with `suppressedIn` naming another tool's local settings file the plugin was switched off in; `missingEnvVars` is checked against the MCP server's environment, not your shell). If regeneration fails, the backend change is still saved and the tool returns an error. Requires an installed plugin (`npx @athenode/cli init`), unless `pluginId` names another plugin of the project: that one is changed on the server only, with no local regeneration.

Input parameters:

- `byId` (boolean): `identifier` is a backend id, not a name (CLI: --by-id).
- `description` (string): New agent description.
- `identifier` (string, required): Agent name, or its backend id with byId.
- `metadata` (object): Metadata fields to set, as {key: value}; "<target>.<field>" sets a per-target field (target: claudecode, codexcli, cursor, copilot, copilotcli, opencode, antigravity-ide, antigravity-cli, devin, juni…
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).
- `prompt` (string): New inline prompt content (CLI: --prompt).
- `rename` (string): New name; the current one is kept if omitted.

### `agents_remove` (~272 tokens)

Remove agent

Detach an agent (by name, or id with `byId`) from the installed plugin without confirmation, removing its generated files; the server deletes the row itself once no plugin links it any more (one another plugin still links is kept). Then regenerates the installed plugin locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`, whose `pluginChanges` lists the tools whose plugin package or declaration was rewritten, with `suppressedIn` naming another tool's local settings file the plugin was switched off in; `missingEnvVars` is checked against the MCP server's environment, not your shell). If regeneration fails, the backend change is still saved and the tool returns an error. Requires an installed plugin (`npx @athenode/cli init`), unless `pluginId` names another plugin of the project: that one is changed on the server only, with no local regeneration.

Input parameters:

- `byId` (boolean): `identifier` is a backend id, not a name (CLI: --by-id).
- `identifier` (string, required): Agent name, or its backend id with byId.
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).

### `agents_list` (~79 tokens)

List agents

List the agents attached to the installed plugin (not the whole catalog). `pluginId` targets another plugin of the project instead of the installed one. Returns an array ({items} in structuredContent).

Input parameters:

- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).

### `skills_create` (~421 tokens)

Create skill

Create a skill and attach it to the installed plugin. `prompt` is the inline SKILL.md body; `description` is usually required metadata, and missing required metadata fails instead of prompting. Then regenerates the installed plugin locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`, whose `pluginChanges` lists the tools whose plugin package or declaration was rewritten, with `suppressedIn` naming another tool's local settings file the plugin was switched off in; `missingEnvVars` is checked against the MCP server's environment, not your shell). If regeneration fails, the backend change is still saved and the tool returns an error. Requires an installed plugin (`npx @athenode/cli init`), unless `pluginId` names another plugin of the project: that one is changed on the server only, with no local regeneration.

Input parameters:

- `description` (string): Skill description.
- `metadata` (object): Metadata fields to set, as {key: value}; "<target>.<field>" sets a per-target field (target: claudecode, codexcli, cursor, copilot, copilotcli, opencode, antigravity-ide, antigravity-cli, devin, juni…
- `name` (string, required): Skill name.
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).
- `prompt` (string): Inline prompt content (CLI: --prompt).

### `skills_update` (~523 tokens)

Update skill

Fork-update a skill of the installed plugin (by name, or id with `byId`): a new backend row gets the changes, keeping unchanged fields and metadata, and replaces the old row in the plugin in the same request; the server deletes the old row unless another plugin still links it. A `rename` to the name of another one in the plugin is refused (409, code `skill_name_conflict`) and changes nothing. Then regenerates the installed plugin locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`, whose `pluginChanges` lists the tools whose plugin package or declaration was rewritten, with `suppressedIn` naming another tool's local settings file the plugin was switched off in; `missingEnvVars` is checked against the MCP server's environment, not your shell). If regeneration fails, the backend change is still saved and the tool returns an error. Requires an installed plugin (`npx @athenode/cli init`), unless `pluginId` names another plugin of the project: that one is changed on the server only, with no local regeneration.

Input parameters:

- `byId` (boolean): `identifier` is a backend id, not a name (CLI: --by-id).
- `description` (string): New skill description.
- `identifier` (string, required): Skill name, or its backend id with byId.
- `metadata` (object): Metadata fields to set, as {key: value}; "<target>.<field>" sets a per-target field (target: claudecode, codexcli, cursor, copilot, copilotcli, opencode, antigravity-ide, antigravity-cli, devin, juni…
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).
- `prompt` (string): New inline prompt content (CLI: --prompt).
- `rename` (string): New name; the current one is kept if omitted.

### `skills_remove` (~272 tokens)

Remove skill

Detach a skill (by name, or id with `byId`) from the installed plugin without confirmation, removing its generated files; the server deletes the row itself once no plugin links it any more (one another plugin still links is kept). Then regenerates the installed plugin locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`, whose `pluginChanges` lists the tools whose plugin package or declaration was rewritten, with `suppressedIn` naming another tool's local settings file the plugin was switched off in; `missingEnvVars` is checked against the MCP server's environment, not your shell). If regeneration fails, the backend change is still saved and the tool returns an error. Requires an installed plugin (`npx @athenode/cli init`), unless `pluginId` names another plugin of the project: that one is changed on the server only, with no local regeneration.

Input parameters:

- `byId` (boolean): `identifier` is a backend id, not a name (CLI: --by-id).
- `identifier` (string, required): Skill name, or its backend id with byId.
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).

### `skills_list` (~79 tokens)

List skills

List the skills attached to the installed plugin (not the whole catalog). `pluginId` targets another plugin of the project instead of the installed one. Returns an array ({items} in structuredContent).

Input parameters:

- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).

### `mcp_servers_create` (~355 tokens)

Create MCP server

Create a plugin-level MCP server on the installed plugin: `command`, `args` and `env` for "stdio", `url` and `headers` for "http"/"sse" (the other transport's fields are ignored). Values may reference environment variables as ${VAR}. Then regenerates the installed plugin locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`, whose `pluginChanges` lists the tools whose plugin package or declaration was rewritten, with `suppressedIn` naming another tool's local settings file the plugin was switched off in; `missingEnvVars` is checked against the MCP server's environment, not your shell). If regeneration fails, the backend change is still saved and the tool returns an error. Requires an installed plugin (`npx @athenode/cli init`), unless `pluginId` names another plugin of the project: that one is changed on the server only, with no local regeneration.

Input parameters:

- `args` (array): Arguments of the command (stdio; CLI: --arg, repeatable).
- `command` (string): Command to run (stdio).
- `env` (object): Environment variables, as {KEY: value} (stdio; CLI: --env).
- `headers` (object): HTTP headers, as {Name: value} (http/sse; CLI: --header).
- `name` (string, required): MCP server name.
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).
- `transport` (string, required): MCP server transport.
- `url` (string): Server URL (http/sse).

### `mcp_servers_update` (~383 tokens)

Update MCP server

Update a plugin-level MCP server (by name, or id with `byId`) in place. Omitted fields keep their value; a given `args`, `env` or `headers` replaces the whole value, so include every entry to keep. Switching the transport drops the old transport's fields. Then regenerates the installed plugin locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`, whose `pluginChanges` lists the tools whose plugin package or declaration was rewritten, with `suppressedIn` naming another tool's local settings file the plugin was switched off in; `missingEnvVars` is checked against the MCP server's environment, not your shell). If regeneration fails, the backend change is still saved and the tool returns an error. Requires an installed plugin (`npx @athenode/cli init`), unless `pluginId` names another plugin of the project: that one is changed on the server only, with no local regeneration.

Input parameters:

- `args` (array): New arguments (stdio); replaces the current list.
- `byId` (boolean): `identifier` is a backend id, not a name (CLI: --by-id).
- `command` (string): New command (stdio).
- `env` (object): New environment variables (stdio); replaces the current map.
- `headers` (object): New HTTP headers (http/sse); replaces the current map.
- `identifier` (string, required): MCP server name, or its backend id with byId.
- `name` (string): New MCP server name.
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).
- `transport` (string): New transport.
- `url` (string): New URL (http/sse).

### `mcp_servers_remove` (~256 tokens)

Remove MCP server

Delete a plugin-level MCP server (by name, or id with `byId`) without confirmation, removing its entries from the local MCP config files. Then regenerates the installed plugin locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`, whose `pluginChanges` lists the tools whose plugin package or declaration was rewritten, with `suppressedIn` naming another tool's local settings file the plugin was switched off in; `missingEnvVars` is checked against the MCP server's environment, not your shell). If regeneration fails, the backend change is still saved and the tool returns an error. Requires an installed plugin (`npx @athenode/cli init`), unless `pluginId` names another plugin of the project: that one is changed on the server only, with no local regeneration.

Input parameters:

- `byId` (boolean): `identifier` is a backend id, not a name (CLI: --by-id).
- `identifier` (string, required): MCP server name, or its backend id with byId.
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).

### `mcp_servers_list` (~78 tokens)

List MCP servers

List the plugin-level MCP servers of the installed plugin. `pluginId` targets another plugin of the project instead of the installed one. Returns an array ({items} in structuredContent).

Input parameters:

- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).

### `rules_update` (~238 tokens)

Update rules

Replace the whole rules text of the installed plugin; an empty string empties it. The content is literal (a leading "@" is not a file reference); over 50000 characters it adds a warning and may be rejected. Then regenerates the installed plugin locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`, whose `pluginChanges` lists the tools whose plugin package or declaration was rewritten, with `suppressedIn` naming another tool's local settings file the plugin was switched off in; `missingEnvVars` is checked against the MCP server's environment, not your shell). If regeneration fails, the backend change is still saved and the tool returns an error. Requires an installed plugin (`npx @athenode/cli init`), unless `pluginId` names another plugin of the project: that one is changed on the server only, with no local regeneration.

Input parameters:

- `content` (string, required): The full rules text.
- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).

### `rules_get` (~71 tokens)

Get rules

Get the rules text of the installed plugin (null when none was ever set). `pluginId` targets another plugin of the project instead of the installed one.

Input parameters:

- `pluginId` (string): Id of the plugin to act on (see plugins_list); the installed plugin if omitted (CLI: --plugin-id).

### `library_list` (~161 tokens)

List library entries

List or search the public plugin library, one page at a time, most liked first. Returns `{items, nextCursor}` with no total; for the next page pass `nextCursor` as `cursor` with the same `query` and `category` (a cursor is invalid with other values). Readable with any project token.

Input parameters:

- `category` (string): Only entries of this category (CLI: --category). One of: programming, testing-qa, security, devops, design, productivity, other.
- `cursor` (string): The nextCursor of the previous page.
- `limit` (integer): Page size, 1 to 100; 20 if omitted.
- `query` (string): Search text (CLI: --query).

### `library_get` (~164 tokens)

Get library entry

Get one library entry: its metadata, versions and the agents, skills (with their bundle files as `{path, isText}`; `isText: false` is a binary file), MCP servers and files of its latest version, without their texts (read those with library_item). Item ids change with every published version. `entry` is the entry's exact name (matched case-insensitively, surrounding spaces ignored), or its id with `byId: true`; a value that looks like an id is still taken as a name without `byId`.

Input parameters:

- `byId` (boolean): `entry` is an entry id, not a name (CLI: --by-id).
- `entry` (string, required): Library entry name, or its id with byId.

### `library_item` (~257 tokens)

Get library entry item

Read the content of one item of a library entry's latest version. `agent`, `skill` and `mcp-server` need `itemId` (from library_get, or a merge preview's `libraryItemId`); `file` needs `path`; `skill-file` needs `itemId` (the skill) and `path`, returns `{path, content}` and refuses a binary file; `rules` needs neither. Any other combination is refused. Items are not addressed by name: names are not unique inside an entry. `entry` is the entry's exact name (matched case-insensitively, surrounding spaces ignored), or its id with `byId: true`; a value that looks like an id is still taken as a name without `byId`.

Input parameters:

- `byId` (boolean): `entry` is an entry id, not a name (CLI: --by-id).
- `entry` (string, required): Library entry name, or its id with byId.
- `itemId` (string): Item id inside the entry (CLI: --item-id).
- `kind` (string, required): Item kind.
- `path` (string): Path of the plugin file, or of the file inside the skill.

### `library_add` (~219 tokens)

Add library entry as plugin

Add a library entry to the project as a new plugin, a full copy of its latest version, and return the plugin. The server only is changed: no local file is written and nothing is installed (run `npx @athenode/cli init --plugin <id or slug>` to install it, both of which are in the result). A name the project already uses is refused with code `plugin_name_conflict` and a free `suggestedName`. `entry` is the entry's exact name (matched case-insensitively, surrounding spaces ignored), or its id with `byId: true`; a value that looks like an id is still taken as a name without `byId`.

Input parameters:

- `byId` (boolean): `entry` is an entry id, not a name (CLI: --by-id).
- `entry` (string, required): Library entry name, or its id with byId.
- `name` (string): The new plugin's name, at most 200 characters; the entry's name if omitted.

### `library_merge_preview` (~285 tokens)

Preview library merge

Preview merging a library entry's latest version into a plugin, changing nothing: per kind the items it would `add`, those in `conflict` with the plugin (and whether they are `replaceable`) and the `identical` ones, the state of the rules, and the `entryVersion` and `fingerprint` that library_merge needs with decisions. Compare both sides of a conflict with library_item and the plugin's own tools. `entry` is the entry's exact name (matched case-insensitively, surrounding spaces ignored), or its id with `byId: true`; a value that looks like an id is still taken as a name without `byId`. `plugin` is required and is the plugin's exact, case-sensitive name, or its id with `pluginById: true` (see plugins_list); the installed plugin is never assumed.

Input parameters:

- `byId` (boolean): `entry` is an entry id, not a name (CLI: --by-id).
- `entry` (string, required): Library entry name, or its id with byId.
- `plugin` (string, required): Name of the plugin to act on, or its id with pluginById (CLI: --plugin). Required.
- `pluginById` (boolean): `plugin` is a plugin id, not a name (CLI: --plugin-by-id).

### `library_merge` (~579 tokens)

Merge library entry into plugin

Merge a library entry's latest version into a plugin, in one transaction, and return what was added and replaced per kind. Without `decisions` (safe mode) it previews and applies in one call: every new item is added, nothing is replaced and the rules are kept. `decisions` is an object in the preview's shape: `entryVersion` and `fingerprint` from the preview, and per kind (`skills`, `agents`, `mcpServers`, `files`) the lists `add` and `replace` of `{name}` items (`{path}` for files). A kind without an `add` list adds everything new; a present `add` list, even an empty one, adds exactly its items. `replace` overwrites conflicting items of the plugin and needs `confirmReplace: true`. `rules` is `keep` (default), `append` or `replace`. A whole preview may be passed back as `decisions`: it adds every new item and replaces nothing. A `library_merge_stale` error means the plugin or the entry changed since the preview: repeat the preview and apply with its values. A refusal writes nothing. `decisions.entryId`, when present, must be this entry. `entry` is the entry's exact name (matched case-insensitively, surrounding spaces ignored), or its id with `byId: true`; a value that looks like an id is still taken as a name without `byId`. `plugin` is required and is the plugin's exact, case-sensitive name, or its id with `pluginById: true` (see plugins_list); the installed plugin is never assumed. When `plugin` is the installed plugin, it is then regenerated locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`); if that fails, the backend change is still saved and the tool returns an error. Any other plugin is changed on the server only.

Input parameters:

- `byId` (boolean): `entry` is an entry id, not a name (CLI: --by-id).
- `decisions` (object): Decisions in the preview's shape: {entryVersion, fingerprint, confirmReplace?, skills?, agents?, mcpServers?, files?, rules?}, each kind as {add?: [...], replace?: [...]} and rules one of keep | appe…
- `entry` (string, required): Library entry name, or its id with byId.
- `plugin` (string, required): Name of the plugin to act on, or its id with pluginById (CLI: --plugin). Required.
- `pluginById` (boolean): `plugin` is a plugin id, not a name (CLI: --plugin-by-id).

### `library_update_preview` (~179 tokens)

Preview library update

Preview updating a plugin that was added from the library to the latest version of its origin entry, changing nothing: the same result as library_merge_preview for that entry. Refused with code `library_update_no_origin` for a plugin that has no origin entry and `library_update_not_available` for one already at the latest version (plugins_list shows `libraryOrigin.updateAvailable`). `plugin` is required and is the plugin's exact, case-sensitive name, or its id with `pluginById: true` (see plugins_list); the installed plugin is never assumed.

Input parameters:

- `plugin` (string, required): Name of the plugin to act on, or its id with pluginById (CLI: --plugin). Required.
- `pluginById` (boolean): `plugin` is a plugin id, not a name (CLI: --plugin-by-id).

### `library_update` (~500 tokens)

Update plugin from library

Update a plugin that was added from the library to the latest version of its origin entry, in one transaction, and return what was added and replaced per kind; the plugin is then recorded at that version. Without `decisions` (safe mode) it previews and applies in one call: every new item is added, nothing is replaced and the rules are kept. `decisions` is an object in the preview's shape: `entryVersion` and `fingerprint` from the preview, and per kind (`skills`, `agents`, `mcpServers`, `files`) the lists `add` and `replace` of `{name}` items (`{path}` for files). A kind without an `add` list adds everything new; a present `add` list, even an empty one, adds exactly its items. `replace` overwrites conflicting items of the plugin and needs `confirmReplace: true`. `rules` is `keep` (default), `append` or `replace`. A whole preview may be passed back as `decisions`: it adds every new item and replaces nothing. A `library_merge_stale` error means the plugin or the entry changed since the preview: repeat the preview and apply with its values. A refusal writes nothing. Take the decisions' values from library_update_preview. `plugin` is required and is the plugin's exact, case-sensitive name, or its id with `pluginById: true` (see plugins_list); the installed plugin is never assumed. When `plugin` is the installed plugin, it is then regenerated locally, like `athenode init` without confirmation (the result adds `install` and `regeneration`); if that fails, the backend change is still saved and the tool returns an error. Any other plugin is changed on the server only.

Input parameters:

- `decisions` (object): Decisions in the preview's shape: {entryVersion, fingerprint, confirmReplace?, skills?, agents?, mcpServers?, files?, rules?}, each kind as {add?: [...], replace?: [...]} and rules one of keep | appe…
- `plugin` (string, required): Name of the plugin to act on, or its id with pluginById (CLI: --plugin). Required.
- `pluginById` (boolean): `plugin` is a plugin id, not a name (CLI: --plugin-by-id).

### `library_publish` (~948 tokens)

Publish plugin to library

Publish a plugin to the plugin library: a new entry, or a new version of the entry the plugin already has. Publishing makes the plugin's agents, skills, MCP servers, files and rules visible to every signed-in Athenode user and turns the entry's public display on, unless an administrator made public display unavailable for the entry. Public display shows the entry's name, description and category and the full content of its agents, skills with their bundle files, rules and plugin files on the open web, without an account, where search engines can index them. Its MCP server configuration is public too: anyone can install the entry, MCP servers included, without an account with `npx @athenode/cli use <slug>`, so MCP values must stay ${VAR} references. After it is turned off, the entry can stay on the public site for up to a day and longer in search engines' caches. So publishing needs the explicit `confirmPublic: true`, the one consent to both; ask the user before setting it, naming the open web, and there is no `publicDisplay` here (to turn public display off afterwards use library_edit). Without `confirmPublic: true` nothing is published: the result is `{published: false, preview, problem}` with a warning, and a second one when an administrator excluded the entry from the public site (`publicDisplayBanned: true`: it is then published to the in-app library only; tell the user before confirming); the preview lists the items as `{id, name}` / `{id, path}` objects, and `problem` (`{status, code, field, error}`, else `null`) is the first refusal the publish would get: an invalid name, description, note or category, a first publish without a category (`library_entry_category_required`), or a name another entry has (`library_entry_name_taken`), which a confirmed publish answers as an error. A first publish beyond the plan's library entry limit (3 entries on the Free plan) is such a refusal too: `problem` in the preview, an error when confirmed (402 `plan_limit_exceeded`, l…

Input parameters:

- `category` (string): The entry's category (CLI: --category): required for a new entry, kept by a new version when omitted. One of: programming, testing-qa, security, devops, design, productivity, other.
- `confirmPublic` (boolean): Confirms what becomes visible, public display included (CLI: --confirm-public). Required to publish. Publishing makes the plugin's agents, skills, MCP servers, files and rules visible to every signed…
- `description` (string): The entry's description.
- `name` (string): The entry's name; the plugin's name (or the entry's current one) if omitted.
- `note` (string): A note for the published version.
- `plugin` (string, required): Name of the plugin to act on, or its id with pluginById (CLI: --plugin). Required.
- `pluginById` (boolean): `plugin` is a plugin id, not a name (CLI: --plugin-by-id).

### `library_edit` (~683 tokens)

Edit library entry

Change a library entry's name, description, category and/or public display (at least one); omitted fields keep their value and no version is created. `description: ""` clears the description, and a given `category` replaces the current one. Public display shows the entry's name, description and category and the full content of its agents, skills with their bundle files, rules and plugin files on the open web, without an account, where search engines can index them. Its MCP server configuration is public too: anyone can install the entry, MCP servers included, without an account with `npx @athenode/cli use <slug>`, so MCP values must stay ${VAR} references. After it is turned off, the entry can stay on the public site for up to a day and longer in search engines' caches. So `publicDisplay: true` needs `confirmPublic: true`, even when the entry already has it on, and is refused without it before anything is sent; ask the user specifically about public display before setting it. `publicDisplay: false` needs no confirmation. Turning it on for an entry an administrator excluded from the public site is refused with code `library_public_display_banned`. Allowed for those who may manage the entry. `entry` is the entry's exact name (matched case-insensitively, surrounding spaces ignored), or its id with `byId: true`; a value that looks like an id is still taken as a name without `byId`.

Input parameters:

- `byId` (boolean): `entry` is an entry id, not a name (CLI: --by-id).
- `category` (string): The entry's new category (CLI: --category); kept when omitted. One of: programming, testing-qa, security, devops, design, productivity, other.
- `confirmPublic` (boolean): Confirms turning public display on (CLI: --confirm-public); required with `publicDisplay: true`, no change by itself. Publishing makes the plugin's agents, skills, MCP servers, files and rules visibl…
- `description` (string): The new description; "" clears it.
- `entry` (string, required): Library entry name, or its id with byId.
- `name` (string): The entry's new name.
- `publicDisplay` (boolean): Turns public display on (`true`, which needs `confirmPublic: true`) or off (`false`); omitted, the entry keeps its setting. Unlike `confirmPublic: false`, which equals an omitted one, `false` is a ch…

### `library_unpublish` (~139 tokens)

Unpublish library entry

Unpublish a library entry immediately, without confirmation: the entry and all its versions are removed from the library. Plugins already added from it are kept. Allowed for those who may manage the entry. `entry` is the entry's exact name (matched case-insensitively, surrounding spaces ignored), or its id with `byId: true`; a value that looks like an id is still taken as a name without `byId`.

Input parameters:

- `byId` (boolean): `entry` is an entry id, not a name (CLI: --by-id).
- `entry` (string, required): Library entry name, or its id with byId.

## Diagnostics

Captured diagnostic sections: Provenance, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/com-athenode-cli/athenode-cli#diagnostics

## Score history

- 2026-11-21: 71
- 2026-11-20: 66
- 2026-11-19: 66
- 2026-11-18: 67
- 2026-11-17: 67
- 2026-11-16: 67
- 2026-11-15: 67
- 2026-11-14: 67
- 2026-11-13: 67
- 2026-11-12: 67
- 2026-11-11: 66
- 2026-11-10: 66
- 2026-11-09: 65
- 2026-11-08: 65
- 2026-11-07: 64
- 2026-11-06: 64
- 2026-11-05: 64
- 2026-11-04: 63
- 2026-11-03: 63
- 2026-11-02: 62
- 2026-11-01: 62
- 2026-10-31: 61
- 2026-10-30: 61
- 2026-10-29: 60
- 2026-10-28: 60
- 2026-10-27: 59
- 2026-10-26: 59
- 2026-10-25: 58
- 2026-10-24: 58
- 2026-10-23: 63

## Common questions

### What is the Athenode MCP server?

Athenode is an MCP server listed in the public MCP registry as com.athenode/cli. Spec-driven development for AI coding agents: specs, skills, agents, rules and MCP servers. This page covers its npm package (@athenode/cli).

### Is the Athenode MCP server safe to use?

Athenode scores 71 out of 100 on VerifyMCP. We recorded 1 known advisory against it as of 21 November 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Athenode MCP server expose?

Athenode exposes 63 tools: specs_list, specs_search, specs_tree, specs_get, specs_create, and 58 more. Their descriptions and schemas cost roughly 15,161 tokens of context every time the server is loaded.

### Is the Athenode MCP server still maintained?

Athenode is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Athenode MCP server under?

Athenode declares the Apache-2.0 licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the Athenode MCP server?

VerifyMCP ran 15 checks on Athenode, covering Malware scan, Known CVEs, Install scripts, Dependency health and 11 more. One item could not be completed, a gap on our side rather than a finding about Athenode: Security disclosure. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/@athenode/cli
- Socket report: https://socket.dev/npm/package/@athenode/cli
- Website: https://athenode.com/docs/cli
- Changelog RSS feed: https://verifymcp.io/servers/com-athenode-cli/athenode-cli.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-athenode-cli/athenode-cli/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/com-athenode-cli/athenode-cli.json
- HTML version of this page: https://verifymcp.io/servers/com-athenode-cli/athenode-cli
