SQLGuard — Execution Certificate Firewall

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful context about the pay model ('Performance pay only', 'no upfront bounties') and the X-SQLGuard-Ref header requirement, but the phrase 'Instant remains taste-only' is cryptic and unexplained, reducing transparency.

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 compact at four short sentences and front-loads the primary purpose. Every sentence contributes something (affiliate role, referral method, commission rates, payout model), though the 'taste-only' phrase is jargon that could be dropped or clarified.

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 tool with one optional parameter, an output schema, and read-only annotations, the description is mostly adequate. However, it does not explicitly state what the tool returns when wallet is omitted versus provided, nor explain how the X-SQLGuard-Ref header should be used by the agent, leaving some operational details to inference.

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

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

Schema description coverage is 100%, and the wallet parameter already has its own descriptive text ('Optional 0x wallet — if set, returns owed/paid status'). The tool description adds no further parameter-level meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description clearly identifies this as the affiliate/referral tool ('Agent-native affiliate', 'Earn $30 USDC per referred Pilot'), which distinguishes it from the many sibling tools like sqlguard_balance or sqlguard_catalog. However, it lacks a precise verb like 'query' or 'get' — the actual operation is implied by the optional wallet parameter rather than stated directly.

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 'PRIMARY:' label indicates the intended use (referring Pilot Challenge or Gateway Pilot), and the commission comparisons ('Session/Cert/Bind stay ~20%') hint at relationships among related tools. But there is no explicit when-to-use or when-not-to-use guidance, nor named alternatives.

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, so the safety profile is covered. The description adds valuable context that this concerns legacy volume and is not intended for production authorize, clarifying the operational scope beyond what annotations provide.

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 concise sentences with no filler. The primary purpose is front-loaded, and the critical sibling distinction is included in the second sentence. Every sentence earns its place.

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

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

For a simple read-only tool with full schema coverage, annotations, and an output schema, the description is complete. It explains what the tool does, clarifies its legacy scope, and routes to the correct alternative where needed.

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

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

Schema description coverage is 100% and the single parameter agent_id is fully described in the schema. The description does not add additional parameter semantics, but the baseline of 3 applies because the schema carries the load.

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

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

The description states a specific verb and resource: 'Check prepaid credit balance (legacy volume)'. It also explicitly distinguishes this tool from sqlguard_challenge by noting it is not for production authorize, making sibling differentiation clear.

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

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

The description gives explicit routing guidance: use this for prepaid credit balance reads, and for production authorize use sqlguard_challenge instead. This names the alternative and the condition that selects it, leaving no ambiguity.

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?

Annotation Contradiction: the description says 'pay Exact USDC once' and 'free sqlguard_gate,' both of which imply state-changing side effects, while annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. At minimum, 'pay once' is misleading next to readOnlyHint=true, and 'free the gate' suggests a state transition. The description not only fails to add clarifiying behavioral context but actively contradicts the structured metadata.

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 short and front-loaded, with no filler sentences. But it compresses too many unexplained acronyms (ABMP, AP2, Ed25519) into a small space, making it dense rather than truly concise. The sentence about freeing sqlguard_gate is useful but introduces a sibling-tool dependency without explaining it.

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?

This is a complex tool with four required parameters, a payment side effect, a hashing step, and an ordering requirement involving sqlguard_gate. An output schema exists, so return values are covered, but the description stll does not explain the ABMP/AP2 ceremony, the meaning of 'pay Exact USDC once' in an apparetly read-only tool, prerequisites, or failure modes. The annotation contradiction alone makes the context materially incomplete for safe 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 100%, so the baseline is 3. The description adds a little extra meaning by explaining that the mandate text is hashed into the Ed25519 certificate (mandate_hash) and that sql is the mutating statement to authorize, but these are marginal additions over the schema descriptions. It does not clarify formats, required syntax, or the relationship between schema_ddl and sql beyond what the schema already says.

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 action ('pay Exact USDC once via POST /v1/bind'), a resource (ABMP BIND), and a process (hashing the mandate into an Ed25519 execution ceertificate). It distinguishes itself from sibling tools by mentioning 'free sulguard_gate before execute,' which implies a separate gate step. However, heavy acronyms like ABMP and AP2 are left unexplaind, and the ter 'bind' remains somewhat domain-speciic, so it is clear only to someone already familiar with the system.

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 or when-not-to-use guidance, and no alternative tool is named. The phrase 'Then free sqlguard_gate before execute' gives a sequencing hint (bind must precede gate/execute) but does not explain why this tool is chosen over sibling tools such as sqlguard_validate, sqlguard_cert, or sqlguard_gate. The usage context is only implied, not stated.

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

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

