Ausca

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

The description discloses important behavioral traits beyond the annotations: idempotency (matching annotation), URL expiry (≤60 seconds, never after inbox expiry), the trust caveat (clean verdict does not make content trusted), and the transport instruction (lease bearer on HTTP/MCP, never in arguments). These add significant value beyond the idempotentHint and openWorldHint 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?

The description is three sentences, each densely informative: the main action and condition, the expiry/trust caveats, and the transport instruction. It is front-loaded with the core behavior and contains no fluff.

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 that an output schema exists (return format is already covered), the description covers all operational essentials: the active-inbox precondition, the safety-verdict condition, expiry behavior, the trust caveat, and the lease-bearer transport requirement. An agent has everything needed 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 carries the full burden of explaining parameters. It does not mention inbox_id, message_id, attachment_id, or idempotency_key at all. The schema itself provides names and patterns, but the description adds no semantic meaning, leaving the agent to infer from names alone.

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

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

The description states a specific verb (return) and resource (download URL for an attachment) with a precise condition (only when the exact stored attachment has a clean safety verdict). It clearly distinguishes this from sibling tools like ausca_artifact_access by scoping it to inbox attachments and the safety gating.

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

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

It provides clear context for when to use the tool ('For an active inbox') and the condition of a clean safety verdict, but it does not explicitly name alternatives or state when not to use it. The context is sufficient for an agent to decide, though exclusions are absent.

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?

Matches annotations (idempotent, destructive) and adds detail beyond them: specifies what gets deleted (message and attachment content), notes it works on an already-terminal lease, and clarifies transport-level authentication. No contradiction.

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, followed by an auth note. No redundant phrases; 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 single-parameter tool with an output schema, the description covers purpose, idempotency, destructive scope, and auth. The only gap is parameter semantics, but that is minor given the simple interface.

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 only vaguely references 'one inbox lease' without explaining inbox_id format, meaning, or relationship to the bearer. The pattern in the schema is the only hint, leaving the parameter under-explained.

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 ('stop', 'delete') and resource ('inbox lease') with clear scope: 'stop inbound visibility and delete retained message and attachment content.' It distinguishes from sibling tools like read/status/attachment by focusing on deletion.

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 context that this is for deletion, mentions idempotency, and gives explicit auth guidance ('Supply the lease bearer on the HTTP or MCP transport; never place it in tool arguments'). It doesn't explicitly name alternatives or exclusions, but the purpose makes the use case clear.

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

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

Annotations only indicate read-only, idempotent, open-world, and non-destructive. The description adds important behavior beyond those: page size cap, possible empty page with continuation cursor, opaque transport-bound cursor, and authentication guidance to keep the lease bearer off tool arguments. No contradiction with 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?

Two tightly written sentences with no filler. The core listing/wait behavior and pagination semantics come first, followed by the critical authentication constraint. Every sentence adds value.

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 output schema, annotations, and the provided cursor/wait constraints, the description covers the key operational details: page cap, cursor continuation, bounded wait, empty-page possibility, and transport-level auth. Nothing essential is missing for a caller to use the tool correctly.

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

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

Schema description coverage is 0%, so the description shoulders the semantic burden. It effectively explains the roles of inbox_id, after, and wait_seconds even without naming them directly: active inbox, opaque cursor, and up-to-30-second wait. The schema itself adds cursor constraints and bounds, and the description adds meaningful behavioral context on top.

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: return or wait for normalized message summaries for an active inbox, with concrete bounds ('at most 50', 'after an opaque inbox-bound cursor'). It clearly distinguishes this list/wait operation from sibling tools like read, delete, or attachment retrieval.

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 clear context: this is for listing or waiting on inbound messages in an active inbox, using a cursor and optional bounded wait. It does not explicitly name alternatives or state when not to use it, but the behavior is unambiguous enough for an agent to select it appropriately.

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?

It goes well beyond the readOnly/idempotent annotations by disclosing that message content is untrusted sender-controlled data, that HTML is inert and never rendered, and that the lease bearer must be supplied on the transport, never in tool arguments. This is valuable behavioral and security context an agent cannot derive 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 front-load the core purpose, then add security warnings and auth placement instructions with no filler. Every sentence carries distinct, necessary information for safe invocation.

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 and strong annotations already present, the description covers the important remaining operational details: active-inbox precondition, untrusted content handling, and auth transport. It is only slightly incomplete in not explaining parameter semantics or explicitly routing between 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 description coverage is 0% and the description does not mention inbox_id or message_id at all. It adds no meaning beyond the parameter names and regex patterns, so the description fails to compensate for the schema's lack of explanations.

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 and resource: 'return one bounded normalized message' for an active inbox. The singular 'one' clearly distinguishes it from sibling list-oriented tools like ausca_agent_inbox_messages.

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 provides a precondition ('For an active inbox') and implies single-message selection, but it never explicitly contrasts this tool with alternatives like ausca_agent_inbox_messages or states when not to use it. Usage guidance is inferred 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?

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds context beyond those: it specifies the response includes the authoritative lease state, current expiry, and terminal status after deletion or expiry, and it warns that the lease bearer must travel on the transport rather than in arguments. This is valuable behavioral and security-relevant disclosure.

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 with no wasted words. It front-loads the core purpose and return contents, then adds the critical transport/auth constraint. 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?

