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

With no annotations, the description carries the full burden. It transparently discloses that the tool is a stub, returns IntentStub, and is not implemented. This goes beyond merely stating it's non-functional; it specifies the only possible behavioral outcome (returning a stub object), which is exactly what an agent needs to know.

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

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

The description is two short sentences that convey everything essential: it's a stub, what it returns, and that it's not implemented. Every word earns its place, and the key 'Honest STUB' is front-loaded. There is no fluff or repetition.

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

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

For a stub tool with no parameters, no output schema, and no annotations, the description captures everything an agent needs to know: it should not be used for real tasks. The mention of the return type (IntentStub) provides a complete picture, and there is no missing information that would cause the agent to call it incorrectly.

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 zero parameters, so the baseline is 4. The description adds nothing about parameters because there is nothing to add. The schema coverage is 100% (vacuously), and the description doesn't need to compensate for any missing parameter information.

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

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

The description explicitly states this is an 'Honest STUB' that 'returns IntentStub' and is 'Not implemented.' This leaves no ambiguity about its purpose: it is a placeholder and not a functional tool. It clearly differentiates itself from real tools by signaling its non-functional nature, even if it doesn't name siblings.

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

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

The description states 'Not implemented,' which strongly implies the agent should not call this tool for real work. While it doesn't explicitly suggest alternatives like 'use create_account instead,' the disclosure is sufficient to prevent misuse. The lack of alternative recommendations is a minor gap, but the instruction is clear and direct.

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

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

With no annotations, the description carries the full burden. It does disclose several behaviors: 'Agent signs', 'Increments spent_lamports', 'Does not move SOL', 'Empty allowlist is denied', and 'cap 0 requires amount 0'. However, these are cryptic and not explained in plain language, and no return behavior or error conditions are mentioned.

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 extremely short, but it is not effectively structured. It is a series of cryptic fragments without a clear introductory sentence stating the purpose. The information is not front-loaded with a plain-language summary, making it more under-specified than concise.

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 5 parameters, no output schema, and no annotations, the description is inadequate. It does not explain return values, error conditions, prerequisite setup, or the relationship to other grant tools beyond a vague reference to pay. Several edge cases are mentioned but not elaborated.

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 80%, so the baseline is 3. The description adds some nuance beyond the schema: it explains that root is optional if not in config, and that cap 0 requires amount 0. However, it does not explain dry_run, which is the only undocumented parameter, and the added context is terse.

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 begins with 'Agent consume path' which is not a clear verb+resource statement. It mentions 'Increments spent_lamports' but does not explicitly state that this tool checks and consumes a grant allowance. Sibling tools like issue_grant and revoke_grant are not clearly differentiated.

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 only usage hint is 'Relayer submits if you also call pay', which implies a combination with pay but does not explain when to use this tool versus others like check_grant, get_grant, or issue_grant. No explicit when-to-use or when-not-to-use guidance is provided.

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

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

No annotations are provided, so the description carries full behavioral burden. It discloses that the operation is root-signed, that it uses different CORE program IDs per network, and that a missing keypair returns need_human_signature/need_human_setup along with an unsigned transaction. It also gives the directive 'Never ask for a seed or key.' This goes beyond a bare 'create' and covers failure modes, though it does not mention success response 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 composed of short, impactful sentences each adding value: the core action, signing context, network variation, failure handling, and a safety directive. It is front-loaded with the purpose and avoids redundant filler. Efficient 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?

Given the two parameters, no output schema, and the complexity of network-specific behavior and conditional signing, the description covers the important operational detail: root-signed, network CORE IDs, missing-keypair fallback, and the 'no seed' warning. It does not describe the success response format or handle the case where the account already exists, but it is largely sufficient for an agent to invoke the tool correctly.

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

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

Schema description coverage is 100%, so both parameters (root and dry_run) are already documented in the schema. The description adds the instruction 'Never ask for a seed or key,' which is a behavioral note rather than parameter-specific semantics. It does not provide additional format or usage details for the parameters beyond what the schema already states, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Create the GrokAccount PDA for the human root.' It clearly identifies the tool's function and even adds network-specific context. However, it does not explicitly name any sibling tool to differentiate from, though the action is distinct enough from the grant/payment/deploy siblings.

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

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

