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

With no annotations present, the description carries the full burden and does so well: it discloses the authorization grant required, the ownership restriction that causes refusal, the empty-value clearing semantics, and the side effect that the owner sees every sent item marked with the agent name on every device. This is far beyond what structured fields provide.

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 and scope are front-loaded in the first clause, and every sentence carries information. The middle sentences are dense compound statements, but no sentence is filler; slight tightening would help readability.

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 mutation tool with no annotations and no output schema, the description covers authorization, ownership refusal, partial-update semantics, and visibility side effects. Nothing an agent needs to call it correctly is missing, and return-value documentation is unnecessary here.

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 already 100%, so the baseline is 3, but the description adds real meaning the schema lacks: PATCH-style semantics ('Pass only the fields to change') and the behavior of empty values ('an empty title clears it'), which qualifies the schema's per-field descriptions rather than repeating them.

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 ('Change an item this agent sent, keeping its id') and enumerates exactly which fields are editable (title, text, language, secret cover). It explicitly carves out the sibling boundary by noting file bytes change with zas_replace_file, so an agent can distinguish it from the other 12 tools without opening any 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?

Gives explicit preconditions ('Needs a grant that includes reading and sending'), an exclusion ('Refuses items sent by anyone else'), and an alternative ('A file's bytes change with zas_replace_file'). It also specifies partial-update usage ('Pass only the fields to change'), leaving nothing to inference.

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 real work: it discloses that notes come back as text while files are written to disk, that it never overwrites an existing file, that the returned path can differ from dest, and that the default destination is a temp directory. It omits auth/permission needs, but the destructive-safety profile is well covered.

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 core action is front-loaded and the file-writing caveats follow logically. The closing sentence about the owner seeing every item this agent sends is tangential for a fetch tool and is the one sentence that does not clearly earn 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?

With no output schema, the description correctly explains the return value (the written path, which may differ from dest) and the note-vs-file duality. It is essentially complete for correct invocation, missing only edge behavior such as what happens when the id does not exist.

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 100%, so the schema already documents channel, id, and dest semantics. The description's added detail ('writes a new file under dest... never overwrites') is really return-value behavior rather than new parameter meaning, so the baseline 3 holds.

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 opens with a specific verb+resource: 'Fetch one item from a Zas channel.' The word 'one' implicitly contrasts with the sibling zas_list_items, so an agent can distinguish retrieval-by-id from enumeration without opening either 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?

Usage is implied rather than stated: the tool is clearly for pulling a single item given a channel and id. There is no explicit when-to-use/when-not guidance and no pointer to alternatives such as zas_list_items for discovering ids, so the agent must infer 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 it does disclose meaningful traits: results are ordered newest-first, each entry carries the phase reached and how it ended, returned job_ids are surfaced, and completed jobs retain their results here. It also notes the visibility model (owner sees items with the agent mark/name on every device). It stops short of stating read-only safety, pagination, or result limits.

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 sentences, front-loaded with the core action and ordering. The second sentence about owner visibility is the least essential and slightly tangential, but it is short and not padded.

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, read-only list tool with no output schema and no annotations, the description covers the important ground: what is listed, ordering, per-item fields, job_id retention, and result persistence. Missing only operational details such as pagination or result-count limits.

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 is 4; there is no schema-level parameter meaning to add or compensate for.

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 ('List') and resource ('the sends and Directo transfers this server started'), plus the ordering ('newest first') and the fields surfaced (phase, outcome, job_id). It is clearly distinguishable from write-oriented siblings like zas_send_direct, though it never names a sibling to sharpen the boundary against zas_list_items or zas_status.

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: 'a finished job keeps its result here' suggests this is where you check the outcome of a prior send, but there is no explicit when-to-use, when-not-to-use, or named alternative (e.g. zas_status) to route the agent. The final sentence adds context but not selection guidance.

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 a real behavioral requirement (a reading grant is needed) and a visibility trait (the owner sees items with the agent mark on every device), which is useful. However it omits return format, pagination/cursor behavior, and ordering caveats beyond 'most recent'.

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 sentences, purpose front-loaded, and the permission constraint follows closely. The final sentence about device-wide agent marking is somewhat tangential but does carry transparency value, so it earns its place marginally.

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 two-parameter read tool with no output schema and no annotations, the description covers the essential purpose and the key permission prerequisite. It is nearly complete; only return/pagination detail is 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 description coverage is 100%: 'limit' documents its 1-50 range and default of 20, and 'channel' documents name-or-id. The description adds no parameter meaning beyond the schema, so baseline 3 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 specific verb ('List') and resource ('items in one of the owner's Zas channels'), with the 'most recent' scoping. It is distinguishable from the singular zas_get_item and the send_* siblings, though it doesn't explicitly name 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?

It gives a prerequisite ('Needs a grant that includes reading') but offers no explicit when-to-use-vs-alternatives guidance, e.g. versus zas_get_item or the receive_direct tools. Usage 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 carries the full burden and does well: it discloses that this is a stateful, multi-call flow, that re-approval replaces the prior agent, and the side effect that the owner sees every item this agent sends (with the >_ mark and agent name) on all devices. It omits auth/permission requirements and failure behavior, keeping it from a 5.

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 tight sentences with the core purpose front-loaded, then the protocol, the code branch, and the re-pairing case. The closing sentence about cross-device visibility is slightly tangential but still earns its place as behavioral context; nothing is redundant.

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 1-optional-param pairing tool with no output schema and no annotations, the description covers the interaction sequence, the code parameter's role, re-pairing semantics, and the resulting visibility. It is close to complete, missing only error/permission handling an agent might want.

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%, so the baseline is 3, but the description adds real value beyond the schema text: it explains the conditional trigger for `code` ('If the page shows a code, call again with `code`'), tying the optional parameter to a runtime condition rather than just its content.

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 opens with a specific verb+resource: 'Pair this agent with a Zas account.' This is unambiguous and clearly distinct from the sibling send/receive/status tools, none of which handle account pairing. An agent can tell what this tool is for 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?

It lays out the multi-call protocol clearly: first call returns a URL for the owner, a later call reports approval, and a code-bearing page means calling again with `code`. It also notes the already-paired case (approval replaces the old agent). It stops short of naming explicit alternatives or when-not-to-call, but the when/how context is strong.

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 so well: it discloses the one-minute call timeout, the ten-minute offer wait, the returned job id to poll via zas_jobs, the returned path, the no-overwrite guarantee, and that nothing is stored. It does not describe failure/timeout outcomes when no offer arrives, which is the main remaining 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?

Front-loaded with the action, then trigger, then constraints, then return/behavior — good ordering. The closing sentence about the owner seeing items "this agent sends" with the >_ mark concerns sends, not receives, so it is slightly off-topic for this 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?

No output schema exists, and the description compensates by stating the return value (path written) and the async job-id pattern. Combined with timing and permission preconditions, an agent has nearly everything needed, missing only explicit error/no-offer handling and sibling disambiguation.

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 100% for both parameters (dest, channel), and the description adds only indirect hints ("writes the file to disk", "returns the path written") without new syntax or default semantics. Baseline 3 applies since the schema does the heavy lifting.

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 concrete verb+resource (receive a file the owner sends through Directo) and the effect (written to disk on this machine). It is distinguishable from zas_send_direct and zas_send_file, but never mentions zas_receive_direct_fallback, which is the closest alternative an agent would need to disambiguate from.

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?

"Call it when the owner says they are sending you something" gives a clear trigger, and preconditions are spelled out: Directo-mode channel only, grant must include reading. No exclusion or explicit fallback routing is provided, so the agent cannot tell when to prefer zas_receive_direct_fallback 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 are provided, so the description carries the burden and it does well: it discloses that decryption happens locally, that the file is written to the same destination, and the reliable-delivery precondition. It omits what happens if the precondition is unmet (error vs. silent no-op) and whether the download is idempotent.

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 functional content is front-loaded and clear, but the final sentence about the owner seeing items with the agent mark and name is tangential marketing copy that dilutes the definition and doesn't help the agent invoke the 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?

For a one-parameter tool with no output schema, the description covers trigger, precondition, and side effects (local decryption, write destination) adequately. Missing only failure semantics when the precondition isn't met.

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 defines the single 'job' parameter with a clear description. The description adds the provenance of the id ('the failed job's id'), which is mildly useful routing context but essentially restates 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 (download) and resource (the encrypted stored copy) and ties it to a precise triggering condition (after a zas_receive_direct job failed in flight). The link to the named sibling zas_receive_direct makes the relationship unmistakable.

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?

Explicitly conditions use on two things: a prior zas_receive_direct failure and the sender having chosen reliable delivery for that transfer. It also names the required argument (the failed job's id), so the agent knows exactly when this applies and what to supply.

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 so richly: refusals (foreign items, notes, publicly shared items), the dual return shape (item id, or job id for uploads over a minute), and the owner-visible agent mark across devices. These are exactly the operational facts an agent needs before invoking a mutation 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?

Four sentences, each front-loaded with a distinct fact: what it does, what it refuses, what it returns, and the visibility/safety caveat. No filler and nothing repeated.

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 mutation tool with no annotations and no output schema, the description supplies the missing pieces an agent needs: refusal conditions, return value semantics including the async job-id case, and a safety warning. Nothing material is left unstated.

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 100%, so id, path, title, and channel are already documented in the schema. The description reinforces that the item id must match an item the agent itself sent and that channel is optional only with a single channel, but adds no syntax or format detail beyond the schema. Baseline 3 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 precise verb+resource: replacing the bytes of a file the agent previously sent, from a local path. It also names the preserved attributes (item id, channel position, pin), which distinguishes it from zas_edit_item (metadata edits) and zas_send_file (new item). An agent can differentiate it from siblings without opening any 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?

Clearly delineates when this tool refuses to act: items sent by anyone else, notes, and items with a public share, plus a pre-send caution about secrets/keys/credentials. It does not, however, explicitly name the alternative tools (e.g. zas_edit_item for metadata, zas_send_file for new uploads), leaving the agent to infer the boundary from the refusal 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?

With no annotations, the description carries the full burden and does: 'Nothing is stored', a one-minute synchronous wait followed by a job id, a ten-minute owner receive window, owner visibility with the >_ agent mark and agent name on every device, and a cautions note about secrets/keys/credentials. These are exactly the behavioral traits an agent needs before firing the call.

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-loaded with the mechanism and the key timing constraint, and most sentences earn their place. The trailing sentence about the >_ agent mark and agent name on every device is awareness-heavy but still operationally relevant; overall slightly long but not padded.

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 output schema, but the description explains both possible returns (transfer result or job id) and names zas_jobs for polling, covering the return contract. The remaining gap is failure/fallback behavior: the existence of zas_send_direct_fallback is never acknowledged, so an agent hitting a failed transfer has no stated next step.

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%, so both parameters (path, channel) are already documented in the schema. The description adds only that it sends 'any file this process can read', which marginally constrains path but adds no syntax or format detail. Baseline 3 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 specific verb (send) and resource (a file) and immediately qualifies the mechanism: a live device-to-device transfer into a channel in Directo mode. That mechanism distinguishes it from siblings like zas_send_file and zas_send_direct_fallback without needing their schemas.

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 clear preconditions and context: the target channel must be in Directo mode and the owner must press Receive on another device within ten minutes. It routes to zas_jobs for status, but never states when to prefer zas_send_file or zas_send_direct_fallback instead, so the alternative-selection guidance is incomplete.

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 present, the description carries the full burden and delivers: local encryption, storage of only the encrypted copy in Cloudflare R2, a 24-hour retention window, no consumption of owner space, download by the claiming device, and the behavioral shift that bytes now pass through storage. It also discloses owner visibility via the agent mark.

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 and trigger are front-loaded and most sentences carry distinct information. A few clauses are conversational ('This stops being Directo', 'it is their choice') and could be tightened without losing meaning.

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?

Covers trigger, consent gate, encryption/storage mechanics, retention, and visibility for a tool with no annotations and no output schema. It omits what the call returns and what happens to the original failed job, which would round it out.

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 single job parameter is fully documented in the schema. The description's 'Pass the failed job's id' restates rather than extends that, so the baseline 3 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 specific verb (deliver), resource (the same file), and a precise trigger condition (after a zas_send_direct job failed in flight), which distinguishes it cleanly from zas_send_direct and zas_receive_direct_fallback. An agent can identify the scenario without opening any 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?

Gives an explicit trigger ('after a zas_send_direct job failed in flight') and a hard prerequisite ('Ask the owner before you use it; it is their choice'). It also names the originating tool whose failure selects this path, so the when-to-use decision is unambiguous.

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 so: it discloses the async return shape (item id, or a job id when the upload exceeds a minute), a hard refusal condition for Directo channels, a capability boundary ('any file this process can read'), and an audit/visibility behavior ('owner sees every item ... with the >_ agent mark and this agent's name, on every device').

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 compact sentences, each carrying distinct information (action, return shape, refusal/alternative, safety warning, visibility), with the core action front-loaded and no 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?

There is no output schema and no annotations, so the description must cover both; it explains the return values (item id vs job id), the refusal path, and the safety/visibility implications. Nothing an agent needs to invoke this correctly appears to be 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 description coverage is 100%, so the baseline is 3; the description adds meaning beyond it by tying the `channel` parameter to the Directo-mode refusal and by characterizing `path` as limited to files 'this process can read'. It does not restate the `expires_in_days` clamping semantics, but the schema already covers that well.

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 with scope: 'Send a file from this machine into one of the owner's Zas channels.' It also explicitly differentiates from a sibling by noting that a channel in Directo mode refuses this tool and that zas_send_direct should be used there.

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 an explicit exclusion rule ('A channel in Directo mode refuses this tool: use zas_send_direct there') naming the alternative tool, plus a safety precondition ('confirm with the owner before sending secrets, keys or credentials'). Both when-not-to-use and the alternative are stated outright.

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 a useful trait — every item is visibly marked with the >_ agent mark and this agent's name on every device — but says nothing about permissions, rate limits, or mutability, which matters for a write 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?

Two sentences, front-loaded with the verb and resource. Efficient overall, though the second sentence leans toward reassurance about attribution rather than operational guidance.

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 mutation tool with no annotations and no output schema, the definition covers purpose and the visibility/attribution trait, and the schema fully documents parameters. However, it omits usage routing against siblings and deeper behavioral context such as auth or limits, leaving clear 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 100%, so all six parameters are already documented in the schema. The description reinforces the text-vs-snippet distinction and the channel destination but adds no syntax or format detail beyond what the schema already provides, so the baseline 3 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 specific verb and resource — 'Send a note' — and clarifies the payload variants (plain text or code snippet with language) plus the destination ('one of the owner's Zas channels'). It is clear, but it does not explicitly distinguish itself from siblings like zas_send_file or zas_send_direct, leaving the differentiation to inference.

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 offers no when-to-use, when-not-to-use, or alternative-tool guidance. It states the destination channel but never says when a note is preferable to zas_send_file or zas_send_direct, so the agent must guess from sibling names.

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 a meaningful behavioral trait: the owner sees every item sent by this agent with the >_ agent mark and agent name on every device (an auditing/visibility property). It does not explicitly confirm the call is side-effect-free or describe behavior when unpaired.

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 sentences, front-loaded with the core purpose (pairing status plus channel list). The second sentence about owner-visible agent marking is somewhat tangential to invocation but adds legitimate context, so it earns its place without bloat.

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 and no output schema, the description must convey return content, and it does: pairing status plus the list of channels the agent may send to or read from. It omits the unpaired/error case and any note on caching or refresh, but is otherwise complete for a zero-parameter status 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?

The tool takes zero parameters and schema coverage is 100%, so the baseline is 4 and there are no parameter semantics for the description to add. Nothing is missing on this dimension.

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: reports whether the agent is paired with a Zas account and lists the owner's channels available for send/read. It is clearly distinguishable from zas_pair, but it never names a sibling or scope boundary explicitly, so it stops short of full 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?

Usage is only implied: an agent can infer this is a status/introspection check, likely before sending. There is no explicit when-to-use, when-not, or alternative (e.g., 'use zas_pair if not yet paired'), so the guidance is adequate but thin.

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