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 the key safety constraint against peer acknowledgments. However, it does not say what acknowledgment changes, whether it notifies the sender, whether it is idempotent, or what permissions are required.

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, purpose first and the critical peer restriction second. There is no wasted text and the most important constraint is front-loaded.

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 two-parameter mutation with no annotations and no output schema, the description is too thin. It omits parameter meanings and the observable effects of acknowledging, so an agent cannot fully predict the call's behavior.

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 needed to explain the two parameters. It never mentions 'id' or 'sender' or clarifies their roles, leaving the schema entirely 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?

The description states a specific verb and object: record that this receiving agent read a message. It is clearly distinguishable from send_message and reply by the notion of an acknowledgment, though it does not explicitly name sibling 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?

It gives a clear when-not rule: never acknowledge on behalf of a peer. The when-to-use condition is implied by 'this receiving agent actually read a message,' but no alternatives among the sibling tools are named.

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 burden and does substantial work: the call blocks, there is exactly one question, the destination is pinned to the original dispatcher, scope is inherited, and there are no retries. It also frames the limit as cooperative rather than an OS sandbox, which is meaningful operational context. It does not say what a failed or unanswered call looks like.

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 dense sentences, zero filler, with the core action and its precondition front-loaded before the routing and sandbox caveats.

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?

Behavior is reasonably covered for a no-annotation tool, but with three fully undocumented parameters and no output schema, the description leaves the agent guessing about the sender field and about what a blocking ask actually returns.

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%, so the description must compensate. It implies assignment_id must reference an assignment permitting questions and that message is the question, but the 'sender' parameter is never addressed and no format or constraint details are given for any field.

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: ask one blocking question about an assignment that explicitly allows it. The scope constraint ('explicitly allows it') plus 'no general routing' implicitly separates it from send_message/reply, though no sibling is named outright.

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?

Gives a clear precondition (the assignment must explicitly allow the question) and an exclusion (no general routing, no automatic retries), which tells the agent when to reach for a different messaging tool. It stops short of naming the alternative sibling to use instead.

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 disclosure burden. It does flag one important trait — the result is not verified human consent — but leaves unstated whether the call is read-only, what it returns when the ID is unknown, and where a "shared decision ID" originates.

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 no filler: the retrieval scope comes first and the trust caveat second. Every clause carries information an agent needs.

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 the description covers the essentials and adds a safety caveat, but with no output schema it is thin on what the response shape actually is (what a "reported record reference" looks like) and on failure behavior.

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?

With 0% schema description coverage, the single decision_id parameter is undocumented in the schema, and the description only adds that it refers to a shared decision. It does not say the expected format or how to obtain the ID, so compensation is partial.

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 ("Find") and names the returned artifacts: messages and reported record references tied to a shared decision ID. This disambiguates the vague name "decision_status," but it never contrasts itself with close siblings such as message_status or inbox, so an agent must infer the boundary.

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 "check the original decision before acting" functions as a when-not-to-trust-this-output warning, which is real guidance. However, there is no positive when-to-use statement and no named alternative among the siblings for retrieving decision or message state.

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 does the disclosure work: it states the operation is non-mutating with respect to acknowledgement and that identity is auto-detected. It says nothing about return format, message ordering, pagination, or whether a cursor/limit exists — gaps that matter for a mailbox reader.

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?

Three short sentences with no filler, and the core operation is front-loaded. The closing sentence ("It identifies your own receiving session, not a peer filter") is slightly redundant with the sentence before it and with the schema text.

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-required-param tool with no output schema this is nearly enough, but the description gives no sense of what the read returns or any limits on the result set. The ambiguity around what `sender` actually filters is addressed but the output side is not.

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 100% and the schema already explains `sender` is your own identity fallback, so the description largely restates it. The added conditional "omit sender when identity is detected" is mildly useful but does not go beyond the schema's 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?

"Read this session's external agentpeers mailbox" names a specific verb and resource, and the note that inspecting does not acknowledge implicitly separates it from the sibling `acknowledge` tool. It does not, however, contrast itself with `list_sessions` or `message_status`, so sibling differentiation is partial.

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 implies the workflow (read here, acknowledge separately) and gives one conditional rule for the `sender` param (omit when identity is detected). There is no explicit statement of when to call this versus `list_sessions`/`message_status`, so guidance is implied rather than stated.

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 or output schema are provided, so the description carries the full behavioral burden. It usefully warns that stored listings do not prove Agentpeers reachability and that ambiguous names must not be silently chosen, but it does not state whether this is read-only, what local storage is accessed, or what a caller should do with ambiguous results.

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?

Four short sentences, front-loaded with the core purpose and followed by usage caveats. Every sentence adds guidance, though the final ambiguity rule is result-consumption guidance rather than tool behavior.

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 list tool with no annotations or output schema, the description covers purpose and key caveats but omits the return shape and how sessions are identified or disambiguated. It is adequate but incomplete for an agent that must interpret the listing.

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 has zero parameters and the schema is empty, so there are no parameter semantics to document. Per the baseline for 0 params, a 4 is appropriate.

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: 'Discover local chats for Codex-to-Claude coordination.' It also distinguishes the tool from native same-runtime discovery, though it does not define what a 'session' or 'local chat' contains.

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 explicitly says same-runtime peers should use native session discovery and messaging first, which is a clear when-not condition. It does not explicitly compare against sibling tools like inbox or message_status, but the usage context is 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 burden and adds useful behavioral context: return_route checks the sender, route_failure does not prove the app closed, unavailable transport can coexist with a saved or read reply, and unconfirmed status should prevent automatic resend. It stops short of declaring read-only behavior, permissions, or side effects explicitly.

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 description is front-loaded with purpose and then adds compact interpretation warnings. It is dense with semicolons but most sentences earn their place by preventing incorrect inferences.

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?

