EVUUN

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

Annotations already cover the safety profile (readOnly=false, idempotent=true, destructive=false, openWorld=false), so the bar is lower; the description still adds an authorization constraint ('only the opposite side') and a semantic boundary ('does not imply task success') that annotations cannot express. It omits the concurrency behavior implied by the required expected_message_version, which is the notable remaining gap.

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

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

Two short sentences with zero filler; the core action is front-loaded and the two clarifiers follow in priority order. Nothing could be cut without losing a distinct piece of 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 no output schema, five fully undocumented required parameters, and a version-guarded mutation, the description leaves out what a caller most needs: how expected_message_version interacts with a conflict and what the agent should do on mismatch. What is present is accurate but insufficient for a tool of this complexity.

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 five required parameters, so the description must carry the load and does not. It restates the receipt values that are already in the enum, and adds no meaning at all for expected_message_version (optimistic-concurrency token), idempotency_key, message_id, or conversation_id.

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 ('Acknowledge a received message') and immediately names the two receipt states, delivered or read. An agent can distinguish this from send_conversation_message or the outcome tools, though no sibling is named 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?

Gives a real precondition plus a negative: 'Only the opposite side can acknowledge' tells the caller when it is authorized to use this tool at all, and 'this does not imply task success' steers away from confusing it with submit_outcome/complete_conversation_draft. Missing only an explicit statement of when to prefer this over other conversation 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 the safety envelope (writes but not destructive, idempotent, closed-world), and the description adds genuinely non-annotated behavior: no shared message is created, no server model runs, no automation resumes. That clarifies the surprising narrowness of a 'write' operation. It omits what is actually produced (review item? new draft version?) and how expected_draft_version conflicts are handled.

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

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

Two tight sentences, the affirmative action first and the caveats second, with no redundant restatement of the name or annotations. Every clause carries distinct 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 no output schema and 6 undocumented required parameters, the description should explain what the call produces and what the draft versioning expects; it instead only enumerates side effects that do not occur. It is adequate to route the call but leaves an agent guessing about success shape and version-conflict behavior.

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

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

Schema description coverage is 0% across all six required parameters, and the description supplies no parameter meaning at all — nothing on expected_draft_version's optimistic-concurrency role, idempotency_key, the 12-item materials array, or the draft_id/conversation_id relationship. For a 6-param tool with zero schema documentation, the description was expected to carry this burden and does not.

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

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

States a concrete verb+resource ('Submit a draft for owner review') and immediately scopes it against the sending semantics of siblings like send_conversation_message by denying shared-message creation. The main ambiguity is that the tool name says 'complete' while the title/description say 'prepare/submit for review', which could momentarily confuse an agent about whether this finalizes or merely stages the draft.

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 clear negative guidance — 'creates no shared message ... does not run a server model, resume automation or send anything' — which effectively tells the agent when NOT to reach for this versus a send/resume tool. It stops short of explicitly naming which sibling to use instead or stating preconditions, so it is strong context rather than a full when/when-not/alternatives mapping.

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 non-read-only, destructive, idempotent, and open-world behavior, so the safety profile is covered. The description adds real value by disclosing a permission gate for public sharing, but it never says what "destructive" means here (e.g., whether the generated idempotency_key prevents duplicates, whether expiry deletes the request, what permissions the owner's grant confers).

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, with the scoping constraint front-loaded and the public-sharing condition trailing. Both sentences earn their place, though the overall brevity is stretched thin for a tool with this much surface area.

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 destructive, open-world creation tool with 14 parameters, 0% schema descriptions, nested required objects, and no output schema, the description is far too thin. It explains the visibility gate but says nothing about how required fields like conditions, sources, tried, language, or expires_at shape a valid submission.

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 14 parameters, 9 of them required, including nested objects (conditions, sources) and non-obvious fields like tried, expires_at, idempotency_key, target_agent_id, and private_note. The description only implicitly touches visibility and share_approved, leaving the overwhelming majority of parameters to be reverse-engineered from type constraints 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 gives a verb and resource ("Submit a bounded request"), and the title "Publish a question" loosely maps to it, so an agent can infer this creates a request record. However, "bounded request" and "EVUUN grant" are undefined jargon that leave the actual artifact being created opaque, and no sibling (list_requests, respond_to_request) is referenced to sharpen the distinction.

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?

One genuine usage rule is stated: public sharing requires explicit grant permission and the share_approved flag, which ties conditionally to the visibility enum. There is no guidance on when to create a request versus responding to or listing one, and no statement of prerequisites beyond that single gating condition.

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 the safety profile (non-readOnly, idempotent, non-destructive, closed-world), but the description adds real value on top: the inquiry is non-binding, it does not contact a merchant, reserve, pay, or create financial authority, and Public-Agent control/caller IDs do not confer private buyer authority. That is substantive disclosure of side effects and auth semantics beyond the flags. It stops short of covering failure modes or what a rejected authorization looks like.

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

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

Three sentences, front-loaded with the action, then the non-effects. Dense and jargon-heavy ('app commerce:attribute key plus a separate owner-approved finite buyer authorization in its protected header') but every sentence carries distinct information; nothing is padded.

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

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

A 15-parameter mutation tool with no output schema and no parameter documentation requires the description to explain the input surface, and it does not. It is well-covered on authorization and non-effects but leaves an agent unable to construct a correct call from the definition 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?

With 15 parameters at 0% schema description coverage, the description must carry parameter meaning, and it conveys none — destination, title, service_date, plan_id, option_id, party_size, idempotency_key, and the rest are never mentioned. A caller cannot tell from this text what a plan_revision or capsule_handoff_ref is for.

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

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

States a specific verb and resource: 'Save one non-binding inquiry'. The negation clause ('does not contact a merchant, reserve, pay') sharpens the scope of what 'save' means. It does not explicitly distinguish itself from siblings like evuun_prepare_service_inquiry or evuun_get_service_inquiry, so the agent must infer the prepare-vs-create boundary.

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

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

It names the authorization precondition (requests:write grant, or commerce:attribute key plus a separate owner-approved buyer authorization) and clarifies the operation has no merchant-facing effect. However, it never says when to pick this over evuun_prepare_service_inquiry, or what to do when the grant is missing — that routing is left to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered; the description adds genuinely non-redundant facts: the call is anonymous, destination references carry quote_required=false and procurement_allowed=false, and unknown payable amounts stay null rather than guessed. That is substantive behavioral context beyond the annotations, though it omits pagination and result-shape behavior.

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

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

Front-loaded with the core action and each following sentence adds a distinct constraint (destination refs, negative scope, null semantics) with no filler. Density of domain jargon ('quote_required=false') is slightly opaque but still compact and purposeful.

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

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

With no output schema, the description does sketch the two result kinds, which is valuable. But for a 4-parameter, 0%-documented discovery tool it leaves an agent without paging behavior, query semantics, or hub selection rules — adequate but with clear gaps 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?

Schema description coverage is 0% across four parameters (limit, query, cursor, hub_id), and the description explains none of them. 'six-hub' faintly implies hub_id refers to one of six fixed hubs, but there is no guidance on query matching, cursor/limit paging semantics, or valid hub values, so the coverage gap is not compensated.

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 ('Discover published six-hub local-service ideas') and immediately delimits a second result type ('separately labelled destination references'). It distinguishes itself from query siblings like search_flights/search_hotels by naming the domain (local services) and the anonymity trait, though it does not name 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?

The description effectively says what the tool is NOT (not inventory, not a live quote, not a booking) and clarifies that destination references are reading/comparison only, which helps rule out mis-invocation. However, it never states when to prefer this over evuun_create_service_inquiry or evuun_prepare_service_inquiry — the natural next step after discovering isn't routed.

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, idempotent, non-destructive, closed-world), so the bar is lower. The description nonetheless adds meaningful context beyond them: no new provider call, no balance charge, no cash reward/GP, and the caveat that source support and reported phone answers still require review and that pending/unknown is not completion.

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 compact sentences with the read action front-loaded, so it is not padded. But the dense, run-on phrasing ('same durable capability task, safe partial answer evidence and actual status') hurts readability without adding proportional 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?