The description and input schema describe a purchase that changes credit ownership after settlement, but the annotations declare readOnlyHint=true. This is a direct contradiction: the description does not correct or qualify the read-only signal and fails to disclose the actual mutating/payment side effects of the 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 compact and front-loaded with the legacy status and preferred alternatives. Every clause carries information, though the phrase 'OFF TABLE as wealth and primary agent buy' is awkward and slightly ambiguous.

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

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

The tool has only two well-documented parameters and an output schema, and the usage policy is covered. However, the readOnlyHint annotation directly contradicts the buy semantics, and the description never clarifies that calling this tool will actually execute a purchase and change state. That is a critical completeness gap for safe agent use.

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

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

The schema description coverage is 100%, so the description does not need to explain bundle or agent_id. It adds policy context by noting bundles remain for volume validates only, but no additional technical parameter semantics beyond the schema. 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 identifies the resource as LEGACY prepaid credits and implicitly the buy action via the title and 'primary agent buy', while distinguishing this tool from sqlguard_challenge and Gateway invoice. However, it never plainly states 'purchases a credit bundle'; the meaning is inferred from the name and schema rather than explicitly described.

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 tells agents to prefer sqlguard_challenge for an exact $100 unlock or Gateway invoice for $299, and restricts micro|starter|builder|team bundles to volume validates only, not standard authorization. This is clear, actionable when-to-use and when-not-to-use guidance with named alternatives.

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 read-only, idempotent, and non-destructive behavior. The description adds important behavioral context: this is a legacy, off-table resource that returns specific data, not the authoritative standard path. It does not cover errors or prerequisites, but the annotation burden is already substantially met.

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 compact, front-loads the legacy/off-table warning, then gives preferred tool routing and return contents. Every clause contributes, though phrases like OFF TABLE and x402 are domain jargon that could be clearer.

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, read-only catalog with an output schema, the description provides the essential purpose, status, routing, and scope needed to decide whether and how to invoke it. Nothing critical is missing for making the 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 input schema has zero parameters and 100% schema description coverage, so there are no parameter semantics for the description to clarify. The baseline of 4 applies because no parameter 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?

The description clearly identifies the tool as a legacy prepaid catalog and states exactly what it returns: credit bundles and x402 buy URLs for volume validates only. It explicitly excludes the authorize standard, so an agent can distinguish this from the broader SQLGuard flow.

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 explicit routing by saying to prefer sqlguard_handshake then sqlguard_challenge, and restricts use to volume validates only while excluding the authorize standard. The word prefer is slightly ambiguous about whether handshake and challenge are prerequisites or replacements, but the guidance is still usable.

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 carry readOnly/openWorld/idempotent/destructive context, so the bar is lower. The description adds that this is the legacy path, costs $0.05 per cert, and must be followed by sqlguard_verify, but it does not explain what happens when the cert is issued or what constraints apply. There is no contradiction with the annotations.

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

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

The text is short, but the phrasing is cryptic and jargon-heavy ('LEGACY taste', 'OFF TABLE as wealth/primary', 'Exact Instant Cert'), and the workflow instruction is compressed into a long run-on sentence. A few clear sentences would be more useful.

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 schema descriptions plus annotations plus output schema cover a fair amount of context. However, the core meaning of 'cert' and what the agent is being asked to authorize is still unclear, and the description relies on cryptic status labels to convey when the tool is appropriate.

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?

Input schema covers all three parameters with meaningful descriptions, so the baseline is 3. The description does not add any additional meaning about the parameters themselves.

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 never states a concrete action; it refers to 'LEGACY taste' and 'One Exact Instant Cert $0.05' but does not say what the tool does with agent_id, schema_ddl, and sql. The title 'Instant Cert' is the clearest signal, which is too close to a tautology. It does differentiate 'legacy' from the challenge/Gateway path, but not by explaining the tool's function.

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 explicit routing: use this only for 'LEGACY taste', not for wealth/primary, and names sqlguard_challenge and Gateway invoice as the wealth alternatives. It also tells the agent to call sqlguard_verify before executing, which is a concrete workflow instruction.

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 and idempotentHint=true; the description adds useful behavior beyond that: the free POST path with mutating SQL results in DENY + deny_id, the exact 402 amount 100000000 is required, and the unlock grants 500 PASS for 7 days. No contradiction with annotations.

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

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

