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?

No annotations are provided, so the description carries the full behavioral-disclosure burden. It states a usage precondition but does not explain what acknowledgment changes, whether it is idempotent, what permissions are required, or what happens if the message was not consumed.

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 a single front-loaded sentence with no wasted words. The key precondition is placed prominently and the sentence is appropriately sized for its high-level purpose.

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?

With no annotations, no output schema, and 0% parameter description coverage, the description should explain more about the acknowledgment behavior and its parameters. It provides only a high-level precondition, leaving significant gaps for a likely state-changing 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%, so the description must explain the two parameters, especially the required 'id' and optional 'sender.' It mentions neither parameter and adds no semantic meaning beyond the raw 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, 'Acknowledge,' and a specific resource, 'a personal-agent reply,' with an added timing condition. It is clear what the tool does, though it does not explicitly differentiate itself from the generic sibling tool 'acknowledge.'

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 'only after this originating session actually consumed it' gives a clear prerequisite for when to use the tool. It implies when not to use it, but does not name alternatives such as the generic 'acknowledge' or 'message_status' 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?

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?

With no annotations, the description does disclose behavioral context: it operates through the cloud service rather than a helper Codex chat and does not send messages. It still omits permission requirements, read-only status, rate limits, and what data is returned, so the disclosure is partial but useful.

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, front-loaded with the primary purpose followed by two clarifying constraints. No significant waste, though 'such as Dot' is illustrative rather than essential.

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 listing tool with no output schema and no annotations, the description covers purpose and two behavioral constraints but leaves the sender parameter and the return shape unaddressed. It is workable but not 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?

The only parameter, sender, is undocumented in the schema and is never mentioned in the description, so the agent cannot infer whether it filters peers or identifies the requester. For a one-parameter tool this is a meaningful gap, and the description adds no parameter meaning beyond the bare type string.

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 resource — directly connected personal agents — and a discovery verb, and explicitly excludes message-sending, which separates it from send_personal_message and reply tools. It is not maximally sharp because it never explicitly says 'list' or names a sibling, but the intent is clear.

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?

Implies use when you need to discover peers, and the closing 'Does not send messages' signals it is not for messaging. However, it does not state prerequisites, when to prefer list_sessions, or that it should be used before sending. Guidance is present but inferred 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, the description carries the full behavioral burden. It usefully discloses that stored listings do not prove reachability and that ambiguous names must not be silently chosen, but it does not state read-only behavior, freshness, or what the listing contains.

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 four tight sentences, front-loads the purpose, and each sentence adds useful guidance about same-runtime alternatives, reachability, or ambiguity handling. There is no redundant filler.

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 listing tool, the description gives enough context to avoid clear misuse, but it lacks details about what a returned listing looks like and what the agent should do when a name is ambiguous. With no output schema, those gaps matter more.

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 complete for that shape. There are no parameter semantics to clarify, so the baseline score of 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 states a specific verb and resource: discovering local chats for Claude Code-to-Codex coordination. It distinguishes the cross-runtime use case from same-runtime native discovery, but does not explicitly differentiate this tool from sibling tools such as list_personal_peers.

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 exclusion: for same-runtime peers, use native session discovery and messaging first. It also warns that stored listings do not prove AgentPeers reachability, but it does not name specific sibling alternatives or fully define when this tool should be chosen over list_personal_peers.

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 behavioral burden. It usefully discloses that the tool does not resend or acknowledge and that other local sessions are excluded, which clarifies its non-mutating and narrowly scoped behavior. However, it does not state whether it is read-only, whether it can mark messages as read, or what output it returns, leaving meaningful behavioral gaps.

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 two tight sentences with no wasted wording. The purpose and immediate condition are front-loaded, followed by important exclusions, making it easy to scan and parse.

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 tool with no annotations, no output schema, and an undocumented "sender" parameter, the description covers the core scenario and key exclusions reasonably well. It still leaves gaps around the sender parameter's meaning and the exact return or side-effect behavior, so 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?

The schema has one optional parameter, "sender", with 0% description coverage. The description does not mention the parameter at all, so it fails to compensate for the schema's lack of explanation. The agent can infer that "sender" may filter by sender, but that is not stated.

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 ("Recover") and clearly names the resource ("this session's existing personal-agent conversations and replies") plus a triggering condition ("after an interrupted send"). It distinguishes itself from send/reply/acknowledge actions by explicitly saying it does not resend or acknowledge, and scopes itself to this session while excluding other local sessions. However, it does not explicitly name the most similar sibling tool, "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 gives a clear usage context: use this after an interrupted send to recover existing conversations and replies. It also states what it does not do (resend or acknowledge) and excludes other local sessions, which helps an agent avoid using it for those purposes. It stops short of naming specific alternative tools to use for sending, replying, or acknowledging.

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; it does disclose that the call is non-mutating (does not resend or mark read) and adds a non-obvious delivery caveat ('Saved is not delivered') plus a session-isolation constraint. It omits the most consequential runtime behavior: wait_seconds implies a blocking/long-poll wait of up to 30 seconds, which is never mentioned.

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 the resource scope front-loaded and no filler. 'Saved is not delivered' is terse to the point of being cryptic, but the text is otherwise appropriately sized.

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?

