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

With no annotations, the description carries the full behavioral burden. It usefully discloses 'Fails closed' and the purpose of surfacing the gate in chat, but says nothing about what happens on approval vs denial, timing, or what the caller receives. Partial disclosure for a safety-relevant tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose is front-loaded in the first sentence, with the wiring detail and fail-closed behavior after. Three tight blocks with no filler, though the code-span wiring string is somewhat niche.

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

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

For a bridge tool with no annotations, no output schema, and 0% param coverage, the description covers purpose and the fail-closed guarantee but omits parameter meaning and return/approval semantics. Adequate to understand the concept, not quite enough to invoke confidently.

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

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

Schema description coverage is 0% across three parameters (tool_name, input, room_id), so the description must compensate. It implies a tool call is being approved but never names or explains any parameter, leaving room_id and input entirely undocumented in both places.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific and unusual function: a permission-prompt bridge that asks a human in the room to allow a tool call. That verb+resource framing clearly separates it from every sibling (none of which gate permissions). The generic name 'approve' is rescued by the description.

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

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

It gives concrete when-to-use context: wire it as Claude Code's permission-prompt-tool so a headless wake hitting a permission gate surfaces in chat instead of stalling. It stops short of naming explicit alternatives or when-not-to-use, but no sibling competes for this role, so the guidance is effectively clear.

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

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

With no annotations, the description carries the full behavioral burden, and it does not disclose whether 'checking' consumes messages, marks them read, or is an idempotent read. The word 'new' hints at an unread filter but nothing is confirmed. No auth, rate-limit, or state-change context is given.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One front-loaded sentence with no filler, and the scope qualifier ('to this instance') is placed where it counts. It is lean, though slightly under-specified for a tool whose keyword 'Check' carries an ambiguity.

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

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

For a zero-parameter tool with an output schema the description need not explain return values, so the remaining requirement is behavioral context. The one sentence leaves the key question unanswered—whether checking mutates read state—which is a meaningful gap given there are no annotations to fall back on.

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

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

The tool takes zero parameters and schema description coverage is 100%, so there is nothing for the description to compensate for; baseline 4 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a clear verb ('Check') and resource ('new messages') with an explicit scope, 'sent to this instance'. This separates it from the sending siblings (send_message, send_room_message) and from room-state tools. It stops short of 5 because 'Check' is ambiguous about whether messages are merely observed or consumed.

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

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 versus get_room_state, list_participants, or the send_* siblings, and no exclusions or prerequisites. Usage is only implied by the word 'new'.

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

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

With no annotations, the description carries the full burden, and it does disclose the two outcome states (GRANTED+token / LOCKED+holder), which is genuinely useful. However, it omits blocking behavior, TTL semantics, retry guidance, and permission requirements for a mutating lock acquisition.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short, front-loaded sentences with no filler; the lock semantics and result states come first and nothing is wasted.

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

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

For a 4-parameter mutating lock tool with zero annotation coverage and 0% schema description coverage, the description is too thin. An output schema covers return values, but the agent still lacks guidance on parameter meaning, TTL behavior, and conflict handling.

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

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

Schema description coverage is 0% across 4 parameters, so the description is the only place semantics could be added, and it says nothing about room_id, file_path, description, or ttl_seconds (including the 300s default). Only the vague mention of a 'token' hints at any parameter meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a specific verb (Acquire) and resource (optimistic file lock), which is far more informative than the tool name alone. It does not explicitly differentiate from the sibling release_task, leaving that pairing implicit.

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

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

There is no statement of when to use this tool versus release_task or any other sibling, and no preconditions (e.g., same room_id/file_path needed for release). Usage must be inferred entirely from the lock metaphor.

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

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

With no annotations, the description carries the full burden but does disclose one meaningful behavioral trait: the result lands in a read-only ref rather than a working branch. It omits whether this mutates the local repo, whether the ref must not already exist, idempotency, and any auth/room membership requirement.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single well-formed sentence that front-loads the verb and the value proposition. Slightly dense with project-specific jargon ('📦', 'quorus', 'refs/quorus/<them>/<branch>') that costs a newcomer some parsing effort.

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

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

