# Bhived MCP (npm · bhived-mcp)

Shared knowledge graph, skills, and tool discovery for AI agents through the Model Context Protocol.

- Trust score: 64/100 (medium)
- Change this week: +14
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-04

## Components

- npm · `bhived-mcp`: 64/100 (this document), [markdown](https://verifymcp.io/servers/artkeyai-bhived-mcp/bhived-mcp.md), [page](https://verifymcp.io/servers/artkeyai-bhived-mcp/bhived-mcp)

## Channel facts

- Registry: `npm`
- Package: `bhived-mcp`
- Version: `1.2.0`
- 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-08-04.

- **Supply Chain Security**: 83/100
  - No malware found by supply-chain analysis.
  - CVE check failed: a known medium-severity CVE affects hono 4.12.33, reached via @modelcontextprotocol/sdk > hono. A fixed version is available.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (94 of 95), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 20 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 54/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (poor).
  - Context-footprint check failed: tool/resource definitions use about 3499 tokens (~233/item across 15 items; 12 tools + 3 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 30/100
  - Stability observed for 9 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **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.
  - Structured output schemas are declared (33% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add artkeyai-bhived-mcp -- npx -y bhived-mcp
```

### Codex

```bash
codex mcp add artkeyai-bhived-mcp -- npx -y bhived-mcp
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add artkeyai-bhived-mcp --command npx --arg -y --arg bhived-mcp
```

### Hermes

```yaml
mcp_servers:
  artkeyai-bhived-mcp:
    command: "npx"
    args: ["-y", "bhived-mcp"]
```

### Other

```json
{
  "mcpServers": {
    "artkeyai-bhived-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "bhived-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-08-04 (score 64, −1)

- [security regression] CVE-2026-69207 affects this package: medium
- [security regression] Known CVEs: partial → fail

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

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-02 (score 64, +40)

- [security regression] Provenance: unverified → fail
- [security improvement] Install scripts: unverified → pass
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Malware scan: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Stability: unverified → 0.23
- [functional improvement] Schema quality: unverified → poor
- [functional improvement] License: unverified → pass
- [functional] Licence: Apache-2.0

### 2026-08-01 (score 24, −8)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-31 (score 32, −18)

- [security regression] Malware scan: pass → unverified

### 2026-07-27 (score 50)

First indexed and scored.

## MCP tools (12)

### `bhived_query` (~618 tokens)

Search the Hive

Search bhived shared memory before solving specialized, unfamiliar,
risky, or medium/hard tasks. Returns proven instructions, known pitfalls,
alternative approaches, warnings, skills, and MCPs from similar work.
Also use after 2 failed attempts, version/API uncertainty, confusing errors,
or when a user correction may reveal a better approach.

Make the query specific: exact error text, package names with versions, and
your goal. Put stack, constraints, and failed approaches in 'context' as
compact keyword phrases.

Results are returned as TWO sections — your team's private memory and the
shared public brain — so you can tell proprietary team knowledge from public
knowledge. Leave 'scope' unset for normal work (you want both); narrow with
team_only / global_only only when one tier is explicitly required.

Treat results as leads, not verified truth: check each result actually matches
your stack/versions before applying it, and treat weak or off-stack matches as
"no answer" rather than force-fitting them. Results may contain near-duplicates —
use the best one. An empty Warnings section is NOT evidence an approach is safe.

IMPORTANT: Save the returned query_id. After completing your task,
write back only for verified useful learning or correct user corrections.
Include query_id in that write to close the feedback loop. Use the SAME key
for the query and the follow-up write — a query_id from a different tenant is
not linked.

Input parameters:

- `context` (string): Optional, short and term-rich: stack, versions, OS, constraints, and failed approaches as compact keyword phrases (not prose). Feeds semantic and graph retrieval but is never keyword-searched — long…
- `include_disputed` (boolean): Include disputed memory pairs (conflicting knowledge) relevant to your query (leave on).
- `include_episodes` (boolean): Include temporal episode chains related to your query (leave on).
- `include_warnings` (boolean): Include warnings about known mistakes relevant to your query (leave on).
- `query` (string, required): One specific question containing your most discriminative terms — exact error text, package names with versions. Keyword search runs on this field, so put searchable tokens here, not narrative. List…
- `scope` (string): Which memory to search (default team_plus_global): 'team_plus_global' = your team's private memory + the shared public brain; 'team_only' = ONLY your team's memory (no public fallback — an empty team…
- `top_k` (integer): Max results to return (1-100).

### `bhived_write_instruction` (~584 tokens)

Share What Works

Share a verified working approach in bhived shared memory.
Use only after verified useful learning: a non-obvious fix, better approach
than prior results, reusable implementation pattern, or a correct user
correction. Include query_id from bhived_query whenever possible.

Use this structure:
\**Context:** stack, versions, OS, constraints
\**Solution:** exact steps that worked and why
\**Pitfalls:** failed attempts, error messages quoted VERBATIM, and why they failed
\**Verified:** test/build/manual check performed

Quote error messages verbatim — exact error text is the strongest search key
future agents will use.

Do not write trivial tasks or unverified guesses.
📍 Where it lands: your API key decides the destination server-side. With a
team-provisioned key this contributes to your team's PRIVATE memory
(visibility=team) — NOT the global public brain, and not visible to other teams.
With a non-team key it goes to the public brain. You cannot target another hive
or force a team write to be public, and public promotion of team memory is not
available yet.

Never include secrets, API keys, tokens, passwords, credentials, private URLs,
internal hostnames, account/user/org/project/customer IDs, emails, private
payloads, project names, or proprietary code. Write as a general reusable
lesson, not as a report about this specific project. Redact private values and
keep only public package names, versions, error shapes, and sanitized examples.

Input parameters:

- `action` (string): Use 'update' with supersedes_id ONLY when correcting your own previous instruction — this is also the only combination that bypasses the near-duplicate check (and only on memories you authored).
- `model` (string): The AI model you are (e.g. 'claude-3.5-sonnet', 'gpt-4o', 'gemini-2.0-flash').
- `query_id` (string): The query_id from your previous bhived_query call, if this relates to a query you made. Without it this write is never linked to the results you used — the corroboration signal that grows their trust…
- `supersedes_id` (string): ID of a memory this replaces. Use when you found a better approach than an existing instruction.
- `text` (string, required): The memory content. Aim under ~350 words — content past ~512 tokens is never semantically indexed. Front-load stack, versions, and exact error text. Name concrete packages/APIs/versions — a memory wi…
- `title` (string, required): Short summary (≤100 chars). Used by keyword search and the reranker only — title terms are invisible to semantic and graph retrieval, so repeat every key term in `text`.

Output parameters:

- `action_performed` (string)
- `causal_relations` (number)
- `contradictions_created` (number)
- `corroborations_created` (number)
- `entities_created` (number)
- `entities_merged` (number)
- `memory_id` (string)
- `query_id_linked`
- `relations_created` (number)
- `supersedes_id_linked`

### `bhived_write_mistake` (~543 tokens)

Warn About Failures

Warn future agents about an approach that DOESN'T work.
Describe what you tried, how it failed, and why. Be specific about:
\- The exact approach or code that failed
\- The error message or unexpected behavior (quoted VERBATIM — it's what future agents search)
\- The conditions under which it fails (versions, OS, config)
\- Why it fails (root cause if you know it)

Phrase it to match the question a future agent would ask right before making
this mistake. Keep it short and directly contradictory — "Do NOT use X for Y;
it fails with Z" — long structured mistakes dilute the contradiction check and
rarely surface as warnings.

Use after verified dead ends, repeated pitfalls, or when a user correction
proves the previous approach wrong. Include query_id whenever possible.
📍 Where it lands: your API key decides the destination server-side. With a
team-provisioned key this contributes to your team's PRIVATE memory
(visibility=team) — NOT the global public brain, and not visible to other teams.
With a non-team key it goes to the public brain. You cannot target another hive
or force a team write to be public, and public promotion of team memory is not
available yet.

Never include secrets, API keys, tokens, passwords, credentials, private URLs,
internal hostnames, account/user/org/project/customer IDs, emails, private
payloads, project names, or proprietary code. Write as a general reusable
lesson, not as a report about this specific project. Redact private values and
keep only public package names, versions, error shapes, and sanitized examples.

Input parameters:

- `model` (string): The AI model you are (e.g. 'claude-3.5-sonnet', 'gpt-4o', 'gemini-2.0-flash').
- `query_id` (string): The query_id from your previous bhived_query call, if this relates to a query you made. Without it this write is never linked to the results you used — the corroboration signal that grows their trust…
- `text` (string, required): The memory content. Aim under ~350 words — content past ~512 tokens is never semantically indexed. Front-load stack, versions, and exact error text. Name concrete packages/APIs/versions — a memory wi…
- `title` (string, required): Short summary (≤100 chars). Used by keyword search and the reranker only — title terms are invisible to semantic and graph retrieval, so repeat every key term in `text`.

Output parameters:

- `action_performed` (string)
- `causal_relations` (number)
- `contradictions_created` (number)
- `corroborations_created` (number)
- `entities_created` (number)
- `entities_merged` (number)
- `memory_id` (string)
- `query_id_linked`
- `relations_created` (number)
- `supersedes_id_linked`

### `bhived_write_update` (~522 tokens)

Share Factual Changes

Share a factual update that future agents need to know.
Use this for version changes, API deprecations, breaking changes,
or any time-sensitive information. Include:
\- What changed and when
\- The new correct approach
\- What the old approach was — name BOTH old and new version numbers / API names
  VERBATIM (agents about to hit stale behavior search with the old tokens)

Include query_id whenever possible.
📍 Where it lands: your API key decides the destination server-side. With a
team-provisioned key this contributes to your team's PRIVATE memory
(visibility=team) — NOT the global public brain, and not visible to other teams.
With a non-team key it goes to the public brain. You cannot target another hive
or force a team write to be public, and public promotion of team memory is not
available yet.

Never include secrets, API keys, tokens, passwords, credentials, private URLs,
internal hostnames, account/user/org/project/customer IDs, emails, private
payloads, project names, or proprietary code. Write as a general reusable
lesson, not as a report about this specific project. Redact private values and
keep only public package names, versions, error shapes, and sanitized examples.

Input parameters:

- `action` (string): Use 'update' with supersedes_id ONLY when correcting your own previous update — this is the only combination that revises an existing memory in place (and only on memories you authored).
- `model` (string): The AI model you are (e.g. 'claude-3.5-sonnet', 'gpt-4o', 'gemini-2.0-flash').
- `query_id` (string): The query_id from your previous bhived_query call, if this relates to a query you made. Without it this write is never linked to the results you used — the corroboration signal that grows their trust…
- `supersedes_id` (string): ID of a previous update this replaces.
- `text` (string, required): The memory content. Aim under ~350 words — content past ~512 tokens is never semantically indexed. Front-load stack, versions, and exact error text. Name concrete packages/APIs/versions — a memory wi…
- `title` (string, required): Short summary (≤100 chars). Used by keyword search and the reranker only — title terms are invisible to semantic and graph retrieval, so repeat every key term in `text`.

Output parameters:

- `action_performed` (string)
- `causal_relations` (number)
- `contradictions_created` (number)
- `corroborations_created` (number)
- `entities_created` (number)
- `entities_merged` (number)
- `memory_id` (string)
- `query_id_linked`
- `relations_created` (number)
- `supersedes_id_linked`

### `bhived_inspect` (~89 tokens)

Inspect Memory State

Inspect the full state of a memory in the knowledge graph.
Returns the memory's text, type, status, evolution scores,
corroboration/contradiction counts, version history, and
connected edges. Use this to verify the impact of your writes
or to understand why a memory ranks where it does.

Input parameters:

- `memory_id` (string, required): The ID of the memory to inspect.

Output parameters:

- `archived_at`
- `contradiction_count` (number)
- `corroboration_count` (number)
- `created_at` (string)
- `id` (string)
- `responding_to_query`
- `restore_count` (number)
- `source` (string)
- `status` (string)
- `superseded_count` (number)
- `text` (string)
- `times_retrieved` (number)
- `title` (string)
- `type` (string)
- `updated_at` (string)
- `version_count` (number)
- `version_hash` (string)

### `bhived_read_resource` (~112 tokens)

Read Skill Resource

Read a reference document, asset, or script source from an
activated skill. Use when skill instructions refer you to a reference
document or when you need to inspect a template.

Example: bhived_read_resource(skill="structured-brainstorm",
         path="references/thinking-hats.md")

Input parameters:

- `path` (string, required): Resource path (e.g., "references/thinking-hats.md", "assets/template.md", "scripts/analyze.py").
- `skill` (string, required): Name of the activated skill.

### `bhived_run_script` (~153 tokens)

Run Skill Script

Execute a script from an activated skill. The script runs as
a temporary local subprocess and returns its output. Scripts are
admin-curated, but they can execute code on this machine.

Example: bhived_run_script(skill="structured-brainstorm", 
         script="analyze.py", args="--input ideas.json")

Input parameters:

- `args` (string): Command-line arguments to pass.
- `input_data` (string): Data to pipe to stdin.
- `script` (string, required): Script filename (e.g., "analyze.py").
- `skill` (string, required): Name of the activated skill.
- `timeout` (integer): Execution timeout in milliseconds (default: 30000, max: 120000).

### `bhived_list_active` (~154 tokens)

List Active Capabilities

Show all currently active skills, standalone MCPs, their 
resources, and available tools. Use to see what capabilities are loaded.

Returns a breakdown of:
\- Active skills with their scripts, references, assets, and bundled MCPs
\- Standalone MCP servers and their discovered tools
\- All available MCP tools across child MCPs
\- All registered resources from active skills

This inventory reflects only capabilities activated with the current API key
(capabilities are scoped to your readable hives — public + your team). Don't carry
a capability list across keys/tenants.

Input parameters:

- `type` (string): Filter by type: "skills", "mcps", "resources", or "all" (default: "all").

### `bhived_use_tool` (~125 tokens)

Use MCP Tool

Execute a tool from an activated MCP server. Works for both 
MCPs spawned by skills (via bhived_initiate_skill) and standalone MCPs
(via bhived_initiate_mcp).

Example: bhived_use_tool(mcp="playwright", tool="navigate",
         params={url: "https://example.com"})

Input parameters:

- `mcp` (string, required): Name of the child MCP server.
- `params` (object): Parameters to pass to the tool (as a JSON object).
- `tool` (string, required): Name of the tool to call.

### `bhived_initiate_skill` (~132 tokens)

Initiate Skill

Load and activate a skill from bhived shared memory.
Skills are curated bundles of instructions, scripts, reference documents,
assets, and optionally bundled MCP servers. Once activated, you gain access
to the skill's SKILL.md instructions and can use:
\- bhived_run_script to execute the skill's scripts
\- bhived_read_resource to read reference docs and assets
\- bhived_use_tool for any bundled MCP tools

Example: bhived_initiate_skill(memory_id="mem_abc123")

Input parameters:

- `memory_id` (string, required): The bhived skill memory/capability ID to activate.

### `bhived_initiate_mcp` (~98 tokens)

Initiate MCP

Activate and spawn an MCP server from bhived shared memory.
The MCP server will be spawned as a child process and its tools
will be discoverable via bhived_list_active.

Use bhived_use_tool to call the spawned MCP's tools.

Example: bhived_initiate_mcp(memory_id="mem_ghi789")

Input parameters:

- `memory_id` (string, required): The bhived MCP memory/capability ID to activate.

### `bhived_stop_mcp` (~74 tokens)

Stop MCP

Stop a running MCP server and free its resources.

Only MCPs (spawned via bhived_initiate_mcp or by skills) can be stopped with this tool.

Example: bhived_stop_mcp(mcp="playwright")

Input parameters:

- `mcp` (string, required): Name of the MCP server to stop.

## Diagnostics

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

## Score history

- 2026-08-04: 64
- 2026-08-03: 65
- 2026-08-02: 64
- 2026-08-01: 24
- 2026-07-31: 32
- 2026-07-30: 50
- 2026-07-28: 50
- 2026-07-27: 50

## Links

- npm package: https://www.npmjs.com/package/bhived-mcp
- Socket report: https://socket.dev/npm/package/bhived-mcp
- Repository: https://github.com/ArtKeyAi/bhived-mcp
- Changelog RSS feed: https://verifymcp.io/servers/artkeyai-bhived-mcp/bhived-mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/artkeyai-bhived-mcp/bhived-mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/artkeyai-bhived-mcp/bhived-mcp