The description provides clear context on when to use the tool (creating the human root's GrokAccount) and explains environment-specific behavior (localnet vs devnet). It mentions the edge case of a missing keypair and instructs the agent to never ask for a seed or key, which is a usage directive. It lacks explicit 'when not to use' or alternative tool references, but the context is clear.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It transparently states that the tool returns an IntentStub and is not implemented, leaving no ambiguity about its non-functional nature. This is honest and explicit.

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 concise sentence that front-loads the honesty about being a stub. Every word serves a purpose, with no filler or unnecessary detail, making it optimally concise.

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 stub tool, this description is complete. An agent needs to know only that it is not implemented and what it returns (IntentStub), both of which are provided. No further context is required to avoid misuse.

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 description coverage is 100% (empty schema). The baseline of 4 applies because no parameter documentation is needed; the description adds nothing about parameters, but none exist.

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 explicitly states the tool is a stub and that invoking it returns an IntentStub. This clearly defines its behavior and distinguishes it from sibling tools that perform real operations. While it doesn't detail what a full deployment would do, it accurately conveys its role as a placeholder.

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 not be used ('Not implemented'), but provides no explicit guidance on when to use it or what alternatives to choose. An agent is left to infer that it is a stub and should be avoided, without being directed to a suitable sibling 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?

With no annotations provided, the description fully carries the behavioral disclosure. It clearly states read-only semantics, the conditional fetch ('if it exists'), and that no signing is required. This covers key behavioral traits for a read operation.

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

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

The description is extremely concise, consisting of three short statements. It front-loads 'Read-only' (a critical behavioral trait), states the action and condition, and ends with the signing requirement. No wasted words.

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 getter with one parameter and no output schema, the description covers essential aspects: read-only, conditional existence, and no signing. It doesn't specify the return format, but that is often implicit for a fetch operation. The tool is simple enough that the description is adequate.

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

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

The schema already fully describes the 'root' parameter (100% coverage), including that it is a Base58 public key and never a secret. The description adds no additional parameter meaning, so baseline 3 is appropriate.

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

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

The description clearly states the action 'Fetch' and the resource 'GrokAccount PDA', with the condition 'if it exists'. It distinguishes itself from siblings like create_account, issue_grant, and get_grant by focusing on fetching the account rather than creating or granting.

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 context like 'Read-only' and 'No signing' but does not explicitly contrast this tool with alternatives such as get_grant or check_grant. Usage is implied for reading account data, but no direct guidance on when to prefer this over siblings is 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?

With no annotations, the description carries the full burden. It discloses read-only behavior and that the resource may not exist ('if it exists'), and mentions 'label is untrusted text' as a security hint. However, it omits details on return format, error behavior, or permissions, which are important for such a 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 very concise, with each clause earning its place: 'Read-only.' states the operation type, 'Fetch the Grant PDA if it exists.' states the purpose, 'No signing.' reinforces safety, and 'label is untrusted text.' adds an important note. It is front-loaded and efficient.

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 simple, the description lacks crucial context: it does not explain the distinction between 'root' and 'agent' parameters, nor does it clarify what 'label' refers to. With no output schema, the return structure is also unaddressed, leaving real ambiguity for an agent.

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

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

Schema coverage is 100%, so both parameters are documented. The description adds minimal parameter meaning beyond that; the mention of 'label' does not map to schema properties. Thus it does not exceed the baseline for well-documented schemas.

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 it fetches the Grant PDA with a specific verb ('Fetch') and resource ('Grant PDA'), and explicitly marks it as read-only. However, it does not differentiate from the sibling 'check_grant' tool, so an agent cannot easily decide which to use without additional context.

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

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

The description mentions 'Read-only' and 'No signing' but does not provide any when-to-use guidance or alternatives. It does not say why one would use this over check_grant or when not to use it, leaving the agent to infer applicability.

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 of behavioral disclosure — and it delivers. It discloses the signing model (root signs, agent does not), hard validation rules (expires_at_unix must be future, allowed_programs max 8 with no duplicates, empty = deny-all), semantic meaning (cap 0 = call-only, sponsor_eligible is 'your paymaster — not a promise Grok Chain pays'), and network-dependent allowlist behavior. Exceptionally thorough for an annotation-free 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?

Dense and front-loaded with the core purpose, every clause earns its place. The telegraphic style (e.g., 'v1 allowlist is router mode') is efficient but slightly cryptic, and the paragraph lacks structural segmentation, which costs a point. Still, no wasted words.

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 tool with no output schema and no annotations, the description covers a great deal: signing, validation, network specifics, and grant semantics. Minor gaps — the dry_run parameter's behavior is never explained, and the distinct role/semantics of the root parameter beyond 'Root signs' is left to the schema — keep this from a 5, but it is far above minimally viable.

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 high at 88%, so the baseline is 3, but the description adds genuine value beyond the schema: 'cap 0 = call-only' clarifies spend_cap_lamports, 'empty deny-all' and 'max 8, no duplicates' augment allowed_programs, and 'must be in the future' adds the validity requirement for expires_at_unix that the schema's '0 is rejected' only hints at. Solid additive 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 description opens with a specific verb+resource+target: 'Issue a capability Grant PDA to an agent pubkey.' This clearly differentiates the action from sibling tools with overlapping domains (revise_grant, revoke_grant, check_grant, get_grant) — 'issue' is unambiguously the creation path, and the signing statement (Root signs, Agent does not) tightens the definition further.

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 strong contextual guidance: who signs, what the expiry must satisfy, allowlist constraints, and environment-specific router behavior (localnet vs devnet INTENTS ids). However, it never explicitly names alternatives or states when-not conditions — e.g., it does not direct the agent away from revise_grant/revoke_grant for later lifecycle steps. Clear context, but no explicit 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 must carry the full disclosure burden. It clearly explains who signs (agent), the fee payer (relayer), that the bot never holds SOL, the funding source (SpendVault), optional sponsor reimbursement, and failure modes (need_human_signature / need_human_setup). This is strong behavioral transparency, though it omits the return value on success.

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 paragraph that is not front-loaded with the primary purpose; it starts with implementation details rather than a clear action statement. While it is not excessively long, it mixes environment specifics, signing, fee payer, funding, and preconditions without clear structure, making it harder to parse quickly.

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 the payment flow, the description covers many crucial aspects: environment-specific behavior, signing, fee payer, funding source, sponsor reimbursement, and required setup. It does not describe the return value or successful output, and it leaves dry_run semantics unexplained, but the coverage is strong for a payment tool without an output schema.

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 descriptions cover 4 of 5 parameters (80%), so the baseline is 3. The description adds some context by linking sponsor_lamports to the optional reimbursement and indicating SpendVault as the source for amount_lamports. However, it does not systematically explain each parameter; for dry_run and root it adds nothing beyond the schema, leaving some ambiguity about their exact roles.

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 'Implemented INTENTS pay' which largely restates the tool name and does not clearly articulate the high-level function (sending lamports to a recipient from a SpendVault). The purpose is implied through context like 'Agent signs' and 'Human-funded SpendVault is the SOL source', but a concise, explicit statement of what the tool does is missing.

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 concrete preconditions for success (rooting, grant, funding, RELAYER_KEYPAIR) and environment-specific behavior (localnet vs devnet), which helps an agent understand operational requirements. However, it does not explicitly instruct when to use this tool versus alternatives like swap or call, nor does it state conditions under which this tool is inappropriate.

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 discloses key behaviors: it replaces policy fields, requires root signing, and prohibits the agent from revising or changing the agent field. It also references issue_grant's rules, implying validation constraints. However, it does not describe outcomes or side effects such as whether fields are overwritten or if the operation is irreversible, leaving room for ambiguity.

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 with no wasteful sentences. It opens with the primary action, then follows with essential constraints, making it easy to parse quickly. All sentences contribute to understanding the tool's behavior.

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 tool's complexity (8 parameters, 4 required, no annotations, no output schema), the description is missing key information. It doesn't explain the meaning of parameters like label, dry_run, or expires_at_unix, nor does it describe the return value or success feedback. The reference to issue_grant rules helps but relies on external knowledge. Overall, an agent would have difficulty confidently calling this tool without additional context.

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 covers descriptions for half of the parameters, and the description does not add meaning for the others (label, dry_run, expires_at_unix). It does not map the mentioned 'policy fields' to specific parameters, so the agent must rely on the schema for parameter details, which is incomplete for half of them. This is insufficient compensation for the 50% schema coverage.

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 operation ('Replace Grant policy fields') and differentiates from related tools by noting it cannot change the agent and shares policy rules with issue_grant. This clearly communicates the tool's role relative to its siblings.

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

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

The description implies usage for revising an existing grant's policy fields, contrasting with issue_grant by stating it cannot change the agent. It also notes the same policy rules apply, but does not explicitly mention when alternatives like revoke_grant or check_grant should be used. It gives enough context to select the tool for the right scenario.

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 must fully disclose behavior. It does mention authentication (Root signs) and a precondition (Account is not closed), plus a permission restriction (Agent cannot revoke). But it does not describe side effects (e.g., whether the grant is permanently removed), what happens on failure (e.g., if account is closed), or the meaning of dry_run. This is a partial disclosure.

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

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

The description is three terse sentences, each carrying distinct information: the action, the signing requirement, and the permission restriction. It is front-loaded with the core purpose and wastes no words. The brevity is appropriate for the level of detail provided.

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

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

For a mutation tool with no annotations and no output schema, the description is under-specified. It does not explain return values, error conditions (e.g., what happens if root lacks authority or account is closed), the effect of dry_run, or how the grant revocation impacts other state. It also lacks guidance on distinguishing it from sibling grant tools, making it incomplete for correct invocation.

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

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

The schema covers 2 of 3 parameters (root, agent) with descriptions, but dry_run lacks any description. The tool description does not add any parameter meaning beyond what the schema already provides, and fails to compensate for the dry_run gap. No elaboration on parameter syntax, defaults, or edge cases is given.

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 action ('Revoke a Grant') and the resource. It adds meaningful constraints (Root signs, Account not closed, Agent cannot revoke) that hint at the tool's scope, but it doesn't explicitly differentiate from sibling tools like issue_grant or revise_grant. An agent could infer it's the opposite of issue_grant but not from the 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?

The description provides context on when the tool can be used (root signature required, account must be open, agent lacks permission) which implies the intended caller and conditions. However, it does not state when to prefer this tool over alternatives like revise_grant or check_grant, nor does it list exclusions. The guidance is implicit 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently states that the tool returns 'IntentStub', is 'Not implemented', and does not call a DEX. This fully discloses the no-op nature and lack of side effects, which is honest and clear. The only minor gap is that it doesn't explain what IntentStub is, but that's not critical for a stub.

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, compact sentence that front-loads the most critical information ('Honest STUB', 'Not implemented') before adding secondary details. Every word contributes value, and there is no unnecessary fluff. This is exemplary conciseness for a stub definition.

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 stub, this description is complete: it tells the agent not to use it, what it returns, and that it has no side effects. There's no output schema, but the return type is explicitly mentioned. It doesn't need to explain the semantics of a real swap because the tool is purely a placeholder. The context signals confirm simplicity, so nothing important is missing.

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

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

The tool has zero parameters and the schema is empty, so there are no parameters to document. Per the baseline for 0-parameter tools, a score of 4 is appropriate. The description doesn't need to add parameter information because there are none, and it doesn't introduce any confusion.

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

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

The description clearly identifies the tool as an 'Honest STUB' and explicitly states 'Not implemented', making it obvious that it is a placeholder for a swap operation. It names the specific intent ('INTENTS swap') and the return type ('IntentStub'), which distinguishes it from functional sibling tools even though it doesn't describe what a real swap would do. This is clear enough for an agent to recognize it as a non-functional stub.

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 explicitly says 'Not implemented', serving as a direct warning not to invoke this tool. It also clarifies that it 'Does not call a DEX', indicating no side effects. While it doesn't point to alternative tools, the primary usage guidance is to avoid this stub, which is exactly what an agent needs to know. This is more explicit than typical guidance because it completely rules out usage.

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