An output schema exists, so return values need not be explained, and the destination ref is given. However, with three undocumented parameters and no annotations, the definition leaves an agent guessing about inputs and side effects before it can call the tool correctly.

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

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

Schema description coverage is 0% for all three parameters and the description explains none of them. The only hint is that bundle_id looks like 'b_...'; room_id and especially repo_path (default '.') are left entirely to inference, so the description fails to compensate for the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (fetch) and resource (a branch a teammate shared) and names the concrete artifact produced (refs/quorus/<them>/<branch>), which an agent can act on. It implicitly contrasts with the sibling share_branch but never names it explicitly, so it falls short of perfect sibling differentiation.

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

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

The parenthetical '📦 ... quorus fetch b_...' ties the tool to the shared-bundle trigger, so the when-to-use context is implied. There is no explicit statement of when NOT to use it, no mention of share_branch as the counterpart, and no prerequisite such as needing to be in the room.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Get' implies a read, but nothing is said about access requirements, whether the room must already be joined, what happens if room_id is unknown, or how fresh/large the state is. The enumerated return fields hint at scope but not at behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single dense sentence with zero filler, and the resource and its contents are front-loaded. It reads as a fragment rather than a sentence, which slightly weakens clarity, but nothing is wasted.

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

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

The output schema exists, so return values need not be explained, and the description's field list is a helpful preview. However, with no annotations and 0% parameter coverage, gaps remain around access preconditions, error behavior, and differentiation from sibling query tools.

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

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

Schema description coverage is 0% and the description never mentions the required room_id argument. room_id is largely self-describing, but nothing clarifies its format, whether it is a UUID versus a name, or how to obtain it. The description adds essentially no parameter meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('Get') and a named resource ('Shared State Matrix'), then enumerates the domains it covers (goal, tasks, locks, decisions, agents). An agent can distinguish it from siblings like room_metrics or list_participants. It stops short of explicitly naming what it is not, so it falls just below the top band.

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

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

No indication of when to call this versus the many adjacent siblings (room_metrics, search_room, list_participants, list_room_tools). There is no prerequisite, no exclusion, and no alternative routing. Usage is only implicitly inferable from the name.

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

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

With no annotations, the description carries the full behavioral burden, and it only discloses the subscription side effect of joining. It says nothing about idempotency when already joined, whether the subscription persists across calls, or what permissions are required for a mutation-style state change.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence with the action front-loaded and zero filler; nothing could be trimmed without losing the one behavioral fact it conveys.

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

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

An output schema is present, so return values need not be described, and the tool is structurally simple with one required parameter. However, for a state-changing join operation with no annotations, the absence of any note on re-joining, permissions, or how to discover a room_id leaves meaningful gaps.

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

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

Schema description coverage is 0% and the description explains nothing about room_id — not its format, nor where to obtain a valid value (the sibling list_rooms is the obvious source). The name is fairly self-explanatory, but the definition adds no semantic value over the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb and resource ('Join a room') and adds the effect ('start receiving its messages'), which separates it from siblings such as list_rooms, send_room_message, and get_room_state. It stops short of naming an alternative, so it is clear but not fully differentiated.

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

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