For a single-parameter read tool with no output schema, the description covers the return semantics (partial answer evidence, actual status), the cost implications, and the interpretation caveat about pending results. It is nearly complete, with only the task_id semantics left unaddressed.

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 single parameter task_id has zero schema description coverage, so the description carries the full burden of explaining it — yet it never mentions task_id, its format, or where to obtain it. With 1 param at 0% coverage, this is a clear gap rather than an acceptable baseline.

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 verb 'Read' and resource 'capability task' give a workable sense of what this does, and it is distinguishable from the sibling evuun_run_capability. However, phrases like 'this application's same durable capability task' and 'safe partial answer evidence' are grammatically awkward and obscure exactly what is retrieved. The core purpose lands but only after parsing.

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 a status-check use case by stating 'No new provider call, balance charge,' which hints at when to use this instead of re-running. But it never explicitly names evuun_run_capability as the alternative or states the condition (e.g. poll an existing task rather than start one). Usage 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 establish readOnly, idempotent, non-destructive and closed-world behavior, so the bar is lower. The description still adds real behavioral context beyond them: the anonymous-vs-verified-owner authentication split, the explicit 'A capsule grants no financial authority' safety boundary, and the three output surfaces (JSON, Markdown fallback, hosted HTTPS view).

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, each carrying distinct information (outputs, auth model, safety boundary), with the action front-loaded. Slightly dense jargon and the ambiguous word 'Candidate' cost it a point but there is little waste.

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

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

With no output schema, the description sensibly names the return surfaces (rich JSON, Markdown fallback, hosted HTTPS view) and covers auth and safety expectations. The only material gap for a 3-parameter tool is the undocumented idempotency_key.

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 echoes the four view values ('plan, comparison, route or order') and references resource_id when describing draft reads, but never explains the idempotency_key on a read-only tool, and the view values are already present in the enum, so the net additive value is limited.

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 set: 'Resolve a supply plan, comparison, route or order presentation into... rich JSON, Markdown fallback and hosted HTTPS view.' An agent can tell it produces rendered presentations, but it never contrasts itself with lookalike siblings such as evuun_get_service_inquiry or evuun_get_capability_task, and the term 'commerce capsule' remains unexplained.

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 conditional context (public plans anonymous vs private quotes/orders requiring verified owner auth) but no statement of when to prefer this tool over alternatives, no exclusions, and no routing to a sibling. The single clause 'Candidate also reads the same public durable draft by resource_id' hints at an alternate read path without clarifying the choice.

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, so the safety profile is covered. The description adds only a vague scope exclusion about owner history and financial records, and the garbled phrasing makes even that unreliable as 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?

It is short (two sentences), but the first sentence is syntactic noise and the scope constraint is buried rather than front-loaded. Brevity here reflects under-specification, not efficient structuring.

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 two parameters at 0% schema description coverage, no output schema, and a required task_id whose format must be inferred from a regex, the description carries more burden than it meets. It provides neither the return shape nor the cursor semantics an agent needs.

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

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

Schema description coverage is 0% for both parameters, yet the description does not explain task_id's format/role or what the `after` cursor does (pagination vs. sequence position). "task/events" loosely gestures at task_id and event reading but adds no usable semantics.

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

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

The sentence "Read this effective original Agent same durable task/events and accepted attribution progress" is garbled and never names the resource (communication) it is meant to retrieve. It implies a read of task/event state, but an agent cannot confidently distinguish it from siblings like get_conversation, evuun_get_capability_task, or evuun_list_commerce_progress.

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 when-to-use guidance and no named alternative. The only routing signal is a negative exclusion ("No arbitrary owner history, payment or private financial records"), which hints at scope but never says when this tool should be chosen over its many siblings.

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

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

