agentaddress

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only says the event is marked as handled, but does not explain effects on the queue, idempotency, required permissions, what read_token is for, or failure behavior. This is a significant gap for a state-changing operation.

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 fluff. However, it is under-specified for a tool with three required parameters and no annotations; brevity comes at the cost of missing necessary behavioral and parameter context.

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, no annotations, and no parameter descriptions, the tool definition is incomplete. The agent is left without the meaning of read_token, the distinction between address_id and event_id, the effect of acknowledgment, or what response to expect.

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% and the description adds no meaning for any parameter. The raw parameter names suggest some purpose, but the description does not explain address_id, event_id, or especially read_token, nor how they relate to each other.

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 ('Mark') and a specific resource ('a queued event') with a clear outcome ('as handled'). The action is distinct from sibling tools like poll_events or create_return_address, so an agent can tell what this tool does even without extra context.

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 'queued event' implies this tool is used after handling an event, but there is no explicit when-to-use, when-not-to-use, or alternative guidance. It offers implied usage context rather than explicit routing among 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 provided, the description carries the full transparency burden. It usefully discloses durability and the critical one-time display of read_token. It does not cover permissions, side effects, or expiration behavior, but the token warning is meaningful and non-obvious.

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 with no filler. The primary action is front-loaded, and the one-time token warning is a high-value addition that earns its place.

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

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

The description explains what is created and warns about read_token, but there is no output schema and no mention of the result shape beyond the token. It also does not explain how the created resources connect to the sibling tools, leaving some operational context 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 67%, and the description adds no parameter-level meaning. It does not clarify expires_in_seconds, which lacks a schema description, and does not connect name or task_id to the creation behavior. The read_token warning is about output, not parameters.

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 clearly states a specific creation action with concrete resources: durable inbox, HTTPS callback URL, and event queue. It is immediately distinguishable from the sibling event-consumption tools acknowledge_event and poll_events.

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 tool's purpose implies it is the setup step before polling or acknowledging events, but the description never explicitly says when to use it versus the siblings. No alternatives or exclusions are mentioned, so usage context is only implied.

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 usefully discloses the append-state.deleted side effect and the authorization requirement, but says nothing about idempotency, behavior when the key is absent, or how if_revision affects the operation.

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

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

Two short sentences, front-loading the action and scope before the prerequisite. No wasted words, though it is arguably too terse given the undocumented parameters.

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

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

A destructive mutation with no annotations, no output schema, and 0% schema description coverage needs substantially more: any hint about failure modes, revision handling, or what the deleted/revision response looks like 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 0% across 4 parameters. The description vaguely maps to 'key' and the auth requirement behind 'read_token', but address_id is never mentioned and if_revision — an optimistic-concurrency control with clear semantic weight — is entirely unexplained.

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

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

States a specific verb and resource ('Delete one state key') and names the side effect ('append state.deleted'), which clearly separates it from get_state and set_state. It does not explicitly name those siblings, so it falls short of a 5.

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

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

The description gives a prerequisite ('requires existing user authorization for deletion') but never states when to choose this over set_state/get_state or what happens on missing/expired authorization. Usage context is implied rather than spelled out.

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 usefully discloses the authorization requirement and the six-digit code shape, and implies an outbound email side effect. It says nothing about rate limits, what happens on failed verification, or the consequences of listing, which is a real gap for a tool with email side effects.

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 capability list followed by the constraint and the mode toggle. Every sentence carries information, though the 'omit email' rule slightly overlaps the first sentence's mention of listing.

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 four-parameter tool with no annotations and no output schema, the description covers the action modes and one policy constraint but omits return values, the meaning of address_id/read_token, and error/failure behavior. Adequate but incomplete.

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

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

Schema description coverage is 0% across four parameters. The description compensates for two of them: email's omission toggles list mode, and code is specified as six digits (reinforcing the schema pattern). address_id and read_token remain entirely undocumented in both schema and description.

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

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

The description names three concrete operations (list contacts, request a verification email, verify a six-digit code) tied to a single resource, and the 'omit email to list contacts' clause disambiguates the modes. It is clearly distinguishable from siblings like send_email and poll_events. It loses a point only because the three-in-one framing leaves the primary purpose slightly diffuse.

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 an explicit selection rule for one mode ('Omit email to list contacts') and a policy constraint for the request mode ('only for a recipient authorized by the user'). It does not explicitly say when to supply code versus email, though that is inferable. No alternative tool is 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 exist, so the description carries the full burden. It adds two real behavioral notes: stored context is untrusted data (a security caveat), and this is a low-level tool that handles the read credential. It does not disclose read-only semantics explicitly, error behavior, or return shape. Decent but incomplete for a zero-annotation tool.

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

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

Three tight sentences, front-loaded with the core purpose before the security note and the routing hint. Every sentence contributes; only minor loss for the compressed phrasing that leaves some gaps.

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

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