The description is dense and front-loaded with the most important routing information: 'PRIMARY agent buy path.' Every sentence carries either a price, an outcome, or an alternative. It is highly compact, though some jargon like 'OFF TABLE' and 'Tip' makes it slightly less immediately readable.

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 rich annotations and an output schema, the description covers what an agent needs: exact pricing, endpoint behavior, pass duration, and sibling-tool alternatives. It also explicitly states the Probe alternative never authorizes, which helps the agent 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?

Schema description coverage is 100%, so the schema already explains the three parameters. The description adds context around sql as 'mutating SQL' and mentions the amount 100000000, but it doesn't materially deepen meaning for agent_id or schema_ddl beyond what the schema already provides.

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 resource: 'PRIMARY agent buy path' and 'Exact USDC $100.00 via POST /v1/challenge/unlock ... opens 500 PASS / 7d.' It clearly identifies this tool as the primary challenge-buy path and distinguishes it from the alternative Gateway invoice and Probe paths.

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 explicitly says when to use this tool — as the PRIMARY agent buy path — and names alternatives: 'Alt: Gateway invoice $299/$499/$1999' and 'Probe FREE tip — never authorizes.' It also states Session/Cert/micro are 'OFF TABLE as primary,' giving an agent clear 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, idempotentHint, and destructiveHint, so the description's safety burden is lower. The description adds behavioral context beyond annotations by revealing that operator wallets are filtered out and that the tool returns a classification plus specific metrics (lifetime USD, sku counts, next ladder step).

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 dense sentence packs the core purpose, an exclusion rule, and the key return fields without wasted words. The most important information is front-loaded.

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

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

For a single-parameter, read-only, idempotent tool with an output schema, the description is nearly complete: it gives the classification goal, the exclusion, and return components. Minor ambiguity remains around domain terms like 'ladder step', but the output schema likely covers the exact shape.

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%, with agent_id already explained as 'Agent or wallet id to classify'. The description largely repeats this concept ('agent wallet') and adds no additional parameter syntax, format, or edge-case guidance.

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 ('Classifies'), names the exact resource ('agent wallet'), and states the definitive outcome ('prior Exact-paying client'), while also adding the operator-wallet exclusion. It clearly differentiates the tool from the generic sqlguard_* sibling list.

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 classifying client status and retrieving lifetime USD/sku counts, but it does not explicitly say when to choose this tool over siblings like sqlguard_balance, sqlguard_profit, or sqlguard_denials. The 'excluding operator wallets' note provides a scope exclusion, not an alternative-tool routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the endpoint and the 'open' filter, which is useful. 'Instant taste-only; Probe free' hints at cost/latency traits, but it is too cryptic to count as meaningful behavioral disclosure, so no more than a 3 is warranted.

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 opening sentence is appropriately concise and informative. However, the rest of the description is disjointed and appears to contain unrelated or unexplained strategy content ('Wealth', 'Legacy Session claim ($0.25) OFF TABLE as primary'), which adds noise rather than clarity. It reads more like scattered notes than a purposeful tool description.

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, optional-parameter, read-only listing tool with an output schema, the first sentence plus annotations are nearly sufficient. However, the unexplained references to unlock paths, Gateway Pilot, and Probe are confusing and could mislead an agent about the tool's intended scope, so the description is not fully complete.

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

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

The schema has one optional parameter, base_url, with a full description and a default, giving 100% schema description coverage. The tool description does not add any parameter-specific meaning beyond the schema, 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 first sentence states a specific verb ('List'), a specific resource ('open DENY inventory'), and the data source endpoint ('GET /v1/denials'). This makes the core action clear. It does not explicitly distinguish the tool from siblings like sqlguard_challenge or sqlguard_pilot, and 'DENY inventory' is terse jargon, so it stops short of a 5.

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

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