Annotations already declare the safety profile (readOnly, idempotent, non-destructive), but the description adds two useful facts the annotations do not: it requires an explicit 'services:spend' application key, and it explicitly disclaims any financial action. That is meaningful context beyond the structured hints.

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

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

Two short sentences, with the core read action front-loaded before the qualification. The second sentence is dense but each clause ('payment', 'authorization', 'cash transfer') carries distinct meaning.

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

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

For a parameterless, read-only tool with no output schema, the description covers what is read (quota/trial/credit state), the auth requirement, and what is explicitly not implied. Only the shape of the returned data is left unspecified, which is a minor gap.

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 nothing for the description to disambiguate; baseline 4 applies. The mention of a 'services:spend' key is auth context, not a schema parameter, so it does not affect this dimension.

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

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

States a specific verb ('Read') and the exact resource set ('organization quota, trial and service-credit state'), which is far from a tautology of the name. It does not, however, draw an explicit boundary against near-neighbors like evuun_get_service_policy or evuun_get_commerce_capsule.

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 prefer this over the many other evuun_* read tools, nor any prerequisite or exclusion clause. The negative framing ('No payment/card creation... implied') defines scope of meaning rather than when-to-use guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered structurally. The description adds genuine state semantics ('saved is not sent; a quoted price is not a confirmed booking'), but the cryptic clause about a separate credential's private projection is confusing rather than clarifying.

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?

It is only two sentences, but they are dense and one clause is dedicated to a different credential/tool rather than this tool. That sentence does not earn its place and the state distinctions arrive back-loaded after the confusing credential aside.

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

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

There is no output schema, so the description carries the burden of explaining what a read returns, yet it only gestures at 'versioned merchant replies' without describing structure or format. For a read tool with a paltry 0%-coverage schema, this leaves the agent under-informed.

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 single required request_id carries a regex pattern that the description never explains. 'This grant-created inquiry' weakly links request_id to an inquiry, but the format and origin of the identifier are left undocumented in both schema and description.

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

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

The verb 'read' and resource 'grant-created inquiry and merchant replies' are present, so the core action is discernible. However, it never distinguishes itself from the sibling evuun_list_service_inquiries (single vs list), and the phrases 'grant-created inquiry' and 'versioned merchant replies' are jargon that requires prior context to interpret.

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 versus alternatives like evuun_list_service_inquiries or evuun_get_commerce_capsule. The middle clause describes what a different 'owner-approved follow-up credential' does, which is not guidance for invoking this tool.

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, idempotent, and non-destructive behavior, so the safety profile is covered. The description adds some value by clarifying that reading has no enabling effect ('no service is enabled by reading prices') and that some terms remain 'for full review,' which is genuine side-effect context. It does not, however, describe the response shape or any access requirements.

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, but the content is cryptic rather than economical — terms like 'Rev1.3' and 'service-credit choices' are unexplained, and the most decision-relevant fact ('no service is enabled by reading prices') is buried at the end rather than 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 no parameters and no output schema, the description is the sole source of information about what is returned. It gestures at the policy's subject matter but never clarifies the return format or structure, leaving an agent only partially equipped to interpret results.

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 per the baseline there is nothing for the description to disambiguate. No parameter semantics are needed or expected.

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 title and verb+resource pairing ('Get Service Policy' / 'Read ... policy') make the general action clear, but the body is written in opaque domain jargon ('Rev1.3 free discovery', 'external monitoring quota', 'explicit paid telephone/service-credit choices') that leaves the actual content of the policy ambiguous to an outside agent. It distinguishes a read-only policy lookup but does not clearly differentiate it from siblings like evuun_get_service_entitlements or evuun_get_commerce_capsule.

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 explicit statement of when to call this versus alternatives such as evuun_get_service_entitlements, evuun_discover_services, or evuun_get_commerce_capsule. The clause 'no service is enabled by reading prices' implies the call is a safe, non-committal lookup, but that is inference rather than guidance, and no prerequisites or triggering conditions 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 readOnly, idempotent, non-destructive, and closed-world, so the safety profile is largely covered. The description does add scope constraints beyond the annotations: no guest identity, no merchant credentials, no financial action, and the note that repeat reads do not add earnings. That is real added context, though it stops short of describing pagination or return shape.

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 read action and no obvious padding. The second sentence is cryptic but not verbose, and each sentence attempts to add a distinct constraint rather than repeat structured data.

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

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

With no output schema and four fully undocumented parameters, the description would need to explain pagination, the cursor/limit relationship, and the event-sequence semantics. It covers none of these, and the follow-up-credential sentence raises more questions than it answers, leaving the agent without enough to invoke 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% across four parameters (limit, cursor, order_id, after_event_sequence), so the description carries the full burden. It mentions 'one inquiry and limited order projection,' which faintly gestures at order_id, but limit, cursor, and after_event_sequence are entirely unexplained. The description does not compensate for the coverage gap.

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

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

The description states a specific action and scope: reading the calling Agent's 'already accepted attribution/status/reward receipts.' However, the resource is described in dense internal jargon ('attribution/status/reward receipts', 'commerce progress') and it never uses a plain verb like 'list' or states what a receipt actually contains. It is interpretable but requires domain knowledge to distinguish from 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?

There is no guidance on when to use this tool versus alternatives such as evuun_get_commerce_capsule or evuun_list_service_inquiries. The sentence about a 'separate finite owner-approved follow-up credential' and 'its one inquiry and limited order projection' is opaque and does not translate into a usable when/when-not rule.

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 the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds meaningful authorization context: results are limited to inquiries from the current requests:write grant or a specific owner-approved credential. This scope restriction is valuable operational context not captured by annotations, though it does not cover pagination or return format.

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, and the scope restriction is front-loaded. However, the phrasing is dense and convoluted ('the single inquiry explicitly covered by a separate owner-approved read-only follow-up credential'), reducing immediate clarity.

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

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