For a one-parameter read-only tool with an output schema and annotations already declaring safety, the description covers the important behavioral points: what is returned, terminal states, and where to supply the lease bearer. It does not discuss when to prefer this over sibling tools, but that is largely inferable from the name and sibling list.

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 input schema has 0% description coverage, so the description must compensate for the single inbox_id parameter. It only says 'for one inbox,' which does little more than echo the parameter name. It does not explain how to obtain a valid inbox_id, what the pattern implies, or how the parameter maps to the returned lease information.

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 ('Return') and names the resource ('lease status for one inbox'), and explicitly lists the returned elements: random receive-only address, authoritative lease status, current expiry, and terminal status. This clearly differentiates it from sibling tools like ausca_agent_inbox_read, ausca_agent_inbox_delete, and ausca_agent_inbox_messages.

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 guidance on when to use this tool versus the sibling tools, nor any mention of alternatives or exclusions. The only operational instruction concerns lease-bearer placement on the transport, which is an authentication detail rather than usage selection advice.

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?

Beyond annotations, the description discloses the 60-second URL expiry, the exact HTTP request shape, path/header parameter mapping, and the requirement to verify downloaded bytes against the returned content digest. It also states that the immutable artifact reference is the only authority, adding meaningful behavioral 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?

Four sentences, all load-bearing: purpose, HTTP/MCP argument mapping, expiry, and integrity verification. The most important information is front-loaded and there is 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?

For a two-parameter tool with an output schema, the description covers the applicable artifact scope, URL lifetime, invocation mechanics, and verification expectations. Nothing essential is left to inference for an agent to call this tool correctly.

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

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

With schema description coverage at 0%, the description must compensate. It usefully maps artifact_ref to a URL path parameter and says to relay it unchanged, and maps idempotency_key to the Idempotency-Key header. However, it does not explain the idempotency key's generation or deduplication semantics beyond that mapping.

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 and resource: it returns an idempotent, short-lived download URL for one verified artifact, explicitly including result artifacts named by a succeeded invocation's output_artifact. This distinguishes it clearly from the sibling invocation, offer, and inbox tools, none of which mint download access.

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 clear selection context by scoping the tool to verified artifacts the service holds, including invocation result artifacts. It does not explicitly name alternatives or say when not to use it, but no sibling tool serves the same purpose.

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 description adds behavioral context beyond the annotations. It explicitly states idempotency (matching idempotentHint), explains that closing never creates a payment (a unique side-effect not in annotations), and details what gets terminated (CDP relay and upstream browser). It also provides transport-level guidance on the lease bearer, which is beyond the structured annotations. No contradictions.

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 three sentences, compact, and front-loaded with the core action. Each sentence adds value: action and scope, payment side-effect, and transport security. No filler or redundant wording.

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 single-parameter destructive tool with rich annotations (idempotent, destructive), the description covers the essential behavior, side effects, and security considerations. It doesn't mention the return value or error handling, but an output schema exists. It could also explicitly state when to use it, but the core usage is clear enough. Overall, it's nearly complete.

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

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

The schema has one required parameter (session_id) with a regex pattern but no textual description, giving 0% schema description coverage. The description mentions 'for one lease' and refers to the lease bearer, implying session_id is the lease identifier, but it does not explicitly state what session_id represents. It also cautions not to place the lease bearer in tool arguments, which could confuse whether session_id is the bearer. More explicit parameter explanation would help.

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 ('terminate'), a specific resource ('CDP relay and upstream browser'), and a specific scope ('for one lease'). It clearly distinguishes from sibling tools like connect and status by describing the closing action. The phrase 'Idempotently terminate' also conveys the operation's nature.

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 critical usage guideline: 'Supply the lease bearer on the HTTP or MCP transport; never place it in tool arguments.' It also notes that closing never creates another payment, implying it's a cleanup operation. However, it does not explicitly state when to use this tool over its siblings (e.g., when a session is done) or mention any prerequisites like an active lease.

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?