No explicit when-to-use or when-not-to-use guidance is provided, and no alternatives are mentioned. References to 'Exact Pilot Challenge unlock', 'Gateway Pilot', 'Legacy Session claim', and 'Probe free' are cryptic and not framed as decision criteria, so an agent cannot infer when to select this tool over its 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 mark the tool as read-only, idempotent, and non-destructive. The description adds useful behavioral context by clarifying that the tool compares settle success against listing freshness and references the specific GET /v1/effects endpoint. No contradiction with annotations.

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

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

The description is two tightly packed sentences. It front-loads the core semantic contrast, then gives the endpoint and intended use case. Every clause adds information and there is no filler.

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

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

For a zero-parameter, read-only tool with no output schema, the description gives endpoint and domain context but does not state what a successful invocation returns or how the 'proof' is presented. The cryptic domain jargon is understandable to an informed agent but leaves some ambiguity.

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 input schema is empty, so the description carries no parameter burden. The pointer to GET /v1/effects and the focus on exactness versus freshness are sufficient context for a parameterless invocation.

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 a concrete purpose: proving that exact settle success differs from Bazaar/catalog listing freshness, and points to GET /v1/effects. It is more specific than a tautology and gives a clear domain role, though it does not use a crisp action verb like 'verify' or 'check'.

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 the tool: for CDP/Bazaar honesty checks on Session/Cert, especially when settle success versus discovery freshness matters. It does not name alternatives or state when not to use it, so usage guidance is present but not 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 indicate read-only and non-destructive behavior, and the description adds important behavioral context beyond those: it fail-closes before execution, is a gate rather than an executor, and issues nothing. This clarifies the tool's side effects and safety posture well. No contradiction with annotations 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?

The description is compact, front-loading the tool identity and role, then giving endpoint usage, conditional requirements, and behavioral guarantees. Every sentence carries meaningful information, with no filler or redundancy. It is efficiently structured for quick agent consumption.

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 objects, and an output schema, the description is reasonably complete: it conveys purpose, required inputs, conditional mandate, and non-executing behavior. The optional schema_ddl parameter is not mentioned, but the schema fully documents it. An output schema exists, so lacking return-value detail is not a 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?

Schema description coverage is 100%, so the baseline is 3, but the description adds context beyond the schema by naming the required request components ('certificate+signature+sql') and the conditional mandate requirement ('when BIND'). This helps an agent understand the request shape without opening the schema. It does not detail all parameters, but the schema already covers them.

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 authorization gate for mutating SQL, stating it fail-closes before execution and issues nothing. It distinguishes this tool from execution or issuance tools by emphasizing it does not execute or issue anything. Some jargon like 'free portable authorize bus' slightly obscures the core action, but the overall purpose is understandable.

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 usage context: any mutating agent tool should pass through this gate before execution. It makes the fail-closed behavior explicit, which tells an agent when this tool is mandatory. It does not explicitly name alternatives or exclusions, but the conditional mandate and 'before execute' guidance are sufficient directional context.

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, openWorldHint, idempotentHint, and destructiveHint=false, so the description does not need to re-establish the safety profile. It adds context about being a 'free discovery magnet' and about Probe/Instant authorization, but those claims are too cryptic to meaningfully inform behavior. No contradiction with the annotations.

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

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

The description is short and action-oriented in the opening clause, so it avoids serious bloat. But phrases like 'Free discovery magnet', 'Instant stays taste-only', and 'Session listed LEGACY OFF TABLE as primary' are vague and cryptic rather than crisp useful guidance.

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

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

The zero-parameter schema and output schema reduce the burden of explaining return values, but core domain semantics remain undefined: DENYs, Denial Exchange, Pilot Challenge Exact $100, LEGACY OFF TABLE, and how this relates to Pilot/Probe/Instant. An agent cannot confidently determine invocation semantics or task fit from this 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?