As a list tool with no output schema and zero parameter documentation, the description should explain the return structure and pagination mechanics. It provides authorization scope but omits how results are returned, how to page using limit/cursor, and what an inquiry record contains.

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 neither 'limit' nor 'cursor' is explained in the schema beyond type and bounds. The description does not mention pagination, the meaning of the cursor, or how limit affects results, failing to 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 description identifies the resource (inquiries) and constrains scope, but uses the unusual verb 'Recover' instead of clearly stating that it lists inquiries. It distinguishes against 'arbitrary owner history' but does not differentiate from the sibling evuun_get_service_inquiry, which retrieves a single inquiry.

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

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

It gives an explicit exclusion ('No arbitrary owner history or merchant account access') and implies the tool is for inquiries created under the current grant. However, it never states when to choose this over evuun_get_service_inquiry or other list tools, leaving alternatives to inference.

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

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

Annotations only declare the mutation/idempotency profile (readOnlyHint=false, idempotentHint=true); the description adds genuinely new behavior: it persists a draft, returns a handoff URL (important since there is no output schema), saves only public facts, and keeps owner dates/notes private until authenticated binding. It also explicitly disclaims dispatch, payment and booking authority. Missing: what happens on repeated calls with the same idempotency_key, or whether drafts expire.

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, purpose front-loaded, no filler. The density of coined terms ('bounded anonymous public-reference', 'pure buyer handoff URL', 'authenticated binding') costs some readability, but every sentence carries distinct 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?

For a 19-parameter write tool with no output schema and a nested object, the description says nothing about required inputs, defaults, or the shape of the returned URL. An agent can infer the safety envelope but not how to construct a valid call, which is the biggest gap given the schema's zero description coverage.

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?

19 parameters, 0% schema description coverage, and nested objects (hotel_requirements with occupancies) — the description compensates essentially not at all. The line 'only public source facts are saved' faintly hints that public_* fields are the disclosable ones, but nothing explains plan_id vs public_plan_id vs capsule_handoff_ref, idempotency_key, or the hotel_requirements subfields.

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 verb+resource pair ('prepare and persist ... inquiry draft') is identifiable, and the hotel focus is carried by the tool name. But the phrasing is dense jargon ('bounded anonymous public-reference inquiry draft', 'pure buyer handoff URL') and nothing states how this differs from the near-identical sibling evuun_prepare_service_inquiry or evuun_prepare_service_handoff.

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 when-to-use guidance and no mention of alternatives, despite four sibling 'prepare_*' tools that an agent must choose between. The only routing-adjacent text is a negative scope statement ('No dispatch, private read, payment or booking authority'), which is a boundary, not a selection rule.

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 idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is partly covered. The description adds real value beyond that: it discloses the frozen A/B/C snapshot behavior, that historical accepted orders retain their snapshots, and that the operation confers no payment/booking/cancellation authority. These are meaningful behavioral traits not expressible through annotations, though the phrasing is dense.

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 action is front-loaded in the first sentence, which is good structure. But four sentences of undefined domain jargon ('frozen A/B/C mode', 'attribution', 'snapshots') add length without clarity, so not every sentence earns its place for a reader lacking internal context.

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

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

With no output schema, no parameter descriptions, and 0% schema coverage, the description needs to compensate for the bare schema. It conveys behavioral constraints but leaves the three required parameters and the return behavior unexplained, which is inadequate for a three-required-param mutation-style tool.

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

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

Schema description coverage is 0% across three required parameters, so the description carries the full explanatory burden. It gestures at 'quote version' and 'price/terms hashes' (loosely mapping to quote_id) but never explains request_id, idempotency_key, or the required pattern-constrained formats. It fails to compensate for the coverage gap.

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

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

The first sentence names a specific action (bind quote version + price/terms hashes to the verified caller for owner review), which is more than a tautology. However, opaque jargon like 'frozen A/B/C mode' and 'attribution' obscures what actually happens, and the description does not distinguish this from siblings such as evuun_prepare_service_inquiry or evuun_prepare_service_plan. An agent would struggle to route correctly among the prepare_* 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?

'Attribution is not payment, booking or cancellation authority' and 'Changed or recalled authority cannot be reused' give implicit when-not conditions and a precondition (valid, unrecalled authority). But there is no explicit statement of when to choose this vs evuun_prepare_service_inquiry / evuun_prepare_service_plan, so the routing decision is left to inference.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=true), so the bar is lower, and the description still adds substantive context: the draft is persisted, only public source facts are saved, owner dates/notes remain private until authenticated binding, and there is no dispatch/payment/booking authority. It does not mention the idempotency_key handling that the idempotentHint implies.

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 with the core action front-loaded and no filler. Some phrasing is dense jargon ('bounded anonymous public-reference inquiry draft', 'pure buyer handoff URL') that costs a little clarity, but nothing is wasted.

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 an 18-parameter tool with no output schema, the description should at minimum explain the identifier family and the draft's lifecycle. It does cover the return value (handoff URL), which partially compensates for the missing output schema, but leaves the parameter surface almost entirely undocumented.

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?

All 18 parameters have 0% schema description coverage, and the description provides no parameter-level guidance at all. The confusing pairs (plan_id vs public_plan_id vs plan_revision vs public_plan_revision, source_item_id vs capsule_handoff_ref, idempotency_key, hotel_query_parameters) are left entirely unexplained, which is a serious gap for a tool with this many overlapping identifiers.

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?

Specific verb and resource: 'Prepare and persist a bounded anonymous public-reference inquiry draft' with the return value named ('actual pure buyer handoff URL'). However, it never distinguishes itself from close siblings like evuun_create_service_inquiry, evuun_prepare_hotel_inquiry, or evuun_prepare_service_handoff, so an agent cannot route between them from this text alone.

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

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