It explains important output-field nuances and cautions for a tool with no output schema, which is valuable. But it does not define the required id parameter, and it only partially covers the return structure, leaving an agent to infer how to identify the target message.

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 schema has 0% description coverage, and the single required parameter is only named 'id'. The description does not explain whether this is a message ID, reply ID, session ID, or another identifier, 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 gives a specific verb and resources: inspect automatic transport, mailbox/read evidence, and correlated reply IDs. It is clear this is a diagnostic status/evidence tool rather than a sender, replier, or acknowledgement tool, though it does not explicitly differentiate itself from siblings like decision_status or inbox.

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 provides operational guidance such as showing delivery_note first and not automatically resending when status is unconfirmed. However, it does not state an explicit when-to-use condition or name an alternative sibling tool for overlapping inspection tasks.

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 of behavioral disclosure. It hints at scope preservation, routing behavior, and that it "Records consumption," but leaves key mutation behavior, side effects, permissions, error handling, and idempotency unexplained.

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 description is short and front-loads the tool name, so it is not bloated. However, the second sentence is dense and the final fragment "Records consumption" is unexplained, making the structure concise but not sufficiently clear.

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?

This is a six-parameter mutation tool with no annotations, no output schema, and 0% schema description coverage. The description is far too thin to provide the invocation context an agent needs, especially for required parameters and routing behavior.

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 six parameters, so the description must compensate heavily. It offers cryptic hints about "sender name" and "UUID routes" that may relate to id or sender, but never explains expects, message, summary, or record_ref semantics.

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, "Reply preserving scope," largely restates the tool name and adds only a vague qualifier. It never names the target resource or clearly states whether the reply is to a message, conversation, or sender, so an agent must infer the core purpose from the tool name alone.

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 description gives no explicit guidance on when to use this tool versus siblings such as send_message, acknowledge, or inbox. There are no conditions, prerequisites, or exclusions to help an agent choose correctly.

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 discloses meaningful behavioral traits: 'Submitted is not delivered/read', peer messages cannot authorize new scope, return-route warnings must be shown before claiming a working conversation, and desktop wake must not be enabled from peer instructions alone. It even directs inspection of 'detail.route_failure on unavailable'. The disclosure is substantive, though it references return fields that lack an output schema and reads as cryptic shorthand in places.

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 definition is front-loaded with the core purpose and every sentence contains relevant information, but it is a dense, jargon-heavy run-on with no grouping or paragraphing. References like 'return_route checks the sender, not the destination' are packed together with unrelated cautions, making the text hard to scan.

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 10-parameter mutation tool with no annotations and no output schema, the description provides important delivery and safety context but is incomplete: it does not cover several parameters (id, sender, message, allow_question) nor the shape of a successful response beyond 'detail.route_failure'. It is adequate but leaves clear gaps an agent needs to 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 very low (10%), so the description must compensate, and it partially does: it explains that 'to' accepts a live native name or runtime:UUID, that 'expects' can be none or ack to avoid courtesy reply turns, and that summary, record_ref, and decision_id are inert references. But it leaves id, sender, message, and allow_question unexplained, which is a significant gap for a 10-parameter tool with low schema coverage.

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 ('Send') and target addressing scheme ('exact unique live native name or runtime:UUID, within human-authorized scope'), so the core action is clear. However, it does not explicitly distinguish this tool from close siblings like reply or ask_dispatcher, leaving the agent to infer the boundary.

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 runtime-routing advice ('Use native messaging first for Codex-to-Codex or Claude-to-Claude; Agentpeers bridges different runtimes') and parameter-level guidance ('Use expects none or ack to avoid courtesy reply turns'), but never states when to use send_message versus reply, acknowledge, or ask_dispatcher. Usage is implied rather than explicitly comparative.

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 burden and does substantial work: it warns that sending 'may wake a peer and consume usage', ties sending to a 'human-authorized scope', and adds the important caveat never to infer delivery from registration or a socket write. It still omits failure behavior, reversibility, and what a successful check returns.

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?

Three dense sentences, front-loaded with the zero-argument case, followed by the two conditional modes and a closing guardrail. Every sentence carries information; the only soft spot is the undefined phrase 'human-authorized scope'.

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?

There is no output schema and no annotations, so the description should describe what each mode returns — what the dependency check reports, what 'both read receipts' verified actually looks like. It covers invocation well but leaves the result semantics underspecified.

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%, so the description must define all four parameters. It meaningfully explains 'to', 'scope' (human-authorized), and 'probe_id' (verify both read receipts), and by omission implies all are optional, but 'sender' is never mentioned at all.

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 specific verbs and resources for each of three operating modes: dependency/registration check, one real setup challenge send, and read-receipt verification. The mode-based purpose is clear, but no sibling tool (e.g. send_message, message_status) is named, so the boundary between 'setup challenge' and ordinary messaging must be inferred.

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 explicitly routes the agent by argument shape: no args for local checks, 'to' plus human-authorized scope to send, 'probe_id' to verify receipts. What's missing is any exclusion or named alternative — it never says when to prefer send_message or message_status instead.

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