Beyond the annotations, it discloses the 60-second expiry, single-live-connection cap, 64-ticket coexistence limit, compaction behavior, and the fact that upstream credentials are never disclosed. This richly characterizes the tool's side effects and constraints without contradicting any annotation.

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 purpose is front-loaded in the first sentence, followed by tight constraints and one usage rule; every sentence carries distinct information and there is 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?

For a two-parameter tool with an output schema and rich annotations, the description covers the important quotas, expiry, and transport-security behavior. It may leave error states or the precise meaning of a 'ready lease' implicit, but it is fundamentally complete for correct invocation.

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 zero prose descriptions for session_id or idempotency_key, and the description never explains their meaning or how they interact with the minting/lease flow. The bearer-transport instruction is useful but does not compensate for the undocumented 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 first sentence names an exact action and artifact: 'Return one single-use Ausca CDP relay URL for a ready lease.' This clearly distinguishes it from sibling status/close tools, which concern checking or terminating sessions rather than minting a connection.

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 clearly frames the tool's role—'for a ready lease'—and gives concrete invocation guidance: put the lease bearer on the transport, never in tool arguments. It does not explicitly name alternative tools or exclusion conditions, but the context is unambiguous for an agent selecting a connect operation.

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, and non-destructive behavior. The description adds valuable context by clarifying that the status is authoritative, that the lease capability is transport-supplied, and that the lease is neither a tool argument nor a response field.

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 purpose is front-loaded, and the second sentence earns its place by preventing a common misunderstanding about the transport-level lease.

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 output schema exists and annotations cover the safety profile, so return values and side effects are mostly handled. However, the description omits usage context and does not explain how to source the session_id, leaving an agent to infer these details.

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

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

The only parameter, session_id, is not described in the schema or the description. With 0% schema description coverage, the description needed to explain how to obtain or interpret session_id, but it only clarifies what is not an argument rather than what the parameter means.

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 ('Return') and resource ('one browser-session lease') and states the exact outcome ('status and expiry'). This clearly distinguishes it from sibling tools like ausca_browser_session_connect and ausca_browser_session_close.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as connect or close. An agent must infer usage from the tool name and read-only annotations rather than from stated conditions or exclusions.

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 description augments the annotations by revealing that cancellation is bounded, may be refused, and can lose a race with terminal completion. It also restates idempotence, which matches idempotentHint=true. No contradiction exists.

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-load the action and then supply the key behavioral caveats. Every sentence earns its place with zero redundancy.

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 cancellation with an output schema and annotations covering readOnly/destructive/idempotent, the description covers the critical uncertainty (refusal/race). A slightly more explicit statement about when cancellation is appropriate would make it complete, but nothing essential 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%, so the description must carry parameter meaning. It clarifies the target is 'one invocation' and the only parameter is invocation_id, but it does not explain identifier format or requiredness beyond the schema's own pattern.

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-resource pair ('cancel... one invocation') and the title reinforces the bounded, best-effort nature. No sibling tool performs cancellation, so it is immediately distinguishable from get/prepare/search tools.

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 context is implied: call this when an invocation should be cancelled. However, it does not state conditions for choosing cancellation over waiting or polling, nor does it identify alternatives/exclusions relative to 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?

Annotations declare destructiveHint=true and idempotentHint=true, covering the safety profile. The description adds important behavioral context: extension preserves address and contents, requires an active inbox, and limits prepaid expiry advancement to 30 days. However, it doesn't explain what gets destroyed (despite destructiveHint) or the replay/idempotency semantics beyond the word 'replay'.

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 that are dense but front-load the core purpose. Some redundancy ('Admit or replay' vs 'idempotent') and jargon reduce efficiency slightly, but no wasted sentences.

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 needn't be explained. However, given high parameter complexity (9 params, nested objects, 0% coverage) and destructive semantics, the description omits critical operational details—e.g., what constitutes a valid offer_revision_digest, the role of parent_binding, or how replay detection works. It's 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% and there are 9 parameters (7 required) with no descriptions. The description provides no parameter-level information whatsoever—it doesn't mention offer_id, idempotency_key, parent_binding, or any other field. For a tool with rich, nested input schema and zero documentation, this is a significant gap.

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

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

States a specific verb+resource ('Admit or replay one Agent Inbox Extension invocation') and clarifies scope by noting only inbox.extend envelopes are admitted on this resource. The 'idempotent paid' qualifiers add meaning. It distinguishes itself from siblings like ausca_open_inbox and ausca_prepare_invocation, though the phrase 'host boundary' is jargon that may not be universally clear.

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

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