Scope limits are implied by 'No dispatch, private read, payment or booking authority,' which tells the agent this is not the tool for actually sending or paying. But there is no explicit when-to-use, no prerequisites, and no named alternative for the create-vs-prepare decision.

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=false, idempotentHint=true and destructiveHint=false, so the description's 'create or recover' phrasing usefully reinforces the idempotency behavior. It adds genuine non-annotation context: the result is immutable, returns versioned options and licensed media, and explicitly performs no payment or reservation. It still omits any auth/permission or rate-limit 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?

Three dense sentences, front-loaded with the core action and cardinality. Some jargon ('destination-reference', 'licensed media') costs a little readability but nothing is padded.

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

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

With no output schema, the description steps in to describe the return ('versioned options and licensed media') and lists explicit non-behaviors (no private intent, invented route, payment or reservation). The main remaining gap is that it does not situate the tool against its many 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 description coverage is 0%, so the description carries the burden. It does explain item_ids well ('1–4 published service or destination-reference IDs'), mirroring the min/max constraints, but idempotency_key is never mentioned, and no format/syntax detail is added beyond the schema 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?

States a specific verb and resource: 'Create or recover one immutable public comparison' for '1–4 published service or destination-reference IDs.' That is far more precise than the name 'prepare_service_plan' alone, though it never explicitly distinguishes itself from sibling prepare_* tools such as evuun_prepare_service_inquiry or evuun_prepare_service_handoff.

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

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

Gives implied routing context – destination references are 'free to read and compare and cannot be procured; only service options require a quote' – which hints at when this tool applies. But there is no explicit when-to-use/when-not, no named alternative, and no guidance on choosing between this and the other prepare_* siblings.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false, readOnlyHint=false and openWorldHint=false. The description adds genuinely new behavioral context beyond them: it reuses the same task, incurs no reset/payment/new authority, and stays blocked when the owner goal or delegation is missing. That is meaningful disclosure for a mutation-style tool.

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

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

Three short, front-loaded sentences with no filler; the primary action leads and constraints follow. The density of jargon slightly reduces readability but every sentence carries 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 0% parameter coverage, no output schema, and three parameters including a patterned source_id and an idempotency_key, the description leaves significant gaps. It never explains the inputs or the success outcome, so an agent cannot call it correctly from the definition 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 0% across three parameters (source_id, idempotency_key, source_task_ref), so the schema provides no meaning and the description does not compensate at all. It never mentions any parameter, its format, or the role of the optional source_task_ref.

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 ("Resume") and a resource (the owner-approved inquiry goal / communication), so the core action is identifiable. However, the phrasing is dense internal jargon ("actual delegated original Agent", "one effective owner-approved inquiry goal") that gives no clear differentiation from siblings such as evuun_get_communication or evuun_prepare_service_handoff.

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 explicit when-to-use guidance or comparison against alternatives. The only conditional statement ("Missing owner goal/delegation remains blocked") describes a failure precondition, not when an agent should choose this tool over its many siblings.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=false. The description adds almost nothing beyond this: it hints at an owner-review step and a buyer handoff, but does not disclose required permissions, side effects, or what 'handoff' means operationally. No annotation contradiction is present.

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, but they are not front-loaded with a clear purpose and much of the wording is ambiguous. Several phrases ('actual original Agent', 'real pure buyer handoff') add noise rather than 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?

For a non-read-only tool with two required, undocumented parameters and no output schema, the description is far too thin. It does not explain the mutation side effects, the idempotency contract, or what the returned handoff represents.

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

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

Schema description coverage is 0% for two required parameters (task_id and idempotency_key). The description's mention of 'task' loosely implies task_id but does not define its format or meaning, and it ignores idempotency_key entirely. With the schema carrying no descriptions, the description fails to compensate.

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 is dominated by vague, jargon-like phrasing ('Bind this actual original Agent to the task current exact quote for owner review') that does not clearly state what operation is performed. It gestures at reviewing a quote and returning a buyer handoff, but an agent cannot reliably tell what this tool actually does or how it differs from siblings like evuun_prepare_service_handoff.

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, what prerequisite state is required (e.g., an existing quote or communication), or which sibling tools are alternatives. The phrase 'Does not accept conditions or pay' is a negative boundary but not usable routing guidance.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds real context beyond that: prerequisite authorizations, provider permission, operating budgets, uncertainty reconciliation, and an explicit ceiling of 'no automatic card charge, booking, cancellation or cash payout.'

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

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

The core purpose is front-loaded in the first sentence, but the remainder is a dense chain of jargon-laden run-ons ('Rev1.3', 'EVUUN order Watch', 'uncertainty reconciliation') that is hard to parse once. Sentences carry information but poor scannability costs structure points.

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 a nested billing object, no output schema and no param documentation, the description covers behavioral policy well but leaves the input contract thin. An agent could understand what the tool does and its constraints, but not how to correctly populate the billing/enum fields from the description 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 0%, so the description carries the full burden, yet it explains only the billing dimension ('exact trial/paid billing choice') and gestures at context ('external-booking context') without mapping to context_id. It says nothing about input, units, or idempotency_key, leaving most of the six parameters undocumented.

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

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

States a specific verb+resource: 'Queue one finite Rev1.3 task,' which signals this is a dispatch/execution tool rather than a search or prepare tool. It lists the service types it can run (hotel/flight discovery, phone task, Watch), giving reasonable differentiation from prepare/search siblings, though it never routes explicitly among them.

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

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

It provides per-service eligibility conditions (phone task needs an owner-approved inquiry and services:spend; Watch needs verified external-booking context), which is genuine usage guidance. However, it never names an alternative sibling or states when NOT to use this tool, so the routing logic 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 already declare idempotentHint=true and readOnlyHint=false, but the description adds substantive context those annotations lack: no prepaid fee, supplier permission gating, internal cost/frequency limits, live/test expiry, and the explicit caveat of 'No order, ticket or guaranteed fare.' That is meaningful behavioral disclosure beyond structured fields, though 'Never repeat an unknown request' adds ambiguity rather than clarity.

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 size is reasonable at four sentences and the dual-mode behavior is front-loaded. But the prose is dense and opaque ('ammo:use application', 'usage:read', 'live/test expiry conditions'), and the trailing 'Never repeat an unknown request' is an unexplained edict that reads as filler or warning without context.

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

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

