AI Ventures

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered. The description adds real substance beyond that: payloads are erased while metadata survives until retention ends, telling the agent exactly what is irreversibly lost.

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, no filler; the action and its scope come first, and the destructive consequence follows immediately.

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

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

With an output schema present and annotations covering idempotency and destructiveness, the description need only explain side effects, which it does well. It omits any auth/permission or error-condition context, a minor gap for a destructive mutation.

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 both parameters are documented there. "through the sequence cursor" loosely echoes the `through` parameter but adds no syntax or boundary detail beyond the schema's "inclusive" note, 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 (acknowledge) and resource (events) scoped by a sequence cursor, which distinguishes it from list_events. No sibling is named, so routing is inferable rather than explicit.

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?

"after processing" gives a clear timing cue for when to call it, but the description names no alternative or exclusion condition. 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?

The annotations already declare readOnlyHint=false, destructiveHint=true, and idempotentHint=true. The description adds useful behavioral context beyond those annotations by stating that already recorded responses are preserved, clarifying what the destructive-looking close operation does not destroy.

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 short, front-loaded sentences with no filler. Every sentence contributes directly to understanding the action and its effect.

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 mutation, the description is largely complete: the annotations cover safety behavior and an output schema exists for return details. It adds the key preservation behavior but does not elaborate on close semantics versus other review lifecycle states.

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 100% description coverage for the single id parameter ("Resource id."). The description adds no additional meaning about the id parameter beyond what the schema already documents, so the baseline of 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?

The description uses a precise verb and resource: "Close a pending review link." It clearly distinguishes this mutation from sibling read/create tools like get_review and create_review, and adds the scope of "pending review link."

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 "pending review link" gives clear context that this applies to reviews still open, implying it is not for completed or already closed reviews. It does not explicitly name alternatives or exclusions, but the usage context is clear enough for an agent.

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?

Annotations already cover the safety profile (readOnly=false, destructive=false, idempotent=false, openWorld=false), and the description adds genuinely non-redundant behavior: one credit per new unique task with free lease reacquisition, a timed lease with reacquisition semantics, and the honest caveat that a lease cannot guarantee exactly-once external side effects. That cost and side-effect disclosure is exactly the value annotations cannot carry.

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 tightly packed sentences, front-loaded with the coordination purpose and lease behavior before retry mechanics. Every sentence carries information, though the density borders on telegraphic and could use a clearer separation of acquisition vs. retry 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?

With an output schema present, return values need not be explained, and the description covers cost, lease timing, retry semantics, and the side-effect caveat. Remaining gaps are minor: what happens when a lease expires unrenewed and the conflict/409 path are left to the schema and sibling tools.

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

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

Schema coverage is 100%, so the baseline is 3, but the description goes beyond the schema by explaining the reuse-vs-fresh idempotency_key decision (replay an active acquisition with the same key, use a new key for a later acquisition). It adds little about task_key, namespace, worker_id, or lease_seconds beyond what the schema already documents.

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 a precise verb pair and resource: it acquires a timed lease or retrieves an existing reservation/result for a shared task. The framing around coordinating independent agents on a shared account/namespace/task key makes it clearly distinct from siblings like get_task, renew_lease, or release_lease.

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 states the operating context (independent agents sharing account, namespace, and stable task key) and gives explicit retry guidance: reuse idempotency_key to replay an active acquisition after a lost response, use a fresh key for a later acquisition. It does not name sibling alternatives (e.g., get_task for status checks) or state when not to claim, so it stops short of a 5.

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

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

Annotations say it is a non-read-only, non-idempotent, non-destructive write, and the description adds real context beyond that: a lease must be actively held, the lease_token acts as proof of ownership, and the payload is capped at 32 KiB. It does not disclose what happens on a stale fence or expired lease, which for a non-idempotent mutation would be 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 core action and constrained to the lease precondition and size limit. No filler or repetition of the name/title.

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

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

An output schema exists, so return values need not be described. The description covers the mutation, the lease precondition, and the payload limit, but omits failure semantics (expired lease, fence mismatch) and whether completing changes the shared task's state, which matters for a non-idempotent write.

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 id, fence, lease_token, and result. The description only reinforces the 32 KiB result cap and the lease-ownership requirement, adding little beyond the structured data, so a 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: publishing a JSON result tied to an active lease, which is the terminal step of the claim_task/get_task lifecycle. It is distinguishable from siblings like release_lease or get_task, though it does not explicitly name an alternative tool.

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 'while holding an active lease' implies the precondition, and 'other participating agents can retrieve the result instead of repeating the work' implies why to use it (avoid duplicate work). However, no explicit when-not conditions or named alternatives are given, so usage 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?