The description implies usage conditions (settlement authority supplied by host, only inbox.extend offer envelopes) but doesn't explicitly state when to use this vs alternatives like ausca_prepare_invocation or ausca_open_inbox. No when-not-to-use guidance is provided.

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, and destructiveHint=false, so the safety profile is covered. The description adds value by specifying what is read (durable state, output commitment, receipt reference) and by explicitly stating the operation has no side effects on purchase or retry identity. This goes beyond the annotations without contradicting 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?

One sentence, front-loaded with the core action and resource, and ends with a meaningful exclusion clause. Every word earns its place; no fluff or repetition of the schema.

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 a single parameter, a rich output schema (not shown but present), and annotations covering safety and idempotency. The description explains the purpose and side-effect profile sufficiently. It doesn't describe the return value, but the output schema exists, so that burden is shifted. It could mention error cases or when the invocation state might be unavailable, but for a simple read tool this is 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 0%, so the description carries the burden for parameter semantics. However, the single parameter invocation_id is self-explanatory given the tool name and description, and the schema defines its format (pattern, maxLength). The description doesn't add detail about the parameter, but the parameter is simple and unambiguous. Baseline 3 is appropriate because the description doesn't actively compensate but the parameter is trivially clear from context.

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 ('Read'), a specific resource ('authoritative durable state, output commitment, and receipt reference'), and a clear scope ('for one invocation'). It also distinguishes itself from sibling tools by explicitly noting it does not create a new purchase or retry identity, which separates it from ausca_prepare_invocation and ausca_cancel_invocation.

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 implies when to use this tool: when you need the authoritative state of an invocation without side effects. It does not explicitly name alternatives or exclusions, but the negative clause ('without creating a new purchase or retry identity') provides clear context that this is a read-only lookup, distinct from preparation or cancellation flows. It lacks an explicit 'use X instead when...' statement, so it doesn't reach 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 already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds value by explaining the active-versus-exact-revision behavior and clarifying that the result includes schema and revision digests needed for an invocation envelope.

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, focused sentence provides the operation, scope, and a useful output-oriented detail. There is no filler or redundant restatement of the title, and the most important semantic distinction is front-loaded.

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

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

With a rich output schema and safety annotations already present, the description covers the key selection semantics and the reason for calling this tool. The only notable gap is the lack of explicit routing guidance toward sibling search tools, which is minor for a targeted lookup operation.

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 conveys the core difference between resolving an active offer versus an exact immutable revision, but it never explicitly names offer_id or revision_digest or explains which parameter selects which mode. The description adds partial meaning but does not fully carry the parameter documentation burden.

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 identifies a specific operation: resolving one active offer or an exact immutable revision. It distinguishes itself from a search/list tool by pointing to single-offer semantics and ties the purpose to constructing an invocation envelope.

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 context of use is implied: use this when you need a specific active offer or exact revision, especially for building an invocation envelope. However, the description never explicitly states when to prefer a sibling like ausca_search_offers or ausca_prepare_invocation, and no exclusions are given.

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 idempotentHint=true, destructiveHint=true, openWorldHint=true, and readOnlyHint=false. The description adds context beyond that by noting the invocation is 'paid' and that settlement authority must come from the host boundary, but it does not explain what gets destroyed, what authorization is required beyond that condition, or how replay behaves in detail.

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 tightly written sentences with no wasteful repetition. The purpose is front-loaded, followed immediately by the admission scope, making it efficient for an agent to parse.

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

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

For a complex tool with 9 parameters, nested objects, no input schema descriptions, and a mutation/destructive profile, the description covers only purpose and offer scope. The output schema helps with return values, but the input contract is left almost entirely unexplained, so an agent lacks enough detail to invoke the tool correctly.

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

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

The schema has 9 parameters with 0% description coverage, and the description mentions none of them by name or meaning. While terms like 'idempotent' and 'offer' loosely relate to idempotency_key and offer_id, no parameter-level semantics are communicated, so the description fails to compensate for the schema gap.

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

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

The description states a specific verb pair ('Admit or replay') and resource ('Browser Session invocation'), and scopes it to 'browser.session offer' envelopes. It distinguishes the tool from generic invocation siblings by restricting admission to that offer, 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?

It gives a precondition ('when settlement authority is supplied by the host boundary') and an exclusivity rule ('Only envelopes for the browser.session offer are admitted'). However, it does not say when to use this instead of siblings like ausca_prepare_invocation or ausca_browser_session_connect, so usage remains implied rather than explicit.

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

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