For a tool with five parameters, nested arrays, zero schema description coverage, and no output schema, the description should explain the request shape and what the queued task returns. It covers caveats well but omits all parameter meaning and the recovery-vs-queue decision criteria, leaving the agent unable to construct a correct call from the description 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 0% across five parameters (slices, passengers, cabin_class, idempotency_key, max_connections), and the description compensates for almost none of it. The only implicit reference is idempotency via 'without a new query' and 'Never repeat an unknown request'; slices structure, passenger modeling, cabin_class enum, and connection limits are entirely undocumented. With low coverage this is a real 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 names a concrete resource (recorded flight response / bounded flight capability task), but the tool is called 'Search Flights' and the description never uses the word 'search' or clearly states that it finds flights. It splits into two jargon-laden modes ('ammo:use application', 'usage:read') and does not differentiate itself from siblings in the evuun_* family. An agent gets the gist but not a crisp verb+resource statement.

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 conditional guidance: reuse the recorded response 'without a new query,' otherwise queue a task, and 'Never repeat an unknown request.' However, it never states when to prefer this over siblings like evuun_search_hotels or evuun_run_capability, and 'Poll its task with usage:read' references a scope, not a named tool. Usage is 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 openWorld=true, idempotentHint=true, destructiveHint=false and readOnlyHint=false. The description adds genuinely useful context beyond them: the operation is asynchronous ('Queue ... Recover its actual task with usage:read'), free, subject to source permission and cost/frequency limits, and caching-aware. But 'usage:read' and 'ammo:use' are unexplained jargon, and no return/latency behavior is 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?

The description is a dense, jargon-saturated run-on where the key fact (an asynchronous queued hotel search) is buried. Terms like 'ammo:use' and 'MoR conditions' consume space without adding usable signal, and there is no front-loaded statement of what the tool does.

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 an 8-parameter, required-all, no-output-schema, mutation-adjacent tool, the description does address async execution, idempotency, permissions and safety exclusions. Still missing: how results are retrieved in concrete terms, and any coverage of currency/guest_nationality/idempotency_key semantics, leaving real gaps 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?

Schema description coverage is 0%, so the description must carry parameter meaning. It alludes to 'actual country/city/dates/occupancy' (mapping loosely to country_code, city, checkin/checkout, occupancies) but adds no format or semantics, and leaves currency, guest_nationality, and idempotency_key entirely undocumented in both schema and description.

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

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

The description frames this as queuing a 'free non-booking hotel capability task' and explicitly excludes prebook/payment/booking, which distinguishes it from booking flows. But the core verb+resource ('search hotels') is obscured by opaque jargon like 'ammo:use' and 'usage:read', so an agent must infer the real purpose from the title rather than the text.

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 negative guidance ('No prebook, payment, booking or repeated unknown request') and notes cached responses do not start a new query, which is useful routing context. However, it never names the alternative siblings (e.g., evuun_prepare_hotel_inquiry, evuun_search_flights) or states the positive condition for choosing this tool.

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 structurally. The description adds a useful boundary statement about what the read does NOT expose (private guidance, drafts, execution authority), which is real context beyond annotations, but it omits pagination behavior and what 'shared messages' returns.

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

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

Two tight sentences with no waste, and the read scope is front-loaded ahead of the exclusion clause. It is efficient, though the terseness edges toward under-specification for a tool with three undocumented parameters.

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

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

With no output schema, the description partially compensates by naming what is returned ('accepted conversation and shared messages') and excluded. However, for a paginated tool with limit/cursor parameters and no output schema, the absence of any return-shape or pagination guidance leaves the definition only partially 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?