The tool has zero parameters and schema coverage is 100%, so the schema fully specifies the call signature. The description's 'one call' phrase hints at combined output but does not need to document parameter formatting. A baseline 4 is appropriate because there are no parameter semantics left to explain.

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 concrete verbs like 'Pull' and 'Hunt' and points at a resource ('DENYs', 'Denial Exchange inventory'), so it is not a mere tautology. However, terms like 'Pilot Challenge Exact $100 wealth unlock', 'LEGACY OFF TABLE', and 'taste-only' are unexplained jargon that a generic agent cannot reliably map to behavior. It only obliquely differentiates from siblings like Probe or Instant.

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 or when-not-to-use statement. 'Probe stays free/not authorize; Instant stays taste-only' hints at comparisons with other tools, but it does not state under what conditions Gravity should be selected. 'Hunt Denial Exchange inventory' provides context, not a decision 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 mark the operation readOnly and idempotent, so the description does not need to restate that. The description adds behavioral context beyond annotations by explaining the handshake's routing behavior, the challenge unlock amount, and explicit exclusions like 'Session/Cert OFF TABLE as primary.'

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 dense and front-loaded with the core handshake behavior, then moves to routing decisions. The routing notation is compact but slightly cryptic ('/gateway $299+', 'Exact unlock /v1/challenge/unlock amount 100000000'), which prevents a perfect conciseness score.

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

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

Given the output schema and full parameter schema, the description covers when to call, what to pass, how to route, and key exclusions. It could be more explicit about what the handshake returns, but the output schema handles that, so this is reasonably complete for an orchestration-first 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 coverage is 100%, so parameters are already documented in the schema. The description reinforces the central need parameter with 'Pass { need: "…" }' but does not add meaningfully beyond the schema. This matches the baseline for full 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 role: 'FIRST tool on connect' and 'Asks: What do you need?', making the handshake-and-route purpose unmistakable. It also distinguishes itself from siblings by saying 'Session/Cert OFF TABLE as primary' and 'Call before sqlguard_catalog when unsure.'

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 explicit routing conditions: 'Org/migrate/mutate/production → sqlguard_challenge', 'Company invoice → /gateway $299+', and 'Call before sqlguard_catalog when unsure.' It tells the agent when to use this tool first and when a different tool is appropriate.

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

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

The description instructs 'Burn via POST /v1/session/cert + verify', which indicates a mutating or destructive workflow, while annotations declare readOnlyHint=true and destructiveHint=false. This is a direct annotation contradiction. The phrase 'opens 7d / 500 PASS' also implies a state change, compounding the inconsistency.

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 short, but it reads as a stream of abbreviations and slash-separated fragments rather than a structured explanation. There is no plain-language lead sentence, and items like 'Invoice alt $299/mo' and 'UI: /challenge' are not clearly relevant to tool invocation. This brevity is under-specification, not genuine conciseness.

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 that appears to open a paid gateway pilot, the description leaves critical context unexplained: what the $100.00 payment does, what a 'PASS' is, what a 'DENY' means, how the burn step relates to the pilot, and what the agent should actually do. The output schema may cover return shape, but the surrounding operational context is far too incomplete.

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

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

The input schema already documents agent_id and company with 100% coverage, so the baseline is 3. The description adds no meaningful detail about these parameters; references to pass counts, pricing, and DENY are not tied to any schema field. It neither improves nor harms parameter understanding.

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 hints that this is an alternative path that 'opens' a 7-day / 500-pass window for $100 USDC, so it is not a pure tautology. However, it never states the tool's core action and resource in plain language; phrases like 'Wealth Exact alt' and 'Exact USDC $100.00 opens 7d / 500 PASS' are cryptic. It only weakly distinguishes itself from siblings by naming sqlguard_challenge.

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 line 'Prefer sqlguard_challenge when you have a DENY' gives an explicit alternative and a condition, which is useful. But 'DENY' is undefined, and the rest of the guidance ('Invoice alt $299/mo', 'Session/Workday OFF TABLE as primary') is too elliptical to help an agent decide reliably. There is no clear summary of when to use this tool versus the sibling set.

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 mark readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful disclosure: it never issues an Execution Certificate and mentions a possible stale paid row in CDP Bazaar. However, 'Session/Cert OFF TABLE as primary' is cryptic and the side-effect caveat is vague, leaving the behavioral picture only partially clearer.

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 short and front-loads the core free-risk-tip purpose, earning it points for brevity. However, it packs multiple pricing and retention clauses ('Exact unlock $100 OR Gateway invoice $299', 'CDP Bazaar may retain a stale paid row; Fly wire is free') that are tangential for invoking the tool and obscure the structured message.

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

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

With an output schema present and all parameters documented in the schema, the description does not need to explain return values. It adds the critical no-authorization caveat and points to effects via GET /v1/effects, which is enough for invocation. The cryptic 'Session/Cert OFF TABLE as primary' and unclear stale-row statement create residual ambiguity that keeps it from being fully complete.

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

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