The stated effect implies when to use it (when you want to begin receiving a room's messages), but there is no explicit when-not guidance, no mention of prerequisites, and no route to alternatives like list_rooms for discovering a room or send_room_message for the opposite operation.

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

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

With no annotations, the description carries the full burden, but the word "List" plus a read-only shape makes the safety profile reasonably inferable. It does add real behavioral value by disclosing the membership boundary — only participants who have actually sent messages, not every known identity — but says nothing about ordering, pagination, or whether scope is relay-wide or room-scoped.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with zero filler. The scope qualifier is placed immediately after the verb and resource, so the most useful constraint is read first.

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

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

An output schema exists, so return values need not be explained, and the absence of parameters removes most documentation burden. However, the description leaves open whether the listing is relay-wide or room-scoped and whether results are truncated, which matters for a discovery tool in a large relay.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate at the argument level. The scope clause in the description is the only parameter-like semantic and it is already covered.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a specific verb and resource ("List all known participants") with a qualifying scope clause ("who have sent messages through the relay"). It is clear on its own, but it never distinguishes itself from adjacent tools such as get_room_state, which plausibly also surfaces participants.

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

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

There is no guidance on when to call this versus get_room_state, list_rooms, or list_room_tools, and no stated prerequisites or exclusions. Usage is only weakly implied by the word "List".

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure and it does not deliver: nothing about visibility/permission scope (are private or unjoined rooms included?), pagination, or ordering. The read-only nature is only inferable from the verb 'List', and return shape is left entirely to the output schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single efficient sentence with the scope qualifier front-loaded and no filler. It is appropriately sized, though the brevity edges into under-specification rather than pure economy.

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

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

The output schema exists, so return values needn't be described, and there are no parameters to document, which means the low bar is nearly met. What is missing is behavioral context an agent needs to choose this tool correctly: room visibility, relationship to search_room, and any auth requirement.

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

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

The tool takes zero parameters, so there is no parameter meaning for the description to add; this is the baseline 4 for a no-arg tool with a 100%-coverage empty schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('List') and resource ('rooms') plus the scope extension 'with their members', so an agent knows this is a roster dump rather than a filtered lookup. It does not name or differentiate itself from the nearby search_room or room_metrics siblings, which costs it the top score.

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

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

The word 'all' implies an unfiltered enumeration, but the description never states when to prefer this over search_room or why you would call it instead of list_participants. No prerequisites, no exclusions, no alternate-tool routing.

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

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

With no annotations, the description carries the full burden and does disclose an access restriction ('Members only') and that it lists registered servers. It still omits pagination behavior, error conditions, and whether the room must exist, which are meaningful gaps for a no-annotation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences front-load the core action and then state the access constraint. There is no redundant or wasted wording.

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

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

For a simple one-parameter read tool with an output schema, the description covers purpose and access restriction adequately. The main remaining gap is room_id semantics, but return values are handled by the output schema.

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

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

Schema description coverage is 0% for the single required room_id parameter. The description only refers to 'the room' without adding format, source, or constraints for room_id, so it does not compensate for the missing schema documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb (List) and resource (MCP servers registered in the room), making its purpose unambiguous. It naturally distinguishes from siblings like list_rooms and list_participants without needing to name alternatives.

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

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

The phrase 'Members only' gives a clear eligibility prerequisite for using the tool. However, it does not mention when to prefer this tool over alternatives or any exclusions, leaving usage context implied rather than explicit.

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

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

With no annotations provided, the description carries the full behavioral burden. 'Fetch' implies a read, but the definition says nothing about authentication needs, tenant scoping rules, rate limits, or error behavior, leaving key behavioral traits undisclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single short, front-loaded sentence with no filler. It is efficient, though it is too brief to provide structural or contextual value.

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

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

An output schema exists, so return values need not be explained. However, with no annotations and no parameter documentation, the definition leaves notable gaps for even a simple one-parameter read tool.

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

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

Schema description coverage is 0% and the sole 'participant' parameter is undocumented. The description only obliquely implies that the argument identifies the participant, adding almost no semantic detail beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (fetch) and resource (a participant's capability manifest) scoped to a tenant. It is clear what the tool does, but it does not distinguish itself from siblings like search_capabilities or publish_capability.

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

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

There is no explicit when-to-use guidance, no prerequisites, and no mention of alternatives such as search_capabilities. Usage can only be inferred from the tool name and the implied intent of retrieving one participant's capabilities.

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

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

With no annotations, the description carries the full behavioral burden. It does add one real constraint not present in the schema: only 'this agent's' own memory can be deleted. However it says nothing about permanence/irreversibility, behavior when the key is absent, or idempotency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single tight sentence with the destructive action and scope front-loaded; nothing is wasted. The stray double-backtick formatting around ``key`` is a minor blemish but not a comprehension problem.

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

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

An output schema exists so return values need not be described, which lowers the bar. Still, for a destructive operation with two required parameters, the missing room_id semantics and the absence of any irreversibility or failure-mode note leave real gaps.

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

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

Schema description coverage is 0% for 2 parameters, so the description must compensate and only partially does: 'key' is named, but 'room_id' (a required parameter) is never mentioned and has no explanation anywhere. The room-scoping semantics of a delete are left entirely to inference.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (Delete) plus resource (memory entry), and scopes it to 'this agent's' memory under a named key. The verb alone distinguishes it from the memory_set/memory_get/memory_list siblings, though the description never names them.

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

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

No when-to-use guidance and no comparison to siblings such as memory_set (which could overwrite instead of delete) or memory_list (to check what exists first). The parenthetical '(GDPR)' hints at a compliance motivation but does not tell an agent when this tool is the right choice.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it says almost nothing: no mention of what happens when the key is missing, whether reads are scoped to a room the agent must have joined, or whether access is restricted by owner. Only the owner default hints at behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short, front-loaded sentences with no filler. It is efficiently written, though the brevity here reads as under-specification rather than disciplined concision given the undocumented parameters.

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

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

An output schema exists, so return values need not be described. However, with zero annotation coverage and 0% schema description coverage on a 3-parameter tool, the description leaves required calling context (key format, room scoping, owner semantics, missing-entry behavior) entirely to inference.

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

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

Schema description coverage is 0%, and two of three parameters (key, room_id) get no explanation at all — an agent cannot tell whether key is a namespaced path, a free-form label, or whether room_id must reference a joined room. The owner note adds some meaning, but it conflicts with the schema's default of null by saying it defaults to 'this agent'.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (Read) and resource (a memory entry), which cleanly separates it from siblings like memory_set, memory_list and memory_delete. It does not explicitly name an alternative or clarify the scope of the read, but the purpose is unambiguous.

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

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

There is no when-to-use guidance: nothing says when to reach for memory_get versus memory_list (which presumably enumerates entries) or search_room. The only conditional statement concerns the owner default, which is a parameter note rather than usage routing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses one useful trait - that only 'readable' entries are returned, implying access filtering - but says nothing about pagination, ordering, result size, or whether the caller's own permissions gate the list. For a read tool with zero annotation coverage this is thin.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler, and the scoping keys appear before any other detail. It is efficient, though the extreme brevity edges toward under-specification rather than pure conciseness.

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

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

An output schema exists, so return values need not be explained here. But with no annotations and 0% schema description coverage, the description should clarify the owner-null behavior and any permission/scope rules; instead it leaves the most consequential parameter ambiguous.

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

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

Schema description coverage is 0%, and both parameters are at least named in the description, so it partially compensates. However, owner defaults to null and the description never explains what a null owner means (all owners? caller's own entries?), which is the key semantic gap for a 2-parameter tool.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a clear verb ('List') plus resource ('memory entries') with a scope qualifier ('readable') and scoping keys (owner, room_id). It distinguishes itself functionally from memory_get (single retrieval) and memory_delete, though it never names an alternative explicitly.

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

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

Usage is only implied: 'readable' hints that permission filtering applies and that this is the enumeration counterpart to memory_get. There is no statement of when to prefer this over memory_get or what happens when owner is omitted, so the agent must infer the routing.

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

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

No annotations exist, so the description carries the full behavioral burden. It usefully adds that memory is persistent, agent-owned, and per-room, but is silent on the critical set semantics: whether an existing key is overwritten, what 'visibility' controls, size limits, or permission/auth requirements for a mutation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler; the core action and scope lead the sentence. Nothing is repeated or wasted.

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

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

An output schema exists, so return values need not be explained, but for a 4-parameter mutation with zero schema descriptions and no annotations the definition is under-specified. Overwrite behavior, visibility values, and authorization are all missing.

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

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

Schema coverage is 0% across 4 parameters and the description mentions none of them by name. 'Store a value' and 'per-room' weakly imply the value and room_id params, but key semantics and the visibility parameter (default 'private', no enum, no description) are entirely opaque.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Specific verb + resource: 'Store a value in this agent's per-room persistent memory' clearly identifies a write-to-memory operation. It is distinguishable from siblings like memory_get/memory_delete, though it never names them explicitly.

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

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

No guidance on when to use this versus memory_get, memory_list, memory_delete, or the room-state tools. No prerequisites, no mention that room_id scopes the write, and no exclusions. The 'per-room' phrase implies scope but nothing about selection.

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

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

With no annotations, the description carries the full behavioral burden and falls well short. It does not say whether publishing replaces or merges an existing manifest, whether it is idempotent, whether it requires prior registration, or whether it can be undone.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler or repetition. It is efficient, though its brevity is partly the source of the missing detail rather than a sign of completeness.

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

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

An output schema exists, so return values need not be explained, but the definition still leaves major gaps for a mutation tool with zero annotations and zero parameter documentation. The overwrite/idempotency behavior and the meaning of the four optional fields are essential and absent.

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

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

Schema description coverage is 0% for all four parameters, so the description is the only place semantics could be added, and it adds none. It never explains what capabilities, supported_languages, supported_frameworks, or description should contain, nor what happens when all optional parameters are omitted.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ("Publish") and resource ("this agent's capability manifest") plus the intended outcome ("so peers can find it"). An agent can distinguish it from the read-side siblings lookup_capability and search_capabilities, but the description never names them, so differentiation is inferred rather than stated.

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

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

There is no explicit when-to-use or when-not-to-use guidance. The purpose clause implies the tool is for becoming discoverable, but the description never mentions the related siblings (lookup_capability, search_capabilities, register_tool, unregister_tool) or the conditions that select this tool over them.

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

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

No annotations are provided, so the description carries the full burden, and it does disclose the admin authorization requirement. However, it says nothing about what happens if the server is already registered, whether registration is idempotent, or any side effects of the mutation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences with the action front-loaded and no wasted words. It is arguably under-sized for a 5-parameter mutation, but there is no filler or redundancy.

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

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

An output schema exists so return values need not be explained, but with no annotations, 5 parameters at 0% schema coverage, and a non-obvious access parameter defaulting to "room", the description is too thin for the tool's complexity.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate and largely does not. Only "in the room" loosely hints at room_id; name, url, the access default of "room", and description are left entirely unexplained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (register) and resource (an MCP server in a room), which is unambiguous and naturally distinguishes it from the sibling unregister_tool. It does not explicitly name or contrast with any sibling, so it stops short of a 5.

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

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

"Room admin only" gives a real precondition, which is more than nothing, but there is no explicit when-to-use guidance, no when-not, and no pointer to alternatives such as unregister_tool or list_room_tools. Usage is only implied by the verb.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about idempotency, behavior on an invalid or stale lock_token, required permissions, whether an error is returned, or whether releasing affects any other held state. For a mutation operation with zero annotation coverage this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences, no padding, and the action is front-loaded ahead of the prerequisite. Every clause earns its place.

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

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

An output schema exists, so return values need not be explained. Still, for an unannotated mutation tool the description omits error and idempotency behavior, and two input parameters are undocumented, leaving the agent underinformed despite the useful prerequisite hint.

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

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 adds real meaning for lock_token by identifying its origin (claim_task), but room_id and file_path remain entirely undocumented, leaving two of three parameters unexplained. Partial compensation only.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: 'Release a file lock.' It also names the related tool (claim_task), which helps distinguish it from siblings even though the naming mismatch between 'release_task' and 'file lock' requires the reader to reconcile the two. Clear enough to act on without opening the schema.

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

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

The line 'Requires the lock_token from claim_task' implies this is only used after a successful claim, which is useful sequencing guidance. However, it never states when not to use it, what happens if the lock was already released, or how it relates to other lock-affecting tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only aggregate but says nothing about permissions needed, whether metrics are computed live or cached, or any rate/latency characteristics; only the metric dimensions themselves are disclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One terse, front-loaded fragment with no filler; the metric dimensions are listed compactly. It is efficient, though it reads as a label rather than a sentence, which slightly limits clarity.

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

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

An output schema exists, so return shape need not be explained, and the description usefully previews the metric categories. However, with no annotations and an undocumented room_id, an agent still lacks permission context and identifier semantics needed to call it confidently.

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

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

The single parameter room_id has 0% schema description coverage and the description adds nothing about which room identifier is expected or how it is obtained. With coverage this low, the description should compensate, and it does not.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names the resource (activity metrics) and enumerates the three measurements returned: messages per agent, type breakdown, task completion. That is enough to distinguish it from read siblings like get_room_state or list_participants, though it never explicitly says which sibling to prefer.

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

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

There is no when-to-use guidance, no statement of prerequisites, and no mention of alternatives among the many room-scoped siblings. The agent must infer that this is the analytics view of a room rather than a state or membership view.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses AND-semantics ('every token'), but says nothing about case sensitivity, empty-`has` behavior, result ordering, or whether it is a safe read. This is thin for a tool with zero annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler. It is efficient, though arguably under-specified rather than genuinely maximally concise.

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

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

An output schema exists, so return values need not be explained, and the tool is a simple one-parameter lookup. Still, with no annotations and no parameter descriptions, the definition leaves joinable gaps around usage routing and the `has` input format.

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

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

Schema description coverage is 0% for the single `has` parameter, so the description must compensate. 'Tokens' and 'match every token' add real meaning about the AND-matching logic, but the format of `has` (space-separated? comma?) and the effect of the empty default are left unexplained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource: finding participants by capability match. An agent can grasp the operation without opening the schema. However, it does not distinguish itself from the closely related sibling lookup_capability or list_participants, leaving the boundary ambiguous.

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

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

No when-to-use guidance and no named alternatives, despite siblings like lookup_capability, list_participants, and search_room that an agent might confuse with this one. The search verb implies discovery, but nothing tells the agent which of these lookups to pick.

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

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

With no annotations, the description carries the full behavioral burden. 'Search' implies a read, but it never states that explicitly, nor does it disclose pagination behavior, what the default limit=50 means, or how results are ordered. A read operation with no safety annotations needs at least this much disclosure, and it is absent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence that identifies the action, the resource, and the filters with zero filler. It is efficient, though the terseness is partly what leaves usage and parameter gaps.

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

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

An output schema exists, so return values need not be explained. However, for a five-parameter search tool with no annotations and 0% schema description coverage, the missing limit/pagination semantics and any filtering-combination behavior (AND vs OR) leave it only minimally complete.

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

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 explains q as a keyword and identifies sender and message_type as filters, which is partial value, but it says nothing about limit or the required room_id, leaving two of five parameters undocumented anywhere.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (Search) and resource (room history) with the search dimensions named. It is distinguishable from list_rooms and get_room_state by the 'history' scope, though it never explicitly contrasts itself with those siblings.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives. The agent must infer that this is the tool for querying past messages rather than current room state, and nothing tells it when a plain list_rooms or get_room_state call would be preferable.

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

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

With no annotations provided, the description carries the full behavioral burden, yet it discloses nothing about delivery semantics, what happens if the recipient agent does not exist, whether the message is queued or real-time, or any rate limits. It essentially restates the operation name.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The main sentence is short, front-loaded, and wastes nothing. The trailing 'Args: to, content' is redundant with the schema and slightly dilutes an otherwise tight description.

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

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

An output schema exists, so return values need not be explained, but with no annotations and fully undocumented parameters the definition leaves the agent without recipient format, delivery behavior, or routing guidance among many messaging siblings.

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

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, but 'Args: to, content' only repeats parameter names already in the schema. It never explains that 'to' is a recipient agent identifier or what format 'content' takes.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Send a direct message to another agent'), and the word 'direct' implicitly sets it apart from the sibling send_room_message. It does not name any sibling explicitly, so it falls short of the top mark.

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

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 versus send_room_message or any other messaging tool, and no prerequisites or exclusions are stated. The agent must infer the direct-vs-room distinction purely from the adjective.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the available message types, but says nothing about side effects, notification behavior, permissions required, or whether the message is persisted/replayable.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences with the action front-loaded and zero filler. Efficient, though the type list is compacted into a slash-separated string that reads more like a schema fragment than prose.

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

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

For a 3-parameter mutation tool with no annotations and no parameter descriptions, the definition is thin. The output schema spares it from explaining return values, but it should still cover permissions, membership requirements, and differentiation from sibling messaging tools.

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

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

Schema description coverage is 0% and there are no enums, so the description must compensate. It supplies the valid message_type values (chat/claim/status/request/alert/sync), which is genuinely useful, but leaves 'content' and 'room_id' entirely unexplained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Send a message to a room'), so the core action is unambiguous. However, it never distinguishes itself from the sibling 'send_message', leaving the agent to guess which messaging tool to pick.

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

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

There is no when-to-use guidance, no prerequisites (e.g. must you be a room member?), and no routing away from 'send_message'. Listing the message types hints at context but does not tell the agent when to choose this tool over alternatives.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that only commits the base lacks are sent and that full=True handles a missing base commit, but it omits side effects (does it push to a remote, mutate room state?), whether it's reversible, and any permission requirements for the room.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded in the first sentence, followed by the incremental-vs-full nuance and the usage trigger, with no filler. Every sentence earns its place for a tool of this complexity.

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

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

The output schema covers return values and the description handles purpose and the key flags, but with five undocumented parameters and no annotations, an agent still lacks room_id, branch, and repo_path semantics to invoke it confidently. It is adequate but incomplete.

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

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 adds real meaning for two tricky params, clarifying base ('commits base lacks', default main) and full (recover from a missing base commit), but leaves branch, room_id, and repo_path ('default .') entirely undocumented in both the schema and the description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The first sentence states a specific verb (Share) and resource (a git branch) plus the scope (teammates on other machines, through the room), which is enough for an agent to grasp the operation immediately. No sibling tool overlaps with branch sharing, so the description doesn't need to differentiate, but it also doesn't explicitly map itself against the room-oriented siblings.

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

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

It gives a concrete when-to-use trigger: 'Use it before asking someone on another machine to review a commit they can't git show.' It also names a conditional path ('set full=True when a teammate reports a missing base commit'). It lacks explicit when-not-to-use guidance or named alternatives, so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Submit' implies a write/mutation to a room, but the description discloses nothing about side effects, required permissions, reversibility, or rate limits. Only a doc pointer is offered.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the core purpose, then lists verbs and a doc pointer in three short lines. No wasted prose, though the doc reference pushes essential detail outside the definition.

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

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

The tool has a nested payload object and an output schema (so return values need not be described), but with zero annotation coverage and 0% schema description coverage, the critical per-verb payload contract is deferred to an external file. An agent cannot reliably call this correctly from the definition alone.

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

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

Schema description coverage is 0% across 4 parameters. The description usefully lists the valid verb values, but leaves the payload structure, room_id format, and ref_message_id semantics entirely to an external document the agent may not have. It only partially compensates for the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource: 'Submit a Quorus Social Protocol v1 verb to a room.' The enumeration of valid verbs (claim, release, disagree, defer, queue, vote, interrupt) further clarifies the operation. It does not, however, differentiate from overlapping siblings like send_message, send_room_message, claim_task, or release_task.

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

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

There is no explicit when-to-use or when-not-to-use guidance. The definition never explains how it relates to siblings that clearly overlap (send_room_message, claim_task, release_task), leaving the agent to infer whether it should use this or those alternatives.

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

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 usefully discloses the admin-only permission requirement and implies a destructive removal, but it does not explain reversibility, side effects, or failure behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences with zero waste. The purpose is front-loaded, and the permission constraint follows immediately.

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

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

An output schema exists, so return values need not be described. The core purpose and permission requirement are present, but for an unannotated destructive tool the description lacks parameter semantics and consequence details.

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

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 but does not. It gives no meaning or format for room_id or name beyond implicit context, leaving both parameters effectively undocumented.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (Remove) and resource (MCP server registration). It clearly distinguishes itself from the sibling register_tool by naming the inverse operation.

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

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

Provides a clear prerequisite: 'Room admin only.' However, it does not explicitly name alternatives or state when not to use it, though the inverse sibling is obvious.

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