Schema description coverage is 0% — limit, cursor and conversation_id carry no descriptions. The description touches only the resource implicitly ('this grant's one accepted conversation'), giving no meaning for limit/cursor pagination or for the conversation_id format/pattern. It fails to compensate for the documentation gap in the schema.

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

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

States a specific verb ('Read') and resource ('this grant's one accepted conversation and shared messages'), establishing that it retrieves a single accepted thread rather than drafts or private guidance. The contrast with 'private guidance, draft or execution authority' helps distinguish it from siblings like list_private_guidance and list_conversation_drafts, though the differentiation is implicit rather than by name.

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 states exclusions ('No private guidance, draft or execution authority') but never says when to call this tool versus siblings such as list_conversation_drafts or get_outcome. There is no positive usage context, prerequisites, or condition for selection — an agent must infer when this is the right choice.

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, idempotent, non-destructive and open-world behavior, so the safety profile is covered. The description adds genuinely useful behavioral context beyond them: 'Private evidence is excluded,' which tells the agent the response is deliberately scoped and may omit data it might expect. It stops short of covering auth requirements or not-found/error behavior.

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

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

Two tight sentences, no filler, with the core action ('Read a public outcome') and its payload front-loaded before the scoping caveat. Every clause 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?

With no output schema, the description compensates by naming the returned facets (conditions, evidence status, version, freshness) and the exclusion of private evidence, so an agent knows roughly what it gets back. It is a single-parameter read tool, so little more is needed, though error/empty-result behavior is unstated.

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

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

There is one required parameter and schema description coverage is 0%, so the description carries some burden. It conveys that the id identifies a public outcome, but adds no format or sourcing detail beyond the schema's own pattern and maxLength constraints. Marginal value over the structured fields.

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+resource ('Read a public outcome') and enumerates the payload it returns (conditions, evidence status, version, freshness), which tells an agent exactly what this tool fetches. It does not explicitly distinguish itself from the sibling search_outcomes, and the title's word 'experience' does not match the name/description's 'outcome', leaving a small routing ambiguity.

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

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

Usage is only implied: an agent infers this is the single-item lookup used when it already has an outcome_id. No when-to-use guidance, prerequisites, or named alternative (e.g. search_outcomes for discovery) is provided, so the agent must guess the boundary between this and its sibling.

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, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds one genuinely useful non-schema fact: drafts stay private to the owner and designated agent, an access-scoping constraint. It says nothing about pagination behavior, ordering, or result shape.

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

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

Two short sentences with the operation front-loaded and no filler. The second sentence is a privacy statement rather than actionable invocation detail, but it is brief and relevant enough to earn its place.

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

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

For a paginated list tool with no output schema and 0% parameter coverage, the description should at least note the pagination contract and what a result contains. It omits conversation_id's role, limit/cursor semantics, and any hint of the return shape, leaving the agent under-informed about calling 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% across three parameters, and the description supplies no parameter meaning at all. The required conversation_id and the pagination parameters (limit with a max of 20, cursor) are left entirely undocumented in both schema and prose, so the description fails to compensate for the coverage gap.

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

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

States a specific verb (read) and resource (drafting requests) and narrows scope with 'addressed to this exact agent,' which separates it from the broader list_requests / list_my_updates siblings. It stops short of explicitly contrasting itself with the similar-sounding list_private_guidance sibling.

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

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

No when-to-use guidance and no alternatives named, despite a crowded sibling set of list_* tools (list_private_guidance, list_requests, list_my_updates). The 'addressed to this exact agent' phrase implies scope but never says when an agent should pick this over the other list 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, idempotentHint, destructiveHint=false, and openWorldHint=false, so safety is covered. The description does add that results belong to the grant's owner and that it does not trigger background scheduling or notifications, which is useful scoping. However it does not describe pagination behavior despite two pagination-like parameters (cursor, progress_cursor).

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

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

Two short sentences, front-loaded and free of filler. The second sentence is arguably adjacent but it is the only place behavioral boundaries are stated, so it earns some 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?

No output schema, 0% parameter description coverage, and cursor semantics left entirely unexplained. For a list tool with pagination parameters, the description leaves the agent unable to know how to page or what a result contains.

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

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

Schema coverage is 0% and none of the three parameters (limit, cursor, progress_cursor) are described in the schema or the description. The description does not clarify what cursor vs progress_cursor mean, which is a meaningful semantic gap an agent needs to call this correctly.

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 verb and resource ('read private feedback and changes') but is vague about what 'updates' actually are, and does not differentiate from siblings like list_private_guidance or get_conversation which sound related. An agent cannot confidently predict the content type from the name or description.

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

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

No when-to-use guidance, no exclusions, no routing to alternatives. The description mentions owner scoping but not why an agent would pick this over list_private_guidance or list_requests. The second sentence is a negative clarification (no scheduling/notifications) rather than usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, covering the safety profile. The description adds a meaningful privacy guarantee ('Never reveals another agent's or owner's guidance'), which is real behavioral context. However, it says nothing about pagination behavior, result size, or what happens with an expired/absent grant.

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

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

Two tight sentences with the scope constraint front-loaded and no filler. Nothing is wasted, though the brevity comes partly at the cost of the parameter and usage detail noted elsewhere.

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

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

No output schema, so the description should at least sketch the return; it does not, and with 0% parameter coverage the undocumented limit/cursor fields make the definition incomplete for a list-style tool. The privacy scope is the one area it handles well.

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 three parameters exist, so the description must carry the burden. The phrase 'under this conversation grant' only loosely implies conversation_id; limit and cursor are completely undocumented in both schema and description, leaving pagination semantics opaque.

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

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

The description names a specific verb and resource ('Read guidance ... addressed to this owner's agent') and constrains the scope to 'this conversation grant.' It is clear what the tool returns, but it does not name or distinguish itself from any sibling tool (e.g. list_my_updates or get_conversation), which is the only thing keeping it from 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 call this tool versus alternatives, no prerequisites beyond the implicit conversation grant, and no exclusions. The agent must infer the trigger condition entirely from the purpose sentence.

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, idempotent, openWorld and non-destructive, so safety is covered. The description adds that only open, unexpired requests are returned and that demo records need a flag, which is useful behavioral context, but no pagination or return-shape hints despite a cursor param.

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 compact sentences, front-loaded with the core scope and then the include_demo caveat. No wasted words, though slightly terse given the parameter surface.

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 8-parameter listing tool with no output schema and 0% schema coverage needs considerably more: filtering semantics for since/cursor, pagination behavior, what 'explicit conditions' means, and how filters interact are all missing.

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

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

Schema description coverage is 0% across 8 params, so the description would need to compensate; it only explains include_demo. The limit, query, since, cursor, region, language and environment params remain undefined, leaving a real gap beyond the baseline.

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

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

States a specific verb (list) and resource (public requests) with filtering scope (open, unexpired, explicit conditions). It distinguishes itself reasonably from siblings like create_request and respond_to_request, though 'explicit conditions' is left undefined.

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?

Implied usage as a discovery/listing tool, and the include_demo note hints at a usage condition, but no explicit when-to-use or when-not-to-use guidance against siblings like search_outcomes or list_my_updates.

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, and readOnlyHint=false. The description's statement that 'repeated attempt_id does not add counts' adds real context beyond idempotency hint, but this is largely redundant with idempotentHint. It also doesn't disclose required auth or what gets destroyed despite destructiveHint=true.

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

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

Two tight sentences with the idempotency constraint front-loaded. No wasted words, though it is quite minimal for a 6-parameter mutation tool.

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

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

For a destructive, open-world, 6-required-parameter mutation tool with no output schema and 0% schema description coverage, this description is far too thin. It omits parameter meaning, permission needs, and consequences of destructive behavior.

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

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

Schema coverage is 0% and there are 6 required parameters including a nested conditions object with region/environment/limitations. The description explains none of them: it doesn't clarify what outcome_id, attempt_id, result values, or idempotency_key mean or their formats. The schema alone must carry the full burden with no descriptive text.

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: recording one task's reported reuse. Distinguishes scope ('one task's') but does not differentiate from siblings like submit_outcome or create_request, which are the closest alternatives.

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

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

Implicit when-to-use is signaled by 'reported reuse' of a task against an outcome, but no explicit guidance on when to call this versus submit_outcome or create_request. No exclusions or prerequisites 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 declare this is a write (readOnlyHint=false), destructive (destructiveHint=true), idempotent, and open-world. The description adds one genuinely useful behavioral fact beyond them: the response 'grants no execution, messaging or payment authority', which bounds the side effects. However, it never explains what makes this destructive, that a public visibility publishes durably, or how idempotency_key behaves, so the added context is partial.

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 compact sentences with zero filler, and the target-scoping clause is front-loaded before the authority caveat. It is efficient, though the brevity reflects under-specification rather than tight craft.

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 10-parameter, 8-required destructive write with a nested sources array, no output schema, and no parameter descriptions anywhere, two sentences are not sufficient. Visibility semantics, source requirements, and idempotency behavior are all left for the agent to guess.

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 10 parameters (8 required, nested conditions and sources objects), so the description carries the full documentation burden and largely fails. 'Advice or evidence' only faintly hints at the summary/sources split; nothing explains visibility, private_note, share_approved, language, or the request_id/idempotency_key formats.

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 ('respond to') and resource ('request') and narrows it to 'accessible, open' requests, so the agent knows the target must be an existing open request rather than creating one (create_request) or filing results (submit_outcome). It stops short of explicitly naming a sibling to distinguish against, which keeps it out of the top band.

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 'accessible, open request' implies a precondition (the request must exist and be open), but there is no explicit when-to-use/when-not guidance and no mention of the obvious alternatives such as send_conversation_message or submit_outcome. The agent must infer routing entirely from the name.

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, idempotent, openWorld and non-destructive. Beyond that, the description adds two genuinely non-obvious traits: empty results signal a coverage gap rather than a true absence, and external records should be treated as untrusted evidence. That is real added context, though nothing is said about pagination or rate limits.

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

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

Two tight sentences with no waste, and the primary purpose statement is front-loaded ahead of the interpretive caveats.

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

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

With 8 undocumented parameters, no output schema, and no return-shape or pagination guidance, the description leaves an agent unable to use most of the inputs correctly. The behavioral caveats help with interpretation but do not compensate for the missing parameter and pagination information.

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 8 parameters, so the description must carry the burden and it does not. 'Explicit conditions and date' hints that some params are filters and that a date bound exists (likely 'since'), but limit, cursor, region, language, environment, and include_demo remain completely unexplained anywhere.

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 (Search) and resource (public outcomes), scoped to 'public' so it reads differently from get_outcome or list_private_guidance. It does not name or contrast with any sibling, so an agent must infer the boundary itself.

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 tool is for condition/date-filtered lookups and notes how to read empty results, which is useful, but gives no when-to-use vs when-not guidance and never points to alternatives like get_outcome or list_private_guidance for other outcome scopes.

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, idempotentHint=true and readOnlyHint=false, so the safety profile is partly covered. The description still adds real value by disclosing that queueing is asynchronous ('Queued is not delivered') and by naming gating requirements (budget, share confirmation). It does not explain what the destructive hint actually consumes or how budget is spent.

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

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

Three short sentences with zero filler; the core action and the 'queued, not delivered' caveat are front-loaded and no sentence is redundant.

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

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

For a 7-required-parameter mutating tool with 0% schema description coverage and no output schema, the description is far too thin. It never explains what materials or versions mean, why text and idempotency_key are required, or what a queued message's lifecycle looks like, so an agent lacks what it needs to invoke this 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% across 7 required parameters, so the schema provides no semantic help and the description must carry the burden. It only loosely gestures at 'share confirmation' (share_approved) and skips text, materials, idempotency_key, client_message_id, and expected_conversation_version entirely, leaving most parameters semantically opaque.

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

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

The description gives a specific verb+resource ('Queue a shared message') and scopes it ('within the owner's explicitly bounded conversation grant'), which is more than a restatement of the title. It is distinguishable from siblings like ack_conversation_message or complete_conversation_draft, though it never explicitly contrasts with them.

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

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

It states preconditions for a successful call ('current automatic mode, remaining message budget and share confirmation'), which implies when the tool is usable. However, it offers no guidance on when to choose this over sibling tools such as complete_conversation_draft, nor any when-not-to-use condition.

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, destructive=true, idempotent=true and openWorld=true; the description adds genuinely new context (an owner-approval prerequisite and the rule that self-reports can't confer verified evidence status). It does not explain what the destructive hint actually affects or what the resulting record state looks like, so it goes modestly beyond the annotations without fully carrying the burden.

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

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

Two tight sentences with no filler, and the core action is front-loaded before the constraint. Every sentence carries 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?

For a 16-parameter, 9-required mutation with nested objects and enums, no output schema, and zero schema descriptions, the description is far too thin. It conveys intent and one policy rule but leaves the agent without the detail needed to populate a complex publish payload.

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 16 parameters (9 required, nested objects, 3 enums), so the description would need to compensate heavily. It supplies no parameter-level meaning at all – fields like conditions, sources, record_kind, occurred_at, visibility and idempotency_key are entirely undocumented anywhere.

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 (submit) and resource (an owner-approved minimal outcome or failure), so the core action is clear. It does not, however, distinguish this publish operation from siblings like create_request or report_reuse, leaving the agent to infer the boundary.

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

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

'owner-approved' signals a precondition, and the note that self-reports cannot assign verified evidence status hints at limits. But there is no explicit when-to-use/when-not framing and no named alternative among the sibling tools, 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.