Input schema has 100% parameter description coverage, so the schema already explains sql, agent_id, and schema_ddl meaningfully. Baseline is 3. The description adds one useful semantic detail by listing examples of mutating SQL (DROP/TRUNCATE/DELETE-without-WHERE), but it does not compensate further beyond what the schema already states.

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 a specific behavior: 'FREE mutating-SQL policy risk tip (DROP/TRUNCATE/DELETE-without-WHERE)' and explicitly says it does not authorize ('not authorize', 'NEVER issues an Execution Certificate'). It distinguishes itself from sqlguard_challenge, a sibling, making the tool's role clear. The phrase 'risk tip' is slightly nonstandard but is anchored by concrete examples.

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

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

The description gives clear context: use this for a free risk assessment rather than authorization, and explicitly routes authorization to 'sqlguard_challenge' with pricing. It also points to 'GET /v1/effects' for more detail. It does not fully enumerate when it should be avoided beyond the authorization case, but the main alternative is named.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds some operational context ('Probe free/not authorize') but uses unexplained directives like 'Bind $0.05 mandate' that do not clarify side effects. No contradiction with annotations.

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

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

At two sentences it is short, but the structure is cryptic: capitalized fragments, slashes, and undefined terms ('Bind $0.05 mandate', 'OFF TABLE') reduce scannability. Important operational context is not front-loaded in an actionable form.

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 an output schema, the main missing piece is a clear statement of what the tool computes or returns; the description never delivers that. It gives a trigger and constraints, but the ambiguous business jargon leaves the definition incomplete for an agent to call confidently.

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

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

The schema has zero parameters and 100% coverage, so there is no parameter documentation burden on the description. The description adds contextual business rules but does not need to explain parameter meanings because there are none.

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 reads as a set of eligibility/profit rules ('wealth ONLY Pilot Challenge Exact $100 unlock...') rather than a clear operation statement. There is no main verb or resource; even the title 'Profit OS' is only a label. It hints at SKU-selection advice only in the final sentence.

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 one explicit trigger: 'Call before picking a SKU when optimizing spend/friction.' However, it never names sibling tools or conditions for choosing them, and most of the description is domain jargon that does not establish when this tool is preferred over alternatives.

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

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

The read-only, idempotent, non-destructive profile is covered by annotations, and the description adds content expectations such as MUST/MUST_NOT rules, legacy session/workday treatment, and probe guidance. However, the phrase 'Share with other agent runtimes' is ambiguous about whether this is an agent directive or a tool side effect, which slightly muddy the behavioral picture.

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 short and front-loaded with the protocol name and purpose, but it packs in cryptic phrases like 'Pilot Challenge Exact $100 wealth path' and 'LEGACY Session/Workday OFF TABLE as primary' that are hard to parse and may confuse agents. The 'Share with other agent runtimes' sentence adds little tool-selection value.

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

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

Given no parameters, rich safety annotations, and a provided output schema, the description is adequate for a low-complexity read-only protocol tool. However, with 23 sibling tools, clearer guidance on when to fetch this protocol versus using other sqlguard tools would make the definition more complete.

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

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

There are zero parameters and the schema is complete, so no parameter documentation is needed. The description does not need to compensate for schema gaps because 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 states a concrete deliverable ('Returns MUST/MUST_NOT rules') and identifies the resource as the ABMP normative protocol with SQLGuard as reference implementation. It conveys an information-retrieval tool rather than a mutating one, though some listed contents are cryptic and sibling boundaries are not explicitly drawn.

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 explicit when-to-use guidance or alternatives are provided. 'Share with other agent runtimes' is an instruction about handling output, not a criterion for choosing this tool over siblings like sqlguard_probe, sqlguard_gate, or sqlguard_require.

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, and the description adds the meaningful fail-closed enforcement rule plus the return payload (compliance_loop + buy URLs). No contradiction with annotations.

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

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

The description is compact at two sentences, with the key policy behavior front-loaded. Some phrasing like 'Session/Cert OFF TABLE as primary' is terse and jargon-heavy, but the overall structure is 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?

