MUJ428 Trust Layer — VERIFY BEFORE ACT

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

With no annotations provided, the description bears the full burden of disclosing behavior. It adds a useful caveat that SELF_ATTESTED_UNVERIFIED entries are discovery leads only, but it does not disclose return format, pagination, filtering semantics, required authentication, or whether this is purely read-only. The 'search' wording implies read behavior, but details are missing.

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

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

Two sentences with no filler. The core action and subject are front-loaded in the first sentence, and the second sentence adds an important data-quality caveat. Every word earns its place.

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

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

The tool is relatively simple with two optional parameters and no output schema. The description names the directory and types of capabilities and flags an important trust caveat, but it lacks parameter semantics and usage guidance needed to fully understand result filtering or how to interpret output. Acceptable for a basic search tool, but there are clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It gives examples of capability types but does not explain the 'protocol' enum, how 'capability' interacts with 'protocol', or how the optional parameters affect results. The description adds some category context but leaves parameter meaning largely to inference.

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 ('Search') and a specific resource ('the MUJ428 compatibility directory'), and lists concrete examples of what it finds (evidence providers, receipt-aware executors, wallets, MCP/A2A integrations). It is clear what the tool does, though it does not explicitly differentiate itself from the sibling get_capabilities, which may overlap.

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

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

No guidance is given about when to use this tool versus alternatives such as get_capabilities, observe_trust_compatibility, or resolve_trust_route. The description implies a discovery/search use case but provides no exclusions or conditions that would help an agent choose among 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?

No annotations are provided, so the description carries the full burden. It does indicate a read-style behavior by saying Return, which implies no side effects. But it says nothing about caching, freshness, scope limitations, required permissions, or error behavior, leaving gaps about how the call behaves beyond being a query.

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

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

One sentence, front-loaded with the action verb, and every remaining word contributes a distinct output category. There is no fluff or repetition, making it appropriately concise for a capabilities overview.

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 no annotations, the description is the only source for what the tool returns. It lists four high-level categories, but uses dense jargon such as MUJ428 canonical machine discovery surfaces and Trust Gravity routing, and does not explain the shape of the response or point to sibling tools for deeper detail. This is adequate but not complete.

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

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

The tool has zero parameters and the schema is empty, so the baseline is 4. There are no parameter semantics to describe, and the description correctly focuses on return content rather than inputs.

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

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

The description states a specific verb (Return) and names four concrete resource areas: machine discovery surfaces, payment-rail discovery, Trust Gravity routing, and recommended adoption path. However, it does not explicitly differentiate itself from siblings like get_payment_rails or find_trust_capabilities, leaving some overlap 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?

There is no guidance on when to use this tool versus its siblings. It does not mention alternatives, conditions, exclusions, or whether this is the preferred entry point for a general overview. The agent must infer usage solely from the name and content list.

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

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

Annotations provide no safety hints (readOnlyHint, destructiveHint are absent), so the description carries the burden. It explicitly states 'This is read-only and moves no funds,' disclosing a critical behavioral trait. It also provides a concrete state summary (x402/Base-USDC live; MPP, AP2, etc. fail-closed) and the rationale (external provider/verifier not yet production-verified). This is strong behavioral disclosure beyond schema.

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

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

The description is two sentences, tightly packed with relevant information: it defines the scope (discovery, read-only), the resource, and the live/fail-closed states with reasons. Every clause earns its place; there is no filler or redundancy.

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

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

For a zero-parameter discovery tool with no output schema, the description covers the essential context: what it does, that it is safe (read-only), and what the current capability landscape looks like. An agent could call this tool with full understanding of its behavior and risks. The lack of an output schema is a minor gap, but for a capability-discovery tool the description suffices.

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 has zero parameters, and the schema covers 100% vacuously. The description adds no parameter-specific details because there are none to add. This is a no-argument capability discovery tool, so the description cannot meaningfully add parameter semantics; a baseline 4 is appropriate for the zero-parameter case.

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

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

The description clearly states that the tool 'discovers' payment capabilities and their 'truthful activation state' for a specific resource (MUJ428). It explicitly distinguishes itself from siblings like select_payment_rail by being read-only and not moving funds. The verb 'discover' plus the resource and scope make the purpose unambiguous.

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 conveys that this is for discovery (read-only) rather than for initiating payments, which is a critical usage distinction given siblings like select_payment_rail or invoke_trust_service. However, it does not explicitly name alternative tools or state when not to use it, leaving some inference required. The implicit guidance is clear but not fully 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It clearly states this is a read-only operation that returns catalog info, which is transparent about its non-mutating nature. However, it doesn't mention potential overhead, caching, or any side effects (though none are expected). It adds value by specifying what exactly is returned, but doesn't go beyond that.

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

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