Annotations already declare idempotentHint, destructiveHint, openWorldHint and readOnlyHint, but the description adds real context beyond them: the operation is idempotent and replayable, it only admits inbox.receive envelopes, it starts a renewable inbox, and the result can be extended via inbox.extend without changing address or contents. It does not, however, explain the destructiveHint=true aspect (what state may be overwritten or lost), which would be the highest-value addition.

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, front-loaded with the core action and followed by scope and lifecycle notes; there is little waste. Density of domain jargon slightly hurts readability but 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?

An output schema exists so return values need not be described, and annotations cover the safety profile. However, with nine undocumented parameters and no explanation of the destructive behavior, the definition is only partially complete for a mutating, open-world invocation.

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 9 parameters (7 required, nested objects), so the description carries the full burden — yet it explains none of them. It only obliquely gestures at the offer restriction ('inbox.receive offer') without clarifying offer_id, offer_revision, digests, idempotency_key, or the parent_binding/attribution objects.

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 pair and resource ('Admit or replay one idempotent paid Agent Inbox invocation') plus a scoping constraint ('Only envelopes for the inbox.receive offer are admitted'). It distinguishes this resource from related siblings like inbox.extend, though the heavy jargon ('envelopes', 'settlement authority', 'host boundary') makes the purpose less immediately legible than it could be.

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 a precondition ('when settlement authority is supplied by the host boundary') and points at inbox.extend as the operation for adding increments while the inbox is active. That implies when this tool is appropriate and how it relates to a sibling, but there is no explicit when-not-to-use or routing between open_inbox and the other inbox tools, leaving usage largely inferred.

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 description adds non-obvious behavioral context: results are 'immutable', failures are returned as a 'typed refusal', exactly one 'invocation envelope' is accepted, and payment material is never accepted from model-authored arguments. Annotations already signal idempotent and non-destructive behavior; the description complements them without contradiction, though side effects of preparation are not described.

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 front-loaded sentences with no filler. The first sentence states the action, resource, and possible outcomes; the second adds a critical security constraint. 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?

For a tool with 9 parameters, 7 required fields, nested objects, and no parameter coverage in the description, the high-level purpose and one security rule are insufficient. The agent is left to infer how offers, revisions, digests, and the invocation envelope relate, as well as when preparation would be required.

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%, and the description names none of the nine parameters such as offer_id, offer_revision, digests, idempotency_key, or parent_binding. The phrase 'invocation envelope' and the payment-material restriction give only minimal input semantics, leaving required parameters largely 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?

The description uses a specific verb ('Validate') and a specific resource ('one exact invocation envelope'), and states the outcome ('immutable preparation terms or a typed refusal'). This clearly differentiates the tool from siblings like get_invocation, cancel_invocation, and search_offers, even without naming 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?

Usage is implied by the word 'prepare' and the action of validating an invocation envelope, but there is no explicit when-to-use guidance or comparison to alternatives. The payment-material restriction is a useful when-not, but the description does not say when this tool should be chosen over related invocation 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds 'without creating product or payment state,' which is essentially a restatement of read-only behavior, and mentions the return of 'stable offer identities and revision digests.' This adds a small amount of context about the output, but since an output schema exists, this information may already be captured there. The description does not contradict 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?

The description is a single, efficient sentence that front-loads the primary action and scope. It contains no redundant phrases and every clause adds value (purpose, method, and non-mutating guarantee). It is appropriately concise for a simple search 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?

The description covers the core purpose and read-only nature, and annotations provide the safety profile. However, it omits details about pagination (the cursor parameter) and the limit behavior, which are relevant for a search tool that likely returns multiple results. The output schema may describe the return format, but the description does not mention how to handle pagination or interpret the cursor. Given the tool's simplicity, this is an acceptable but not exhaustive level of completeness.

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 description coverage is 0% for q and limit, with only the cursor parameter having a schema description. The description itself does not explain any parameters; it only hints at the query parameter through 'free-text query.' It does not explain the limit default or the cursor's role in pagination. Since schema coverage is low, the description was expected to compensate but fails to do so, leaving parameter semantics largely undefined.

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 verb ('search'), a resource ('current immutable Ausca offer catalog'), and the method ('by free-text query'). It distinguishes this tool from siblings like ausca_get_offer (which retrieves a specific offer by ID) by focusing on query-based search. The phrase 'without creating product or payment state' reinforces its read-only scope, differentiating it from creation-oriented siblings.

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 implies usage: it is a search tool for finding offers, so an agent can infer when to use it. However, it does not explicitly state when to use this tool instead of alternatives (e.g., ausca_get_offer) or when not to use it. There is no mention of exclusions or alternative tool routing, so the guidance is only implied rather than explicit.

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