For a zero-parameter tool with an output schema and safety annotations, the description covers the core trigger, enforcement action, and return value. It leaves minor gaps around option variants and sibling relationships, but these are secondary given the structured metadata.

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 100% schema coverage, so the baseline is 4. There is no parameter documentation burden for the description to carry.

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 a specific resource ('ABMP fail-closed policy') and a concrete behavior: block SQL write tools until payment PASS + verify. This goes well beyond the generic title 'Require policy,' though it does not explicitly contrast with sibling tools like sqlguard_gate or sqlguard_verify.

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 intended context is implied: agent runtimes should invoke or apply this policy before SQL write tools. Unlock conditions are stated, but there is no explicit when-to-use/when-not-to-use guidance and no mention of alternatives among the many sqlguard 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 readOnly, idempotent, and non-destructive, so the safety profile is covered. The description adds the output's content (install plus wealth ladder) and marks Session/Instant as off the table, but this added context is not clearly explained and no other behavioral details are provided.

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 short and front-loads the main action, but the second sentence 'Session/Instant OFF TABLE as primary' is poor prose and hurts readability. It is compact but not cleanly 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?

For a parameterless, read-only informational tool with an output schema, the description covers the key call content: installation snippet and wealth ladder. It is reasonably complete, though the jargon phrase and lack of sibling routing prevent a perfect score.

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 and the schema is fully described (100% coverage, additionalProperties false), so there is no parameter documentation burden for the description. Per the rubric, a zero-parameter tool earns the baseline 4.

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 verb and resource: it returns the npm/CDN install for sqlguard-client and the wealth ladder (handshake → Pilot Challenge → Gateway → verify). It does not explicitly contrast itself with sibling tools such as sqlguard_client or sqlguard_gate, and the phrase 'Session/Instant OFF TABLE as primary' is cryptic, so it is not fully precise.

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 purpose implies when to use it: when a user needs installation commands or the upsell ladder. However, it gives no explicit when-not-to-use guidance, does not name an alternative sibling, and 'OFF TABLE as primary' is too vague to serve as a usable exclusion 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds context that this endpoint is legacy and not part of the primary buy path, but it doesn't explain what happens on invocation, what 'burn compatibility' involves, or any authentication/policy details beyond the cryptic doctrine.

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 short and front-loaded with the legacy/off-table status and the preferred alternative path. However, fragments like 'burn compatibility' and 'no_money_no_service' are jargon-heavy and may not be meaningful to every agent, slightly reducing clarity despite the compactness.

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

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

The tool has only one parameter, a rich output schema, and strong annotations, so the formal metadata carries much of the burden. Still, the description never defines the tool's actual function, leaving the purpose ambiguous; an agent cannot confidently select or invoke a tool when the description only explains what it is not and when to avoid it.

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 only one parameter and schema description coverage is 100%, so the schema already documents agent_id as 'Agent or wallet id that will own the session.' The description adds no further meaning about the parameter, leaving the baseline 3 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 never states what the tool actually does; 'Session Cert' is only labeled as legacy/non-wealth and 'kept for burn compatibility only.' This restates the title and gives a negative scope without defining the core action or resource, so an agent cannot tell what invoking it accomplishes.

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 steers agents away: 'Prefer sqlguard_challenge → Exact Pilot unlock $100 or Gateway invoice $299+.' It also states the only remaining use case ('burn compatibility only') and the policy 'no_money_no_service,' leaving little doubt about when to use this tool versus alternatives.

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 mark the tool readOnlyHint=true and destructiveHint=false, but the description says it 'opens a 7-day PASS window' and instructs the agent to 'Burn via POST /v1/session/cert + X-SQLGuard-Session.' Opening a window and burning a session cert imply state mutation/destruction, directly contradicting the annotations.

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

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

Three dense sentences front-load the scope ('Returning-wallet lane'), state the action, and give a minimal workflow. It is concise, though the protocol details could be clearer for a broader audience.

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

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

The description omits prerequisites for being a 'returning wallet,' what 'Exact USDC' means, and the meaning/reason for burning a session cert. The schema and output schema reduce some burden, but the conflicting safety annotations and opaque jargon leave an 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?

The single parameter agent_id is fully described in the input schema with 100% coverage ('Agent or wallet id that will own the sprint window'). The description adds eligibility context but does not materially extend parameter meaning, so the baseline applies.

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

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

