A
licenseA
qualityD
maintenanceEnables multiple AI agents to coordinate work on the same codebase by providing real-time file locking, commit approval, and agent awareness through a lightweight WebSocket-based MCP server.
9
16
11
MIT
mesh
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@meshshow me the roster of alive agents"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
mesh
The cross-agent communicator. A standalone coordination layer for fleets of agents working the same repository — presence, resource locks, and durable messaging — exposed as a single zero-dependency MCP server.
mesh is the communication primitive extracted from the machine's
hub daemon and reimplemented as a self-contained plugin. No daemon to keep
alive, no port to bind, no toolchain to build: just node. State is a single
JSON file under a repo-scoped .mesh/ directory, guarded by an OS-atomic lock
so multiple agents (and multiple processes) can coordinate safely.
Why
When several agents share one codebase they trip over each other: two edit the
same file, a plan waits on an answer that never arrives, a crashed worker leaves
a lock wedged forever. mesh gives them three things and nothing else:
Awareness — who is alive, on what branch, doing what.
Claims — atomic, leased resource locks with a monotonic fence token, a fair FIFO queue, and self-healing when a holder dies.
Messaging — durable, ULID-ordered messages with per-agent read cursors, broadcast (
*), and topic subscriptions.
A dead agent never wedges the mesh: liveness has a TTL, leases expire, and locks held by the dead are reaped and promoted to the next waiter automatically.
Related MCP server: agent-comm
Install (as a Claude Code plugin)
/plugin marketplace add yesitsfebreeze/mesh
/plugin install mesh@meshThe plugin registers one MCP server (mesh) exposing nine tools. State is
written to .mesh/ in the current project (add it to .gitignore).
The tool surface
Every agent identifies itself with a stable agent_id.
Awareness
tool | purpose |
| Announce presence and refresh liveness (heartbeat). Re-registering after death bumps an |
| List known agents, their |
register takes agent_id, branch, prompt_ptr, optional role and
ttl_seconds (default 60). An agent is alive within its TTL, stale for a
30s grace window after, then dead — at which point it is hidden from the
roster (unless include_stale: true) and its locks become reapable.
Claims (leased, fenced locks)
tool | purpose |
| Atomically acquire — or queue for — a resource lock. |
| Relinquish a held claim or cancel a queued ticket. |
| Inspect current locks and queues. |
claim { "agent_id": "a", "resource": "feature:auth", "mode": "exclusive",
"lease_seconds": 120, "wait": "queue", "note": "wiring login" }
// -> { "status": "granted", "claim_id": "01K…", "fence": 7, "lease_expires_at": "…" }mode—exclusive(default) orshared. Shared holders co-exist; an exclusive request is denied/queued while any holder is present.lease_seconds— the lock auto-expires after this (default 120). Re-claimby the same holder is an idempotent renewal — sameclaim_id, samefence.wait—no_wait(default) returnsdeniedif held;queueappends a FIFO ticket and returnsqueuedwith aqueue_position.fence— a per-resource monotonically increasing token, bumped on every grant/promotion. Use it to reject stale writers (fencing tokens, à la Kleppmann).
On release the next queued ticket is promoted (and, for shared, a run of
consecutive shared waiters is promoted together). When a holder's agent dies or
its lease lapses, the lock is reaped on the next touch and the queue advances —
no manual cleanup.
Messaging (durable, ordered, cursored)
tool | purpose |
| Send a durable message — to an |
| Peek pending messages without advancing the cursor. |
| Advance the read cursor up to a message id (acknowledge consumption). |
post { "agent_id": "a", "to": "topic:build", "subject": "green",
"body": "main is green", "ttl_seconds": 3600 }
inbox { "agent_id": "b", "topics": ["build"] } // -> { messages: [...], cursor, unread }
read { "agent_id": "b", "up_to": "01K…" } // -> { cursor, remaining }Messages are ULID-keyed, so the delivery log is totally ordered. Each agent has
its own cursor: inbox shows everything addressed to it above its cursor;
read moves the cursor forward (monotonic — it never goes backwards).
Addressing: direct (to: "b"), broadcast (to: "*", delivered to all), or
topic (to: "topic:x", delivered only to agents that pass topics: ["x"]).
Optional ttl_seconds makes a message self-expire.
Maintenance
tool | purpose |
| Drop TTL-expired messages and sweep dead claims; returns |
Reaping also happens opportunistically inside roster and claims, so gc is
only needed to reclaim expired messages eagerly.
Standalone use (without Claude Code)
It is a plain MCP stdio server — drive it from anything that speaks JSON-RPC:
node bin/mesh-mcp.mjs # reads JSON-RPC lines on stdin, replies on stdout
MESH_DIR=/path/to/.mesh node bin/mesh-mcp.mjs # override the state directoryOr import the core directly:
import { Mesh } from "@yesitsfebreeze/mesh";
const mesh = new Mesh(".mesh");
mesh.register({ agent_id: "a", branch: "main", prompt_ptr: "demo" });
mesh.claim({ agent_id: "a", resource: "feature:x" });The Mesh constructor accepts an injectable clock (() => unixSeconds) as its
second argument, which makes lease/liveness behavior deterministic in tests.
State & concurrency
All state lives in
.mesh/state.json—roster,claims,messages,log,cursors,events,fence_floor. Delete the directory to reset.Every mutation runs under an OS-atomic lock directory (
mkdirsucceeds for exactly one process) and is persisted with a temp-file + atomic rename, so concurrent agents and processes never corrupt the file. A stale lock from a crashed holder is stolen after 5s.
Test
npm test # node --test — 12 behavioral-parity cases, zero dependenciesLicense
MIT
Available Tools
9 toolsclaimC
Atomically acquire (or queue for) a resource lock.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | ||
| note | No | ||
| wait | No | ||
| agent_id | Yes | ||
| resource | Yes | ||
| lease_seconds | No |
TDQS
C2.7/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description discloses atomicity and queueing behavior, but lacks details on failure modes, blocking behavior, or return values. With no annotations, this is moderately helpful but incomplete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is a single, concise sentence that is well front-loaded. It is efficient but misses parameter details that could be added without verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 6 parameters, 2 enums, and no output schema, the description lacks critical context about return values, parameter meaning, and locking semantics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, and the description provides no explanation of any of the 6 parameters, including required fields like agent_id and resource.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool acquires or queues for a resource lock, with specific verbs and resource. However, it does not explicitly distinguish itself from sibling tools like 'claims' or 'release'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No when-to-use or when-not-to-use guidance is provided. The description implies usage for locking, but without context of when to choose this over alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
claimsC
Inspect current locks and queues.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| agent_id | Yes | ||
| resource | No |
TDQS
C2.7/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only states 'Inspect', implying read-only, but does not confirm no side effects, describe error behavior, or explain how locking/queuing works. This leaves significant ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, achieving conciseness and front-loading the core action. However, it may be too sparse for a tool with two parameters and no output schema, sacrificing completeness for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description should hint at return values. It does not. Parameters are unexplained, and there is no context on how to use the tool effectively. The tool's purpose is clear but the description fails to equip an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description should clarify parameter meanings. It does not explain what 'agent_id' or 'resource' represent in the context of inspecting locks and queues. The schema provides no descriptions either, so both are opaque.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the verb 'Inspect' and resource 'locks and queues', clearly indicating a read-only monitoring action. It distinguishes from siblings like 'claim' and 'release', which perform mutations, but the domain-specific meaning of 'locks and queues' is not explained.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or preferred contexts, leaving the agent to infer from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
gcA
Drop TTL-expired messages and sweep dead claims; returns reclaimed count.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
A3.7/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It only states the action and return value, lacking details on side effects (e.g., irreversibility), required permissions, or performance impact.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no waste, effectively communicates the core purpose and return value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a parameterless tool, but lacks behavioral context (e.g., safety, prerequisites). With no output schema or annotations, more detail on scope would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, so the description does not need to add parameter information. Baseline 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Drop TTL-expired messages and sweep dead claims') and specifies the resource. It distinguishes from sibling tools like 'claim' and 'post' by focusing on garbage collection.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied (cleanup of expired messages and dead claims) but no explicit when-to-use or when-not-to-use guidance is provided. No alternatives are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
inboxA
Peek pending messages without advancing the cursor.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| since | No | ||
| topics | No | ||
| agent_id | Yes |
TDQS
A3.7/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It effectively communicates that the tool does not advance the cursor (i.e., is read-only). This is a key behavioral trait. However, it omits other details like authentication, rate limits, or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is a single sentence that front-loads the core purpose and key behavioral characteristic. Every word is necessary; no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite a simple purpose, the tool has four parameters with zero schema descriptions and no output schema. The description fails to explain how parameters affect behavior, what constitutes 'pending messages', or what the return format is, making it incomplete for agents.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It does not mention any of the four parameters (limit, since, topics, agent_id) or their roles. The description adds no meaning beyond the schema's bare type definitions, leaving agents to guess parameter purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it peeks pending messages without advancing the cursor, using a specific verb (peek) and resource (pending messages). This distinguishes it from sibling tools like 'read' (which likely advances cursor) and 'claim' (which marks messages).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description implies non-destructive preview via 'peek' and 'without advancing the cursor', but lacks explicit guidance on when to use this tool versus alternatives like 'claim' or 'read'. No direct comparison or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
postC
Send a durable message (agent_id, * broadcast, or topic:).
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| to | Yes | ||
| body | Yes | ||
| subject | No | ||
| agent_id | Yes | ||
| reply_to | No | ||
| ttl_seconds | No |
TDQS
C2.6/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only mentions 'durable message' but does not disclose important traits like authentication needs, idempotency, or error behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short (one line), which is concise, but it lacks proper structure and clarity. It reads as a fragment rather than a complete sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 6 parameters, no output schema, and sibling tools likely in the same domain, the description is insufficient. It does not explain return values, error handling, or how to format recipients for different modes.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description only hints at the 'to' parameter with examples. Required parameters like 'agent_id' and 'body' are not explained, nor are optional ones like 'subject' or 'ttl_seconds'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the action ('send a durable message') and provides examples of recipients (agent_id, broadcast, topic). However, it does not clearly distinguish from sibling tools like 'read' or 'inbox', which are likely messaging-related.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. The description lacks context such as prerequisites, typical use cases, or explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
readC
Advance the read cursor (acknowledge consumption).
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| up_to | Yes | ||
| agent_id | Yes |
TDQS
C2.2/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description is too brief to disclose behavioral traits like side effects, idempotency, or required permissions beyond the action of advancing a cursor.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise but lacks structure and is under-specified, missing critical details that would make it effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with two required parameters and no annotations or output schema, the description is incomplete and fails to provide a clear understanding of how to use it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema coverage and no parameter details in the description, the agent receives no additional meaning for 'agent_id' or 'up_to' beyond their names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the action is to 'Advance the read cursor' which is a specific verb and resource, but it does not distinguish from siblings like 'inbox' or 'claims', leaving the purpose somewhat vague.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, nor any prerequisites or conditions, leaving the agent without context for invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
registerC
Announce presence and refresh liveness (heartbeat).
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| role | No | ||
| branch | Yes | ||
| agent_id | Yes | ||
| prompt_ptr | Yes | ||
| ttl_seconds | No |
TDQS
C2.7/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It implies a safe, periodic operation but doesn't disclose side effects, authentication needs, or behavior on failure (e.g., if the agent is already registered).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence, front-loading the core action. However, it sacrifices detail for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 5 parameters, no output schema, and no annotations. The description omits critical context such as return values, parameter effects, and operational constraints, leaving the agent under-informed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description provides no explanation of parameters like role, ttl_seconds, or prompt_ptr. The agent must guess their meanings from the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool registers presence and refreshes liveness, acting as a heartbeat. It distinguishes from siblings like claim, read, etc., which don't relate to registration.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use register versus alternatives. The description does not specify prerequisites, frequency, or scenarios where this should be called.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
releaseC
Relinquish a held claim or cancel a queued ticket.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| agent_id | Yes | ||
| claim_id | Yes | ||
| resource | Yes |
TDQS
C2.4/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description implies mutating state (relinquishing or canceling) but discloses no behavioral traits such as authorization needs, reversibility, side effects, or outcomes. No annotations are provided to compensate for this lack of transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, making it concise. However, the brevity comes at the cost of completeness; it is adequately structured but lacks important details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of parameter descriptions, no output schema, and no annotations, the description is severely incomplete. It does not explain what 'resource' refers to, how claims and tickets are related, or what the output looks like, leaving an AI agent with insufficient context to use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage for its three required parameters. The description does not explain the meaning of 'agent_id', 'claim_id', or 'resource', nor how they relate to the operation. This adds no value beyond the schema listing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific verbs ('relinquish', 'cancel') and clearly states two use cases: releasing a held claim or canceling a queued ticket. However, it does not distinguish itself from sibling tools like 'claim' or 'gc' which might perform related actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives. The description does not mention any prerequisites, context, or situations where another tool would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
rosterC
List known agents and their liveness.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| agent_id | Yes | ||
| include_stale | No |
TDQS
C2.3/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must convey behavioral traits. It states it lists data, implying read-only, but does not disclose auth requirements, rate limits, or what 'liveness' entails operationally.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, but it is under-specified rather than concise. It lacks necessary detail for a tool with two parameters and no output schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (2 params, no output schema, no annotations), the description is severely incomplete. It does not explain the purpose of agent_id, the meaning of liveness, or the effect of include_stale, leaving the agent with inadequate context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no meaning to the two parameters (agent_id, include_stale). Since schema description coverage is 0%, the agent receives no guidance on what agent_id refers to or how include_stale affects the results.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'List' and identifies the resource 'known agents' with a property 'liveness'. It is clear and distinguishes from sibling tools like claim or release which are actions, not listing tools. However, it could be more precise about what 'liveness' means.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No usage context is provided. The description does not indicate when to use this tool over others, nor does it mention any prerequisites or exclusions. With siblings like read and claims, guidance is missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
9 tool updates
v1.0.0- First observed
claim - First observed
claims - First observed
gc - First observed
inbox - First observed
post - First observed
read - First observed
register - First observed
release - First observed
roster
TDQS
B3.2/5.0
Disambiguation5/5
Each tool targets a distinct operation: locking, inspecting, garbage collection, peeking, sending, reading, registering, releasing, and listing. Descriptions clearly differentiate them, with no overlapping purposes.
Naming Consistency4/5
Most tool names are single-word verbs, but 'gc' is an abbreviation and 'roster' is a noun, introducing slight inconsistency. However, the pattern is largely predictable.
Tool Count5/5
With 9 tools, the server covers essential operations for messaging and locking without superfluous tools. The count feels well-scoped.
Completeness4/5
The tool set provides full lifecycle for messages (post, read, inbox, gc) and locks (claim, claims, release), plus presence (register, roster). Minor missing features like explicit message deletion or broadcast-only send could be present but are not critical gaps given descriptions.
Maintenance
ActivityStale
ResponsivenessSyncing
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Agent communication platform for agent to agent messaging via MCP. Messages, channels, skills.
MCP Server for an Agent Task Marketplace
Hosted MCP messaging across owners, tools, and machines, with readable transcripts.
Agent-native collaboration network: orchestrate a team of long-running agents from any MCP client.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server that enables AI coding agents to communicate, share state, and coordinate work in real time via MCP tools or REST API.1595MIT
- AlicenseBqualityBmaintenanceCross-agent messaging for MCP clients, enabling agents to discover one another, exchange threaded messages, and resume work in a persistent project room.191MIT
- AlicenseNot gradedqualityBmaintenanceMCP server for coordinating multiple AI agents across developers and vendors with a shared job board, per-file locking, and live project context.5AGPL 3.0
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/yesitsfebreeze/mesh'
If you have feedback or need assistance with the MCP directory API, please join our Discord server