The description is a single, dense sentence that front-loads the key deliverable (the catalog) and then enumerates the specific data items. There is no superfluous text. Every clause contributes to agent understanding.

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

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

The tool is a simple read-only catalog fetch with no parameters and no output schema. The description covers the main contents thoroughly. The only minor gap is not specifying whether the output is structured (e.g., JSON) or the exact format, but given the simplicity and lack of parameters, this is adequate. It misses nothing critical for calling the 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?

Since the tool has zero parameters, the schema is essentially empty. The description adds meaning by listing what the catalog contains, which is more than the schema provides. The baseline for zero parameters is 4, and the description enriches the tool's purpose, so this is appropriate.

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

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

The description clearly states the tool returns the 'MUJ428 service catalog' along with several specific data points. It identifies the verb 'Return' and the resource, and the mention of 'canonical' implies it's the authoritative source. While it doesn't explicitly name sibling tools, the specificity of the catalog content differentiates it from siblings like get_capabilities or get_payment_rails.

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

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

The description implies usage when the agent needs the overall service catalog, pricing, endpoints, quotas, or network info. However, it does not explicitly state when to prefer this over siblings like get_payment_rails or get_capabilities, nor does it give any exclusions or alternative suggestions. The context of the catalog is clear, but selection guidance is lacking.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states that the operation is read-only and has no execution or payment authority, which is valuable safety information. It does not mention authentication, rate limits, or failure behavior, but for a zero-parameter polling tool this is reasonably transparent.

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

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

The description is a single well-structured sentence that front-loads the action and resource, lists the key returned fields, and adds a clear read-only safety note. Every clause adds information, and there is no redundant or filler content.

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 zero parameters and no output schema, the description covers everything an agent needs: what it does, what data it returns, and its side-effect profile. The tool is simple enough that this description is complete for selection and 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?

There are no parameters, so the baseline is 4. The description correctly focuses on what the heartbeat returns rather than parameter details, which are unnecessary here. No additional parameter semantics are needed.

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

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

The description uses a specific verb ('Poll') and names the exact resource ('MUJ428 Trust Heartbeat'), then enumerates the specific data it returns: policy epoch, accepted receipt version, revocation state, resolver endpoints, and poll interval. This clearly distinguishes it from sibling tools like get_capabilities or get_service_catalog, which target different resources.

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 the tool should be used to retrieve current trust heartbeat state, and the read-only note helps set expectations. However, it does not explicitly say when to choose this tool over alternatives or when not to use it, leaving usage guidance mostly implicit.

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

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

No annotations are provided, so the description carries the full burden. 'Return' implies a read-only retrieval and the lack of parameters suggests no side effects, but it does not describe output format, error behavior, or confirm read-only status explicitly. Adequate for a simple getter, but not rich.

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

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

Two short sentences, front-loaded with the primary action and a useful clarification about the authoritative source. Every word earns its place with no redundancy.

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

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

For a zero-parameter tool with no output schema, the description clearly states what is returned and identifies the authority. It could add specifics about the pricing content or format, but the tool's simplicity means this is largely complete.

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

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

The tool has zero parameters, which sets a baseline of 4. The description adds no parameter-specific detail because there are none to document; no further compensation is needed.

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?

Description uses specific verb 'Return' and identifies an exact resource: 'canonical PROJECT OVERREACT-428 pricing'. This clearly distinguishes it from sibling tools like get_service_catalog or get_capabilities by focusing on pricing and authority.

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 establishes clear context: this tool returns canonical pricing and identifies Airtable Commercial Pricing Authority as the source of truth, implying this is the go-to for authoritative pricing. However, it does not explicitly state when not to use it or mention alternatives among siblings.

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

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

With no annotations provided, the description carries the full burden. It discloses the two-phase behavior, synchronous fulfillment, and that payment is only initiated with a valid signature. However, it does not describe potential side effects, error handling, or whether the service is idempotent, leaving some transparency gaps.

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

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

The description is concise, two sentences, and front-loads the key behavior (two-phase call). Every sentence adds value, and no extraneous information is included.

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 3 params, an enum, and no annotations or output schema, the description covers the critical workflow but omits details on the 'request' object and per-service specifics. It is adequate for a high-level call flow but not complete for an agent to construct correct requests without further schema info.

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%, so the description must compensate, but it only mentions 'payment_signature' and 'service' implicitly via the protocol. It does not explain the 'request' object structure or what each service enum value entails. The 'request' nested object is completely undocumented in the description, leaving a critical 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 clearly states that it is a service bridge for MUJ428 and describes the two-phase call pattern, which is more specific than just the name. However, it does not differentiate from siblings like 'trust_action' beyond referencing a specific protocol.

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

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