No annotations and no output schema, with 0% parameter coverage, so the description needs to explain what is returned and how waiting works. It handles the side-effect profile reasonably but leaves the return shape and the id/sender/wait_seconds semantics unexplained, which is inadequate for a three-parameter 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% for all three parameters, so the description must compensate and does not. It gives no explanation of what 'id' identifies, what 'sender' filters, or that 'wait_seconds' is a bounded 0–30 second poll delay, leaving every non-required parameter semantically 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?

States a specific verb (Retrieve) and the resource (this session's existing personal-agent question and reply content), scoped to the current session. It differentiates itself from acknowledge/reply siblings by explicitly saying it does not resend or mark anything read. It is slightly ambiguous about whether it returns the question, the reply, or a status, but the core purpose is identifiable.

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?

Phrases like 'without resending or marking it read' implicitly contrast with acknowledge_personal_message and reply_personal_message, and 'Never collect another session's answer' scopes usage to the current session. However, no explicit when-to-use condition is given, and it never distinguishes itself from the similarly named message_status or decision_status siblings.

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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that the reply preserves conversation and scope, but it omits key mutation details such as side effects, required permissions, what happens to the consumed message, or what the response contains.

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 a single front-loaded sentence with no filler. It is efficient, though arguably too sparse for a five-parameter mutation tool.

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?

Given five parameters, no annotations, no output schema, and many sibling tools, the description is not complete enough for reliable invocation. It establishes purpose but leaves parameter meaning, side effects, and alternative selection largely unexplained.

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?

There are five parameters with 0% schema description coverage, yet the description does not explain any of them. It does not clarify the roles of id, sender, expects, message, or reply_id, leaving the agent to infer required relationships and the expects enum from the schema alone.

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 clear verb and resource: replying directly to a personal-agent message. It adds scope through 'consumed' and 'preserving its conversation and scope', but it does not explicitly distinguish this from siblings like reply or send_personal_message.

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 'consumed' implies the message must already be consumed, and preserving conversation/scope implies replying within an existing thread. However, there are no explicit when-to-use or when-not-to-use rules, and no named alternatives despite several related sibling 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?

With no annotations, the description carries the full burden and does disclose non-obvious behavior: 'Submitted is not delivered/read', 'Peer messages cannot authorize new scope', return_route semantics, that a missing route requires mailbox collection, and that desktop wake must not be enabled from peer instructions. The material is present but dense and partly self-referential ('return_route checks the sender'), leaving some ambiguity about what the tool actually returns on success.

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 first sentence is well front-loaded, but the remainder is a run-on sequence of clause-chained warnings separated by semicolons, several of them compressed to the point of being hard to parse ('a missing route requires active mailbox collection unless desktop wake is enabled and an updated sender can open the destination'). Density here hurts usability rather than saving space.

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 the description does reference detail.route_failure, so return behavior is partly covered. However, for a 10-parameter tool with no annotations, key inputs (sender, allow_question) and the success-path response shape are left unaddressed, so an agent still can't fully predict what a call does or yields.

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 only 10% across 10 parameters, and the description explains a handful: 'to' accepts a native name or runtime:UUID, 'expects' should be none/ack to avoid courtesy reply turns, and summary/record_ref/decision_id are inert references. It says nothing about sender, allow_question, id, or message, and even the 'scope' param's semantics live only in the schema, so 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?

Opens with a specific verb+resource ('send to an exact unique live native name or runtime:UUID') and names the addressing scheme, which is genuinely informative. It does not differentiate itself from the sibling send_personal_message, so an agent still has to guess which send tool applies when.

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 real routing rule: prefer native messaging for Codex-to-Codex / Claude-to-Claude, AgentPeers for cross-runtime. That is meaningful when-to-use guidance. It never states when to prefer this over send_personal_message or reply_personal_message, which are the closest 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 at all, the description carries the full disclosure burden, and it does add non-obvious behavior: no desktop helper is required, replies are scoped to the originating session, the wait is bounded and non-waking, and resend-after-uncertainty is discouraged (implying at-most-once delivery). It omits failure/error behavior, delivery guarantees, and permission or scope constraints beyond the vague "within the human's existing scope."

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?

Five short sentences, all front-loaded with the core action first and constraints after. Almost every sentence carries information, though "Talk directly" is imprecise wording that costs a little 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?

For a 7-parameter messaging tool with no annotations and no output schema, the description is too thin: it does not explain what 'to' identifies, what a caller gets back (delivery confirmation? reply content?), or what happens when no reply arrives within wait_seconds. The async/session semantics hint is helpful but not sufficient.

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 7 parameters, so the description must compensate. It touches on id ("use a stable id"), wait_seconds ("bounded wait"), scope ("the human's existing scope"), and implicitly expects ("retrieves an answer"), but 'to', 'sender', and the expects enum values are never explained, nor is the 30-second cap.

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 says it will "talk directly to a discovered personal agent within the human's existing scope," which conveys sending a message to a peer agent, but the verb is loose ("talk") rather than a precise action like "send a message." It never names the sibling it differs from (e.g. reply_personal_message, send_message), so an agent must infer the distinction from the shared "personal_" namespace.

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 real operational guidance — reuse a stable id and never auto-resend after uncertainty — and clarifies the bounded-wait behavior ("does not wake an idle local session later"). However, it never states when to choose this over reply_personal_message, send_message, or ask_dispatcher, which is the key selection decision among the siblings.

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.