Annotations only declare safety flags (non-read-only, non-destructive, not idempotent). The description adds genuinely useful behavior beyond that: cost ('Consumes one inbox credit') and the critical fact that 'Callback arrival does not restart a stopped assistant,' which an agent might otherwise assume incorrectly. Return format is handled by the output schema.

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

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

Four short, dense sentences with the capability front-loaded and lifecycle caveats after. No filler, though the credit-cost sentence and restart caveat could be merged slightly more tightly.

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

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

For a 3-param, all-optional creation tool with an output schema and annotation safety profile, the description covers purpose, lifecycle caveat, and cost. Nothing essential for correct invocation appears missing.

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

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

Schema coverage is 100% with all three optional params (label, idempotency_key, expires_in_seconds) fully documented in the schema, including the 409-on-reuse semantics and lifetime bounds. The description adds no parameter detail, 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?

The description states a specific capability: 'Provision a reachable intake URL, then retrieve events in a later run,' which clearly identifies this as the creation/provisioning tool among inbox siblings. It doesn't explicitly name a sibling like get_inbox or delete_inbox, but the create-vs-read/delete distinction is inferable from the provisioning framing.

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 clear context for when this tool is appropriate: 'after the agent process exits' and for callbacks that must survive a stopped assistant. There is no explicit when-not or routing to an alternative sibling, so it falls short of a 5.

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

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

With annotations present, the description adds substantial context the annotations do not carry: the page is private, the version is immutable, one review credit is consumed (a cost/quota signal), and the returned link must be conveyed out-of-band. The idempotency_key retry note is consistent with idempotentHint=false rather than contradicting it. It does not restate the non-destructive profile that annotations already cover.

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

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

Four short sentences, each carrying a distinct fact (purpose, artifact, delivery of link, cost/retries) with minimal waste. It is front-loaded on the outcome and closes with the operational caveat, though the opening sentence is slightly indirect for a creation 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 6-parameter, non-destructive mutation tool with an output schema and annotations, the description covers the full workflow: create, immutable snapshot, private link, out-of-band delivery, credit cost, and retry safety. Return values are correctly left to the output schema, though credit/quota preconditions could be spelled out more explicitly.

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 83%, so the schema already documents title, text, choices, image_urls, expires_in_seconds, and idempotency_key in detail. The description only reinforces idempotency_key for retries; it adds no new semantics about choices vs approval flows or image constraints beyond what the schema states, 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?

The description states the outcome (get feedback or a selection from a person) and the resource created (a private page for an immutable version of text or images), so an agent can tell this is a review-creation tool distinct from get_review/cancel_review. However the first sentence leads with the user goal rather than the action, so the verb 'create' is implicit rather than explicit.

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 useful operating guidance ('send the returned link through your own communication channel', 'use idempotency_key for retries'), which is real when-to-do-what context. But it never states when to choose this over siblings like get_review, claim_task, or complete_task, nor any prerequisite (e.g. needing a credit balance) beyond the cost note.

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?

Annotations already flag destructiveHint=true and idempotentHint=true, so the safety profile is known. The description adds concrete behavior beyond that: it specifies that intake is disabled and that queued events are permanently erased, telling the agent exactly what data is lost. It stops short of noting auth requirements or reversibility caveats.

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

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

A single front-loaded sentence with no filler; the destructive outcome is stated first and every word 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?

For a one-parameter destructive tool with rich annotations and an output schema, the description covers the essential behavioral fact (permanent erasure of queued events). It omits permission/authorization context and any confirmation semantics, but nothing critical to correct invocation 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?

Only one parameter exists and schema coverage is 100%, so the schema already documents 'id' fully. The description adds no syntax or format guidance beyond the schema, which is the expected baseline when the schema carries the load.

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 pairs a clear mutation verb ('Disable... permanently erase') with the specific resource ('intake' / queued events), so the agent knows exactly what operation is performed. It does not name sibling tools like create_inbox or get_inbox to differentiate, 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?

There is no statement of when to use this versus alternatives (create_inbox, get_inbox), no prerequisites, and no warning about the irreversible loss beyond the bare fact of erasure. The agent must infer usage context entirely.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds only the returned fields, which are already exposed by the output schema, and says nothing about auth requirements, error cases, or expiry semantics.

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

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