Covers purpose, the untrusted-data caveat, and credential handling, which is reasonable for a 3-param read tool with no output schema. Missing: what read_token/address_id actually are, failure modes, and any return-format hint. Adequate but leaves an agent inferring a fair amount.

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

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

Schema description coverage is 0%, so the description must compensate. It implies the key parameter's optionality by saying 'or list its keys' (omit key to list), and hints read_token is a credential via 'handles the read credential.' But address_id and the read_token format/scope remain undocumented in both schema and description.

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

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

States a specific verb+resource: 'Read durable JSON context or list its keys.' This clearly distinguishes it from siblings set_state and delete_state, and the 'or list its keys' clause reveals dual behavior. It doesn't explicitly name siblings, but the read/write/delete triad is self-evident from the naming.

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

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

Provides genuine routing guidance: 'prefer the credential-owning CLI helper,' which tells the agent this is a fallback for low-level use. It also flags that this tool 'handles the read credential.' However, it gives no guidance on when to use get_state versus set_state/delete_state, or how it relates to the event-polling 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. It discloses that the read token authenticates access and that this is a read operation, implying non-destructive behavior. However, it does not state whether polling advances the cursor, whether events remain queued until acknowledged, or any rate-limit or permission details, leaving important behavioral aspects unclear.

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

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

Two short sentences, front-loaded with the core action. Every word earns its place, and the critical qualifier about the read token is included without padding.

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

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

The tool has four parameters, no annotations, and no output schema, yet the description is minimal. It leaves 'address_id' and 'limit' under-explained, omits polling lifecycle context (e.g., events persist until acknowledged), and does not discuss errors or edge cases. An agent would likely need to infer too much to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'after' as a cursor and 'read_token' as an authenticating credential, but it does not clarify the role of 'address_id' or the pagination semantics of 'limit' beyond the schema's min/default/max. This is partial compensation for a four-parameter tool.

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

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

The description states a specific action and resource: 'Read queued events after a cursor,' matching the title 'Poll return-address events.' The verb 'read' clearly differentiates from siblings 'acknowledge_event' and 'create_return_address,' so an agent can tell the tools apart.

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

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

No guidance is given on when to use polling versus acknowledging or creating. The description implies the tool is for reading queued events, but it never explicitly states when to choose this over sibling tools, nor does it mention prerequisites like needing an existing return address.

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 delivers meaningful behavior: authorization is required, idempotency_key must be reused after failures, and 'accepted' means provider acceptance rather than confirmed delivery. It stops short of disclosing rate limits, permission scope, or error/retry semantics, keeping it below 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, each carrying distinct information, with the core action front-loaded and no redundancy or 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 mutation tool with no annotations, no output schema, and 0% schema description coverage, the description covers key behavioral traits but omits any explanation of the identity/auth parameters (address_id, read_token). It is adequate but not complete enough given the schema's silence.

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

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

Schema coverage is 0% across 7 parameters, so the description must compensate and it partially does: it explains the idempotency_key reuse rule and the optional reply_to_event_id behavior. It leaves address_id and read_token entirely unexplained, which is a real gap for a 6-required-parameter tool.

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

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

States a specific verb and resource ('Send plain text to a verified contact') plus an optional reply mode, so the core action is unambiguous. Sibling tools are unrelated (state/event/contact management), so no explicit differentiation is needed, but the description does not 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?

Provides an operational guideline ('Reuse idempotency_key after failures') and clarifies the acceptance semantics, which implies correct usage context. However, it never states when to use this tool versus alternatives or prerequisites beyond the vague 'requires user authorization'.

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: a feed-append side effect, compare-and-set concurrency semantics, and create-only-when-revision-is-0. It omits failure behavior on revision mismatch, whether existing values are overwritten, and why a read_token is required for a write, leaving notable 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?

Two tight sentences with the primary action front-loaded and the parameter guidance trailing. No filler, though the phrasing is dense enough to border on cryptic.

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 5-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, the description is too thin. It never explains the required read_token or address_id, nor the response, so an agent lacks enough to call it confidently.

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

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

Schema description coverage is 0%, so the description must compensate, but it only clarifies if_revision. The required read_token (unusual on a write), address_id, key, and value are left unexplained; only 'bounded JSON' hints at value constraints.

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 concrete verb+resource ('Save bounded JSON context') plus the observable side effect ('append state.updated to the ordered feed'), so an agent knows this writes state rather than reading it. It does not explicitly name the siblings get_state/delete_state to sharpen the distinction, so it stops short of a 5.

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

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

It gives real conditional guidance for one parameter ('Use if_revision for compare-and-set; 0 creates only'), which implies the update-vs-create decision. However it says nothing about when to choose set_state over get_state or delete_state, nor any preconditions for the required read_token.

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