Skip to main content
Glama

mesh_wait_ring

Wait up to the requested time for the next inbound ring, returning the moment any new ring is recorded. Use this instead of repeated polling to react to incoming messages without a sleep-then-check loop.

Instructions

Block for up to wait_seconds (max 3600) for the next incoming ring -- the passive counterpart to polling mesh_read_inbox for a new one under rings.pending. Covers every incoming ring, not only ones still awaiting your own answer: open/closed/allowlist policies resolve theirs immediately, 'ask' leaves one pending for mesh_answer_ring -- this call returns the instant any of them is recorded, so check the returned ring's own answer field. Reads the same background recording ring serving already does on every real inbound ring (active from presence.start() onward, independent of this call), so there is nothing new to start watching. An MCP host that backgrounds a slow tool call and delivers the result as a notification (Claude Code does) turns this into real low-latency push, not a client stuck blocking. Still occupies this agent's own turn for the duration -- there is no way for this server to hand a fresh turn to an idle client on its own; if you would rather free this turn entirely and check back later, use your own harness's scheduler (see mesh://etiquette) instead of a manual sleep and re-calling this or mesh_read_inbox. Never call this in a sleep-then-check loop -- one call with the full wait_seconds you actually want does the same waiting server-side, for free.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
wait_secondsYesHow long to wait (max 3600).

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.28.7

TDQS

A3.9/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It does well in some areas: it explains blocking semantics, maximum wait time, scope of rings (not just unanswered ones), and the relationship to the background recording ring (active from presence.start()). However, it lacks detail on the exact return value format (the ring object) and how the 'answer' field is structured. While the description is helpful, it doesn't fully disclose the output shape, so a 3 is appropriate.

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 dense paragraph that front-loads the purpose but then becomes long-winded with extraneous asides about MCP host backgrounding, Claude Code, and turn-management philosophy. This could have been split into clear sections or trimmed significantly. It is not concise and the structure hampers readability, though the first sentence is efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (one simple parameter, no output schema), the description covers the key behaviors: blocking semantics, scope of rings, background recording, and alternatives when to avoid blocking. Without an output schema, it could have specified the returned ring structure, but it implicitly references the 'answer' field lazily, which may be acceptable. Overall, it is nearly complete but has minor gaps on the return format.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already has 100% coverage with a description for wait_seconds: 'How long to wait (max 3600).' The tool's description adds context about the max value but not significantly more than the schema. The description does imply the parameter's role in blocking duration, but that's already clear from the schema. Thus, with high schema coverage, a baseline of 3 is maintained.

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 'Block for up to wait_seconds (max 3600) for the next incoming ring', specifying a precise verb ('block'), resource ('incoming ring'), and limits. It also explicitly contrasts with 'polling mesh_read_inbox', which differentiates it from a close sibling. The distinction is clear without needing to inspect schemas.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit guidance on when to use this tool: it is the passive counterpart to polling mesh_read_inbox, covers all incoming rings (open/closed/allowlist resolve immediately, 'ask' leaves one pending), and the agent is instructed to check the returned ring's answer field. It also gives strong when-not-to-use guidance by advising against sleep-then-check loops and recommending the harness scheduler via mesh://etiquette instead. This is rich, actionable usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.