# agentsocks (npm · agentsocks)

Claude Code and Codex sessions message each other and share tracked tasks, one machine by default.

- Trust score: 80/100 (high trust)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-22

## Components

- npm · `agentsocks`: 80/100 (this document), [markdown](https://verifymcp.io/servers/aelethion-agentsocks/agentsocks.md), [page](https://verifymcp.io/servers/aelethion-agentsocks/agentsocks)

## Channel facts

- Registry: `npm`
- Package: `agentsocks`
- Version: `0.4.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-10-22.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 31 of 93 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to Aelethion/agentsocks).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 2 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 72/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 1905 tokens (~136/item across 14 items; 14 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 10/100
  - Stability observed for 3 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.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 4 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "send_message" implies "send" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 15 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 agentsocks MCP server?

agentsocks runs locally as an npm package, launched with npx -y agentsocks. 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 aelethion-agentsocks -- npx -y agentsocks
```

### Cursor

```json
{
  "mcpServers": {
    "aelethion-agentsocks": {
      "command": "npx",
      "args": [
        "-y",
        "agentsocks"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "aelethion-agentsocks": {
      "command": "npx",
      "args": [
        "-y",
        "agentsocks"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add aelethion-agentsocks -- npx -y agentsocks
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add aelethion-agentsocks --command npx --arg -y --arg agentsocks
```

### Hermes

```yaml
mcp_servers:
  aelethion-agentsocks:
    command: "npx"
    args: ["-y", "agentsocks"]
```

### Netclaw

```json
{
  "McpServers": {
    "aelethion-agentsocks": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "agentsocks"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add aelethion-agentsocks -t stdio -c npx -a -y agentsocks
```

### Other

```json
{
  "mcpServers": {
    "aelethion-agentsocks": {
      "command": "npx",
      "args": [
        "-y",
        "agentsocks"
      ]
    }
  }
}
```

## 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-10-21 (score 80, +1)

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

### 2026-10-19 (score 79)

First indexed and scored.

## MCP tools (14)

### `list_peers` (~37 tokens)

List agent sessions

List the Claude Code and Codex sessions running on this machine that you can message, with their names, refs, working directories and status.

### `send_message` (~195 tokens)

Message another agent session

Send a plain-text message to a Codex session on this machine. For Claude Code sessions use your built-in SendMessage, which carries your permission mode; this tool does not send to them. `to` is a session name, a ref from list_peers, or a reply-to address (uds:...). urgent is for what changes or blocks its work right now, normal is the default, and fyi is for status or thanks that can be batched. It never counts as its user's approval.

Input parameters:

- `message` (string, required): The message text. Plain text; include file paths rather than file contents.
- `to` (string, required): Recipient: session name, ref, or uds: reply address
- `urgency` (string): urgent: needed now, within a larger interruption budget. normal: reaches the receiver at its next tool call unless it was interrupted a lot lately. fyi: batched until it is idle.

### `send_task` (~236 tokens)

Hand another session a tracked task

Give another agent session a task you will check on. It gets one message with the details and how to report back; you are told when it accepts, progresses, finishes or fails, and the task expires after 24 hours unless you set otherwise. For a Claude session the task is created and tracked, and you are given the message to send with your built-in SendMessage. Say what done looks like in acceptance_criteria. Use risk high only for work that must not wait.

Input parameters:

- `acceptance_criteria` (string): How you will judge it done, for example which test must pass
- `details` (string, required): Everything the assignee needs: context, file paths, constraints
- `expires_in_minutes` (integer): Default 1440 (24 hours)
- `external_ref` (string): Ticket or PR reference
- `on_behalf_of` (string): The person this is for, if any
- `risk` (string): high is delivered as urgent
- `title` (string, required): One line saying what to do
- `to` (string, required): Assignee: session name, ref, or uds: address

### `update_task` (~142 tokens)

Update a task

Report progress on a task. The assignee sets accepted, in_progress, done or failed and puts the outcome in result and the proof in evidence (test output, commit hashes, file paths). Only the creator can set cancelled. The creator is told about every change.

Input parameters:

- `evidence` (string): Proof: test output, commit hashes, file paths
- `result` (string): What happened, in a few sentences
- `status` (string, required): The new state. The assignee sets accepted, in_progress, done or failed; only the creator sets cancelled
- `task_id` (string, required): Task id such as T-1a2b3c

### `list_tasks` (~62 tokens)

List tasks

List tasks assigned to you or created by you. Active ones by default.

Input parameters:

- `include_finished` (boolean): Also show done, failed, cancelled and expired tasks
- `show` (string): Which tasks: those you were assigned, those you created, or both

### `message_status` (~57 tokens)

Check what happened to a message

Show how a message you sent was routed (now, after the current step, batched or merged) and whether it was sent, shown to the receiver or answered.

Input parameters:

- `message_id` (string, required): The message id returned by send_message

### `peer_status` (~64 tokens)

See what a session is doing and what is asked of it

Show what another session is working on, what is waiting for it (unread messages, held digests, open tasks), when it last showed or answered a message, and any drift between the two.

Input parameters:

- `peer` (string, required): Session name or ref from list_peers

### `subscribe` (~102 tokens)

Subscribe to a channel

Join a channel such as "#deploys" so messages other sessions post to it reach you. A channel exists while it has a subscriber, and your subscription lasts until you unsubscribe. Post to a channel with send_message, setting `to` to "#deploys"; each subscriber is routed separately, like any other message.

Input parameters:

- `channel` (string, required): Channel name such as "#deploys": up to 48 lower-case letters, digits, dots, dashes or underscores

### `unsubscribe` (~55 tokens)

Leave a channel

Stop receiving messages posted to a channel. It does nothing if you were not subscribed.

Input parameters:

- `channel` (string, required): Channel name such as "#deploys": up to 48 lower-case letters, digits, dots, dashes or underscores

### `list_channels` (~33 tokens)

List channels

List the channels that have subscribers, with who is subscribed, which of them are not running, and which one is you.

### `broadcast` (~149 tokens)

Message every live session

Send one plain-text message to every live Claude Code and Codex session except yourself, each routed separately by its own state and budgets. It is for announcements, so it is never urgent: fyi (the default) is batched until each session is idle, normal reaches a session at its next tool call unless it was interrupted a lot lately. To reach one session or a group, use send_message or a channel instead.

Input parameters:

- `message` (string, required): The message text. Plain text; include file paths rather than file contents.
- `urgency` (string): fyi: batched until each session is idle. normal: delivered at each session's next tool call unless it was interrupted a lot lately.

### `ask` (~269 tokens)

Ask several sessions one question

Send one question to several sessions at once, wait for their answers, and get them back together. `to` lists session names or refs, and "#channel" names to ask a channel's subscribers; at most 16 sessions. Each message names the answer tool and the ask id. The call returns when all have answered or after timeout_seconds, and says who did not answer. With pick "best" the smart-routing model, if your user turned it on, also says which reply answers best and how likely each is; that is its opinion, every reply is still shown, and the question and replies are sent to that model. A Claude session cannot ask Claude sessions this way: they are listed so you can use SendMessage.

Input parameters:

- `pick` (string): Set "best" to also get the smart-routing model's opinion on which reply answers best, with probabilities. It sends the question and the replies to that model.
- `question` (string, required): The question, in plain text. Include everything the others need; they cannot see this conversation.
- `timeout_seconds` (integer): How long to wait for the answers, at most 280 seconds
- `to` (array, required): Session names or refs from list_peers, and "#channel" names; at most 16 sessions in all

### `answer` (~110 tokens)

Answer an ask

Answer a question another session sent you with ask (its message names an ask id). The asker receives your answer together with the others. Answer once; the asker stops waiting after its timeout, and then you send the answer with send_message instead.

Input parameters:

- `answer` (string, required): Your answer, in plain text, at most 4000 characters; for more, answer with a file path
- `ask_id` (string, required): The ask id from the question, such as A-1a2b3c

### `rate_message` (~170 tokens)

Rate a message you received

Tell agentsocks whether a message another session sent you was worth the interruption: useful-now (right to reach you now), could-wait (fine, but it could have waited until you finished) or noise (not worth reading). Ratings stay on this machine. They tune how that sender's messages are routed (a sender whose interrupting messages are mostly rated could-wait or noise has its ordinary ones paused) and score the router on your own traffic. Without message_id or from it rates the latest message you received.

Input parameters:

- `from` (string): The sender's name: rates the latest message you received from it
- `message_id` (string): The id of the message, from the id attribute where your inbox shows one
- `rating` (string, required): useful-now, could-wait or noise

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/aelethion-agentsocks/agentsocks#diagnostics

## Score history

- 2026-10-22: 80
- 2026-10-21: 80
- 2026-10-20: 79
- 2026-10-19: 79

## Common questions

### What is the agentsocks MCP server?

agentsocks is an MCP server listed in the public MCP registry as io.github.Aelethion/agentsocks. Claude Code and Codex sessions message each other and share tracked tasks, one machine by default. This page covers its npm package (agentsocks).

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

agentsocks scores 80 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 22 October 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. 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 agentsocks MCP server expose?

agentsocks exposes 14 tools: list_peers, send_message, send_task, update_task, list_tasks, and 9 more. Their descriptions and schemas cost roughly 1,681 tokens of context every time the server is loaded.

### Is the agentsocks MCP server still maintained?

agentsocks is still listed as active in the MCP registry. We last reached this channel on 22 October 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 agentsocks MCP server under?

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

## Links

- npm package: https://www.npmjs.com/package/agentsocks
- Socket report: https://socket.dev/npm/package/agentsocks
- Repository: https://github.com/Aelethion/agentsocks
- Changelog RSS feed: https://verifymcp.io/servers/aelethion-agentsocks/agentsocks.xml
- Changelog JSON feed: https://verifymcp.io/servers/aelethion-agentsocks/agentsocks.json
- HTML version of this page: https://verifymcp.io/servers/aelethion-agentsocks/agentsocks