A single short sentence that front-loads the verb and lists exactly the returned values. Nothing is redundant or 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?

For a read-only lookup with full annotations and an output schema, the description covers what is fetched and needs no return-value prose. Only the missing guidance on when to use it versus siblings keeps it from being fully 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?

There is a single parameter, and schema coverage is 100% with a documented 'Resource id.' The description adds no syntax, format or scoping detail beyond what the schema provides, so the baseline of 3 for schema-documented parameters 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 names a specific verb (Get) and enumerates exactly what is retrieved: the receive URL, intake expiry and lifetime event count. Combined with the title 'Get a callback inbox', an agent can identify the resource and payload without opening the schema. It does not, however, differentiate itself from siblings like get_review, get_task or get_pricing beyond the title.

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

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

There is no statement of when to use this tool, what prerequisite id it expects, or which sibling to use instead (e.g., create_inbox, delete_inbox, list_events). Usage must be inferred entirely from the name and title.

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?

Annotations already declare readOnlyHint, idempotentHint and openWorldHint=false, so the safety profile is covered. The description adds useful content-level context (that the response includes allowances, prices and live payment availability), but says nothing about auth requirements or rate limits. Adequate, but not rich.

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

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

A single front-loaded sentence with no filler. Every clause (allowances, pack prices, payment availability) names a distinct returned artifact, so 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?

With a rich annotation set, an existing output schema, and no parameters, the definition is nearly complete — return details are carried by the output schema. The only missing piece an agent would want is a routing hint against get_usage.

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

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

The tool takes zero parameters, so there is no parameter semantics burden; the baseline for a zero-param tool is 4. The description correctly does not waste space restating a nonexistent input 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 (get) and resource (pricing) and enumerates the content returned: free allowances, prepaid pack prices, payment availability. It is clear what the tool does, but it never distinguishes itself from the nearby sibling get_usage, which is the most likely source of selection confusion.

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 by what the tool returns — an agent can infer you call it to check billing/pricing state — but there is no explicit when-to-use statement, no prerequisites, and no mention of get_usage as the alternative for consumption data. Minimum viable guidance only.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false. The description adds meaningful context beyond annotations: it clarifies that a reviewer-entered name is self-reported and not identity verification or a legal signature, which affects how the returned data should be interpreted.

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 sentences, front-loads the core action, and includes a relevant caveat without unnecessary words. Every sentence 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?

Given the simple one-parameter retrieval, the rich annotations, and the presence of an output schema, the description is complete enough. It need not explain return values because the output schema exists, and it adds important interpretive context about reviewer names.

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% and there is one parameter ('id') fully documented in the schema. The description adds no additional meaning about the id parameter, so the baseline of 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?

The description states a specific verb and resource: 'Retrieve a review and its version-bound structured response.' This clearly distinguishes it from sibling tools like create_review and cancel_review.

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 says what the tool does but gives no explicit guidance on when to use it versus alternatives such as create_review, cancel_review, or other get_* tools. Usage is only implied by the verb 'Retrieve'.

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?

Annotations already declare read-only, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds that completed results are included and gives the REST key-lookup route, but does not discuss pagination, auth, or rate limits; with annotations in place this is modest added context.

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

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

The definition is front-loaded and compact, moving from the core retrieval action to lookup modes and then to the REST endpoint detail. Every sentence contributes without repetition.

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 a rich annotation set and an output schema, the description does not need to cover return values. It is complete enough for a read-only retrieval tool with three optional parameters, though it could clarify tool-selection boundaries versus mutating siblings.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds meaningful lookup semantics: id works in both REST and MCP, while namespace+task_key is described as an MCP path, with a REST query example. This goes beyond the generic schema descriptions, though the parenthetical '(MCP)' next to namespace/task_key while also describing a REST key lookup is slightly confusing.

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 resource ('a task'), and enumerates the two supported lookup modes. The retrieval framing distinguishes it from action siblings like claim_task and complete_task, though it 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?

Explains which parameter combinations are valid (id via REST or MCP; namespace/task_key via MCP) and gives the REST endpoint for key lookup. However, it offers no explicit guidance on when to choose this tool over alternatives such as claim_task or complete_task.

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?