The description provides explicit guidance on when to call: first without payment_signature to get a challenge, then with payment_signature to complete. It also clarifies that no payment is initiated without a valid signature, which helps set expectations. However, it does not mention when to choose this over siblings like 'trust_action'.

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

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

With no annotations, the description carries the burden of disclosing behavior. It clearly explains the semantic nature of the recorded observation (self-reported discovery telemetry) and what it should not be used for, which is useful. However, it does not disclose operational behaviors such as whether the call has side effects beyond recording, idempotency, error handling, or what response to expect. It is minimally transparent but not fully.

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

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

The description is two concise sentences. The first sentence states the action and purpose immediately. The second sentence adds essential limitations without waste. It is front-loaded and every word earns its place.

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

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

The tool is relatively simple with two scalar parameters and no output schema, but the description does not mention return values, success/failure semantics, or whether duplicate observations are allowed. It gives enough context to understand the tool's role but not enough to fully anticipate the behavior of a telemetry-recording call.

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

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

The schema has 0% description coverage, so the description must compensate. It provides general context about 'agent encountered' and 'compatibility advertisement', which loosely maps to observer_ref and advertisement_hash, but it never explicitly explains either parameter, their format, or how they relate. An agent would still have to infer that observer_ref is the agent identifier and advertisement_hash is the identifier of the encountered advertisement.

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

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

The description uses a specific verb ('Record') tied to a concrete resource ('agent encountered a MUJ428 compatibility advertisement') and states the purpose ('so propagation can be measured'). It also distinguishes what the observation is not ('never external-adoption, embedding, or revenue evidence'), which helps separate it from sibling tools focused on capabilities or trust operations.

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

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

The description provides clear context for when to use this tool: when an agent has encountered a compatibility advertisement and wants to measure propagation. It also gives explicit exclusions by stating the observation is never external-adoption, embedding, or revenue evidence. However, it does not name alternative sibling tools or provide a direct 'use X instead' instruction, so it falls short of full 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?

No annotations exist, so the description carries full disclosure burden. It does meaningful work by clarifying that the tool only creates a discovery request and deliberately creates no binding authority — a critical behavioral trait that prevents misuse. It could go further by disclosing whether the request is publicly visible, persists, or can be withdrawn, but the core side-effect profile is well communicated.

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, both earning their place: the first front-loads the action and result, the second supplies the essential caveat. No filler, no repetition of schema content, and the most important scoping information is delivered immediately.

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

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

With 6 parameters (including a nested arbitrary-key requirements object), zero annotations, and no output schema, the description leaves too much unexplained. An agent knows what the tool is for but not how to construct a valid request payload or what a 'compatibility match' response looks like. The description captures intent and danger but not operability.

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

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

Schema description coverage is 0% and the description supplies no parameter-level guidance. The agent receives no explanation of what requester_ref should contain, what the requirements object expects, how protocols should be chosen, or what the action enum values mean — despite requester_ref and description being required. The phrase 'bounded machine-readable request' gives only the faintest hint about request construction.

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

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

The description uses a specific verb ('publish') with a specific resource ('a bounded machine-readable request for a trust capability') and states the expected outcome ('receive current compatibility matches'). It distinguishes itself from sibling read/list tools like find_trust_capabilities and observe_trust_compatibility by making explicit that this is a publish action, not a read action.

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

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

The description gives a clear when-not-to-use signal: it is explicitly 'not commercial acceptance, execution authority, or payment authorization.' However, it stops short of naming which sibling tool should be used when those capabilities ARE needed, so the agent must infer the alternative from the sibling list.

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

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

With no annotations provided, the description carries the behavioral burden and does well by explicitly stating this is a read-only routing call that never authorizes execution or payment. It adds meaningful safety context beyond a generic 'resolve route' summary, though it does not disclose all behaviors like possible lookup failures or data-source dependencies.

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

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

The description is two sentences, directly front-loads the tool's identity and core purpose, and every sentence contributes meaningful information. There is no repetitive filler or restating of the tool name.

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

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

Given the complexity of 9 parameters, no annotations, no output schema, and no parameter descriptions, the high-level routing explanation is insufficient for reliable invocation. The description lists what the tool returns conceptually, but it does not explain how to structure inputs or how defaults behave when all parameters are optional.

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

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