The description states a specific action and result: 'Client Sprint opens a 7-day Ed25519 PASS window' in the 'Returning-wallet lane.' It is not a tautology and gives scope, though 'Exact USDC' and 'Workday/Pilot' are unexplained domain jargon.

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 clearly positions the tool as the 'Returning-wallet lane' and places it temporally 'between Workday and Pilot.' It also gives concrete follow-up steps ('Burn via POST /v1/session/cert... then sqlguard_verify before execute'), but it does not explicitly name alternatives or exclusion 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?

It adds a critical side effect beyond the annotations: this tool 'burns prepaid credits only.' It also warns not to execute FAIL or unverified certs. The cryptic 'OFF TABLE as wealth' phrase weakens clarity, but the cost behavior is meaningfully disclosed.

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 short, but the first clause 'OFF TABLE as wealth' is cryptic and does not earn its place. The routing guidance is front-loaded and useful, yet the jargon reduces overall 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?

For a credit-burning validation tool, it covers cost behavior, production routing, and a safety warning. Still, it does not clarify what the tool returns or what 'validated' means, and the legacy-vs-production distinction is only lightly sketched.

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

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

Schema description coverage is 100%, so the parameters are already documented in the input schema. The description adds no additional parameter-level detail, which matches the baseline for fully covered 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 identifies the tool as a 'Legacy prepaid burn path' and contrasts it with the production flow (sqlguard_challenge → sqlguard_verify), so an agent can place it among siblings. However, it never explicitly says the tool validates SQL; the core purpose is left to inference from the title and parameter descriptions.

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 routes production use to sqlguard_challenge and sqlguard_verify, and positions this tool as the legacy prepaid path. It does not fully enumerate when prepaid is appropriate, but the exclusion is explicit and actionable.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context by positioning verification as a mandatory gate and explicitly warning not to write if verification fails. This goes beyond the annotations without contradicting them.

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

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

Two short sentences deliver the essential requirement, the verification scope, and the failure behavior. The critical 'REQUIRED before production execute' warning is front-loaded, and no words are 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?

The tool has rich annotations, complete schema descriptions, and an output schema, so the description only needs to supply the operational context. It provides the mandatory-before-execute sequencing and the no-write-on-failure rule. For a 6-parameter tool with this level of structured metadata, nothing essential is missing from the description.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters, including accept_demo, expected_sql_hash, and expected_schema_hash. The description only echoes the certificate and signature concepts already present in the schema and adds no new parameter-level detail. 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 states a specific action ('Verify') and a specific resource ('Execution Certificate'), and further specifies what is checked: signature, expiry, and PASS. It also frames the tool as a required pre-production step, which differentiates it from sibling tools like sqlguard_validate that likely produce the certificate rather than verify it.

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 states when to use this tool: 'REQUIRED before production execute.' It also provides a clear conditional rule: 'If verify fails, do not write.' However, it does not name alternate tools or explicitly describe when not to use it, so it stops short of full usage-selection 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 the safety profile is covered. The description adds useful context: this is legacy, not recommended as a primary buy, and the old POST /v1/session/cert + verify flow still works. However, the meaning of 'burn' is ambiguous and no additional behavioral details like auth requirements, rate limits, or side effects are disclosed.

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 compact and front-loaded: it immediately signals legacy status and non-recommendation, then names alternatives, then states that endpoints still work. There is no filler, though the cryptic shorthand 'OFF TABLE' and 'burn' make it less polished than it could be.

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 unclear functional purpose, the description is incomplete for invocation. An agent learns that the tool is legacy and discouraged, but not what actually happens when it is called, how the result relates to the workday window, or what the expected outcome is. The mention of POST /v1/session/cert is an external endpoint clue rather than a full description of this tool's 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?

There is only one parameter, agent_id, and its schema description already explains that it is the agent or wallet id owning the workday window. With 100% schema description coverage, the tool description does not and does not need to add parameter-level detail. 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 identifies the tool as a legacy non-wealth job meter and clearly marks it as not the primary purchase path, but it never states a concrete action the tool performs, such as purchasing, activating, or reading a workday. It is more of a deprecation/policy label than a functional definition, so an agent is left to infer what calling sqlguard_workday actually does.

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 explicit negative guidance: it is 'OFF TABLE as primary buy' and directs the agent to prefer sqlguard_challenge for the exact $100 unlock or a Gateway invoice for $299. It also notes that legacy endpoints remain functional. This is strong routing guidance, though it never states a positive scenario in which sqlguard_workday should deliberately be selected.

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