Annotations already declare read-only, idempotent, non-destructive, and closed-world behavior. The description adds no behavioral context beyond those annotations, such as freshness guarantees, authentication requirements, or rate limits, though it does not contradict them.

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

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

A single front-loaded sentence with no wasted words. It states exactly what is returned and nothing more.

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 no-parameter, read-only tool with rich annotations and an output schema, the description is complete enough. It identifies the returned data and does not need to explain return structure because an output schema exists.

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 no parameters, so per the rubric the baseline is 4. There are no parameter meanings for the description to clarify beyond what the empty schema already shows.

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 ('Get') and resource ('current account credits and service limits'), so the tool's function is clear. It does not explicitly differentiate itself from the sibling get_pricing, which concerns pricing rather than credit balances and service limits, so it is not 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?

Usage is only implied: call this when you need current account credits or service limits. There is no explicit when-to-use, when-not-to-use, or alternative guidance, such as distinguishing it from get_pricing.

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?

Annotations already cover read-only, idempotent, non-destructive semantics, so the description only needs to add value beyond that. It does: it warns that payloads are untrusted external data and states the seven-day retention window, which is real operational context an agent cannot get from annotations.

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, each earning its place: the core action/cursor model, the security caveat, and the retention limit. Front-loaded with the primary function 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?

An output schema exists, so return values need not be described, and the description adds the retention window and trust warning that the structured fields lack. It does not cover the required `id` resource's meaning or pagination termination, but nothing critical for correct invocation 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%, so the schema fully documents id, after, and limit, establishing a baseline of 3. The phrase 'after a sequence cursor' reinforces the semantics of `after` but adds no format or edge-case detail beyond the schema's 'Last processed sequence, exclusive.'

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 ('Read ordered events') plus the access pattern ('after a sequence cursor'), which is enough to distinguish it from acknowledge_events. It stops short of explicitly naming the sibling it complements, so it lands at 4 rather than 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?

Usage is implied — you call this to pull events from a stream — but there is no explicit when-to-use, no prerequisite (e.g. having an id from a task/lease), and no guidance on how it pairs with acknowledge_events. Minimum viable.

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?

Annotations already declare destructiveHint=true and idempotentHint=false, so the agent knows this mutates state and is not repeat-safe. The description adds the meaningful consequence that the lease becomes acquirable by another worker, but says nothing about ownership validation, failure modes, or what happens to a released task.

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

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

A single front-loaded sentence with no waste; the action and its effect are stated immediately.

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

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

An output schema exists so return values need no explanation, and annotations cover the safety profile. However, for a destructive, non-idempotent lease mutation with three required parameters, the description omits error/ownership conditions and the interplay with renew_lease, leaving it only minimally adequate.

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% and the schema itself documents id, fence (fencing number from acquisition), and lease_token (secret proof of ownership). The description adds no parameter-level meaning beyond 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 (release) and resource (active lease) plus the effect (another worker can acquire it). It is clearly distinct from claim_task and renew_lease in spirit, though it never names a sibling explicitly.

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

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

Implies the usage context ('your active lease') so the agent understands this applies to a lease it currently holds, but there is no explicit when-to-use versus renew_lease or complete_task, and no stated prerequisites such as needing a valid fence/lease_token.

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?

Annotations already declare readOnly=false, idempotent=false, destructive=false, so the safety profile is covered. The description usefully adds that the lease must be active and that a fencing number is required, but it never states that renewal extends the lease lifetime (which the lease_seconds parameter implies) or what a fence mismatch does. Adds some value beyond annotations, not rich.

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, zero waste, with the core operation front-loaded and the constraint following. Nothing could be trimmed without losing information.

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 an output schema present, return values need no explanation, and annotations carry the safety profile. The one meaningful gap is that renewal semantics (that it resets the lease clock via lease_seconds) are left for the agent to infer from the schema alone.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema, including fence meaning and lease_seconds defaults. The description only restates token and fence at a high level, adding no format or constraint detail beyond what the schema provides. Baseline 3 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?

States a specific verb (renew) and resource (lease) and names the two credentials required (secret token, fencing number), so the agent knows exactly what operation this is. It does not explicitly contrast with siblings like release_lease or claim_task, so a 4 rather than 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?

"Renew an active lease" plus "Expired or stale leases cannot renew" gives a clear precondition and a when-not condition, which is more than most definitions offer. It still names no alternative tool for acquiring or releasing a lease, so it falls short of explicit routing guidance.

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