Schema description coverage is 0% and the description provides no parameter-level guidance. While some parameter names like action and irreversible are self-explanatory, the interaction between binding, external, consequential, tool_annotations, and the routing decision is entirely unexplained, leaving the agent to guess how these optional inputs affect the result.

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 ('resolve'/'determine') and a clear resource (Trust DNS route for Trust Receipt v1.3), and names concrete outputs such as evidence profile, verification endpoint, and effect-state requirements. It also distinguishes itself from action-oriented siblings by explicitly stating it is read-only and never authorizes execution or payment.

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

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

The description implies when to use this tool: before an intended action, to resolve routing and next steps rather than to execute the action. The read-only framing rules out using it for execution/payment, but it does not explicitly name alternative sibling tools or provide when-not-to-use conditions.

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

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

With no annotations provided, the description carries the full burden. It explicitly states 'Does not move money,' disclosing a key behavioral trait (no financial side effects). However, it omits other potential details like authentication or rate limits, though these are less critical for a calculation 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?

The description is two sentences, front-loaded with the core purpose, and contains zero filler or redundant wording. Every word contributes to understanding the tool's function.

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

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

For a simple calculator with one parameter and no output schema, the description adequately covers purpose and side-effects. It does not describe return format or edge cases, but given the low complexity, this is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, and the tool description does not elaborate on the 'transaction_value_usd' parameter beyond its name. It implies the fee depends on the value but offers no additional meaning, format, or constraints beyond what the schema already specifies.

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

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

The description clearly states the tool calculates the exact launch fee for a transaction before payment, using a specific verb ('calculate') and resource ('MUJ428 Transaction Assurance launch fee'). It distinguishes itself from siblings like get_trust_layer_pricing by emphasizing 'exact' and 'before payment', and adds a clarifying side-effect note.

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

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

The description provides a clear usage context ('before payment') and implies a timing constraint, but does not explicitly name alternatives or conditions when not to use it. This is clear context without exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It compensates well by explicitly stating three non-actions: 'never sends a payment credential, never moves funds, and never grants execution authority.' It also reveals the failure behavior for unsupported or unverified rails, though it does not cover authentication, rate limits, or idempotency.

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

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

The description is three tight sentences with the core purpose front-loaded. Every sentence earns its place: the first defines the operation, the second eliminates execution risk, and the third states the failure mode.

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

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

Given there is no output schema and no annotations, the description should explain more about return behavior and how to interpret results. It mentions REQUIRE_VERIFICATION-style failure but never describes the success path or what a successful preflight returns. With six optional parameters and zero schema descriptions, the tool definition is incomplete for reliable autonomous 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%, and the description adds almost no parameter-level meaning. It references a 'requested payment rail' but does not explain mode, asset, network, base_rail, authorization_protocol, or how they interact. The enums in the schema provide some value, but the description itself leaves most parameter semantics to inference.

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

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

The description opens with a specific verb and resource: 'Preflight a requested payment rail before Trust Reflex.' It immediately differentiates itself from execution-oriented siblings like trust_action and invoke_trust_service by explicitly labeling itself a 'no-money planner' that never sends credentials, moves funds, or grants execution authority.

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

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

The description clearly places the tool before Trust Reflex and frames it as a preflight planning step rather than an execution step. It does not explicitly name alternatives or exclusion conditions, but the context is strong enough for an agent to understand when this tool fits in the workflow.

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?

Without annotations, the description carries the burden and discloses key behaviors: the free quota, HTTP 402 response after quota, requirement for payment_signature, and the guarantee of not fabricating signatures. It lacks side-effect details but is transparent about the main behavioral traits.

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

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

The description is two sentences, front-loaded with purpose, and every sentence adds value (purpose, quota, payment flow, security guarantee). It is appropriately concise and well-structured.

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?

Despite being concise, the description is insufficient for a 9-parameter tool with no output schema. It does not specify success criteria, return format, or how to obtain a payment_signature, and most parameter semantics remain unexplained.

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%, yet the description only mentions caller_ref and payment_signature implicitly. It does not explain the meaning or usage of the other seven parameters, including required ones like action and action_ref, leaving this dimension weak.

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

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

The description clearly states the tool invokes the 'MUJ428 Trust Reflex' before a consequential action, which is a specific and distinct purpose. It differentiates from sibling tools like get_capabilities or select_assurance_tier, which are informational or tier-related.

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 context that the tool should be used before a consequential action and explains the quota/payment flow, but it does not explicitly compare with alternatives like invoke_trust_service or clarify when not to use it, leaving some ambiguity for an agent.

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