SQLGuard — permission before production writes

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

Annotations already declare the tool as readOnlyHint=true and idempotentHint=true, so the agent knows it's a safe read operation. The description adds valuable context about the payment model ('Performance pay only — no upfront bounties') and the 'Instant remains taste-only' quirk, going 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?

The description is a single dense paragraph with several distinct pieces of information, but it uses cryptic jargon ('agent-native affiliate', 'taste-only') and lacks visual structure. While it is brief, the phrasing and odd formatting reduce clarity, making it only moderately 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?

The tool has a single optional parameter, strong annotations, and an output schema, so the description need not explain return values. It covers the referral mechanics and reward rates, but leaves ambiguity about what actually happens when the tool is invoked versus what the affiliate program entails, making it somewhat incomplete for a tool 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?

The single parameter 'wallet' is well-described in the schema ('Optional 0x wallet — if set, returns owed/paid status'), providing full schema_description_coverage. The description does not add extra parameter meaning, so a baseline score of 3 is appropriate since the schema carries the parameter 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 clearly states that this is an affiliate tool for earning $30 USDC per referred Pilot, with a specific referral mechanism (X-SQLGuard-Ref). It distinguishes from siblings by explicitly naming the 'PRIMARY' action and the exact reward structure, making the purpose unambiguous.

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

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

The description provides a clear context for when to use this tool: to refer Pilot Challenge unlock or Gateway Pilot with a referral code, earning a commission. It does not explicitly mention alternatives or exclusions, but the 'PRIMARY' directive gives strong usage context, aligning with a clear contextual guideline.

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. The description adds useful context about the tool being for legacy volume and explicitly not for production authorize, which 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?

The description is two concise sentences. It front-loads the core purpose and uses the second sentence for essential usage differentiation. Every word earns its place.

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

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

Given the tool's simplicity (one parameter, output schema present, annotations covering safety), the description fully addresses purpose, scope, and alternatives. The output schema handles return details, so no further explanation is 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 coverage is 100%, with the single parameter agent_id described as 'Agent or wallet id whose prepaid credit balance to read.' The description adds no extra parameter details, 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 clearly states the specific action and resource: 'Check prepaid credit balance (legacy volume).' It also distinguishes itself from sibling tool sqlguard_challenge by noting that tool is for production authorize, making the purpose unambiguous.

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

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

Explicit guidance is given on when to use this tool vs. alternatives: 'For production authorize use sqlguard_challenge — not prepaid micro.' This clearly states when not to use this tool and names the preferred alternative.

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 discloses a financial side effect ('pay Exact USDC once') and a state-changing action ('free sqlguard_gate before execute'), which directly contradicts the annotations readOnlyHint=true and destructiveHint=false. This is a serious transparency failure.

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, naming the endpoint and action in the first clause. It avoids filler, but is dense with specialized jargon (ABMP, AP2, Ed25519, mandate_hash) which may obscure meaning for less familiar agents.

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 involves payment, hashing, and gate release, the description is too sparse. It omits prerequisites, payment amount/source, what happens without exact USDC, and the nature of the gate-freeing side effect. The contradictory annotations further impair completeness; output schema helps with return values but not process 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 input schema has 100% coverage with descriptions for all four parameters, so the baseline is 3. The description adds context around `mandate` (hashed into the Ed25519 certificate) but does not meaningfully enhance understanding of `sql`, `schema_ddl`, or `agent_id`. It does not compensate beyond the 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 identifies the core action (ABMP BIND) with endpoint and mechanism (POST /v1/bind, Ed25519 certificate, mandate_hash), making the tool's purpose identifiable. However, it mixes several verbs (pay, hashes, free) and does not clearly differentiate from sibling tools like sqlguard_cert or sqlguard_gate beyond the workflow mention.

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

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

It gives a clear sequencing cue ('Then free sqlguard_gate before execute'), implying when to use this tool in a multi-step flow. But it doesn't explicitly state when to use it versus alternatives or any exclusion conditions, so 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?

Annotation contradiction: readOnlyHint is true, but the description says 'Buy credits' and implies a purchase action, which is a write operation. The description also fails to explain what 'OFF TABLE as wealth' means or what actually happens when the tool is called, so it adds no useful behavioral context beyond the conflicting annotation.

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

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

The description is concise with three short sentences, but the first sentence is a fragment with unclear jargon ('OFF TABLE as wealth'), which slightly reduces clarity. However, it is still efficient and front-loaded with the legacy warning.

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

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

The description covers the legacy status and usage guidance, but the annotation contradiction and unexplained 'OFF TABLE' leave gaps. The output schema exists, so return values need not be described, but the tool's actual behavior is unclear given the read-only hint versus the buy action.

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 provides 100% coverage with descriptions for both parameters. The description adds meaningful context by noting that the offered bundles are only for volume validates, giving semantic guidance about when each enum value is appropriate.

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

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

The description clearly states the tool is for buying legacy prepaid credits with specific verb and resource. It distinguishes itself from sqlguard_challenge by labeling itself as legacy and directing users to alternatives, making its purpose unambiguous relative to 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 explicitly tells the agent to prefer sqlguard_challenge (Exact $100 unlock) or Gateway invoice $299, and states that the bundles are only for volume validates, not standard authorization. This gives clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds a legacy status, the output type (credit bundles + buy URLs), and the caveat 'not the authorize standard' — all useful beyond the structured annotations. However, terms like 'volume validates' and 'x402' are not fully explained, so it falls short of a 5.

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

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

The description is a single, dense sentence that packs legacy status, differentiation, and output details. It is not overly long, but the heavy use of abbreviations and jargon makes it less immediately parseable. Still, every clause earns its place and it is reasonably 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 tool has no required parameters, a rich annotation set, and an output schema, the description provides enough context for basic invocation. It clarifies the relationship to sibling tools and the legacy nature. Minor gaps like the meaning of 'volume validates' and 'authorize standard' prevent a perfect score, but it is largely complete.

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

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

The tool has zero parameters, so there is no parameter behavior to clarify. The schema coverage is 100% (trivially), and the description adds context about the output. With no parameters, a baseline of 4 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 uses a clear verb ('Returns') and specifies the resource ('credit bundles + x402 buy URLs') and scope ('volume validates only'). It also distinguishes itself from siblings by explicitly positioning as 'LEGACY' and 'not the authorize standard,' which prevents confusion with similar tools.

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

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

It explicitly instructs the agent to prefer alternative tools ('Prefer sqlguard_handshake then sqlguard_challenge'), and labels the tool as 'LEGACY prepaid catalog (OFF TABLE as wealth/primary)' which strongly signals it should not be used as a primary option. This provides clear when-to-use and when-not-to-use guidance.

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

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

The description adds useful context beyond the annotations: it discloses a cost ('$0.05'), a legacy/deprecated status, and a mandatory verification step. Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The added cost and workflow requirements are valuable behavioral details.

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 (three sentences) and front-loaded with the key qualifier 'LEGACY taste only.' Each sentence provides a distinct piece of information: legacy status, price, alternative paths, and verification. There is no fluff, though the brevity contributes to the opacity rather than 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?

The description provides pricing, legacy status, and a prerequisite, but it fails to explain what 'Instant Cert' actually does or when it should be invoked beyond vague 'legacy' scenarios. The output schema exists, so return values are not needed, but the overall purpose and usage context remain incomplete due to heavy jargon and lack of plain-language function.

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 provides 100% coverage, describing each parameter (sql, agent_id, schema_ddl) with clear definitions. The description does not add any additional parameter-level meaning, only mentions 'Exact' in relation to the cert, which is ambiguous. The baseline of 3 is appropriate because the schema carries the parameter-semantics burden.

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

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

The description never explicitly states what the tool does. It uses cryptic jargon like 'LEGACY taste only' and 'Instant Cert' without defining what a certificate is or what action it performs. The title says 'Instant Cert' but the description doesn't clearly say 'issues a certificate for SQL' until you cross-reference the schema fields. As a result, an agent cannot confidently infer the tool's core function from the description 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 gives explicit guidance on when NOT to use this tool: it's 'LEGACY taste only' and 'OFF TABLE as wealth/primary,' pointing to alternative wealth paths via sqlguard_challenge or Gateway. It also instructs to use sqlguard_verify before execute. This provides a clear conditional context, even though the phrasing is obscure.

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 provide readOnlyHint, openWorldHint, idempotentHint, and non-destructive flags; the description adds concrete context such as the free challenge returning DENY+deny_id, the exact unlock amount, and Probe's non-authorizing nature. No contradiction exists because the described POSTs are external endpoints, not the tool's own state mutations.

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 every sentence contributes distinct information: primary path, challenge response behavior, unlock terms, and alternatives/probe caveat. It is front-loaded with 'PRIMARY agent buy path.' The telegraphic, jargon-heavy style slightly reduces scannability, but it avoids waste.

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

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

Given the rich annotations, 100% schema coverage, and existing output schema, the description adds critical missing context: exact payment amount, duration, alternative price tiers, and probe limitations. This is sufficient for an agent to decide when and how to invoke the challenge/unlock flow. Omitted details like authentication are not essential given openWorldHint.

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 covers 100% of parameters with meaningful descriptions (sql preview, agent_id, schema_ddl). The tool description does not add significant parameter-level detail beyond the schema; it mentions the unlock amount but that is not a parameter. Baseline 3 is appropriate since the schema does the semantic heavy lifting.

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 the 'PRIMARY agent buy path' and details the specific challenge/unlock protocol, including the exact $100 USDC unlock and resulting 500 PASS / 7d. It also distinguishes from Gateway invoice and Probe alternatives. However, it relies on telegraphic endpoint references rather than a clean declarative verb+resource statement, which slightly reduces clarity.

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 labels this as the primary buy path, lists an alternative Gateway invoice path with price tiers, and clarifies that Probe is free but never authorizes. This gives an agent useful selection cues relative to sibling tools. It could more directly reference sibling tool names, but the guidance is clear enough.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive). The description adds meaningful behavioral context: it classifies wallets, explicitly excludes operator wallets, and lists the specific return values. This goes beyond what annotations provide, though it does not discuss edge cases or error handling.

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

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

The description is a single, well-structured sentence that front-loads the verb and packs in the key details (classification, exclusion, return values) without any wasted words. It is concise and complete.

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

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

The tool is simple (one parameter) and has an output schema, so the description need not explain return values in detail. It covers the core purpose and key behavioral nuance (exclusion of operator wallets). It could clarify domain terms like 'prior Exact-paying client' or 'ladder step,' but the output schema likely fills those gaps.

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

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

The schema has 100% parameter description coverage for the single parameter (agent_id), so the baseline is 3. The description adds no additional parameter semantics beyond the schema, simply restating that it takes an agent/wallet id.

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

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

The description uses a specific verb ('Classifies') and a specific resource ('agent wallet'), and clearly states the output ('lifetime USD, sku counts, and next ladder step'). It also distinguishes itself from sibling tools by focusing on Exact-paying client classification, which is unique among the listed sqlguard_* tools.

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

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

The description implies usage (classify a wallet to determine client status) but does not explicitly state when to choose this tool over siblings or mention any exclusions beyond 'excluding operator wallets.' No alternatives are named, so guidance is only implied.

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

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

Annotations already mark this as read-only, idempotent, and non-destructive. The description adds the endpoint and 'open' scope, but phrases like 'Instant taste-only; Probe free' are ambiguous and do not clearly disclose behavioral traits.

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

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

The first sentence is concise, but the second and third sentences are cryptic and likely to distract rather than inform.

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

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

The tool is simple (one optional param, output schema, safe annotations), but the cryptic supplemental instructions raise more questions than answers, making the description incomplete for effective 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 single parameter base_url is fully described in the schema, and the description adds no parameter-specific information. Baseline 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 first sentence clearly states 'List open DENY inventory from GET /v1/denials', providing a specific verb and resource. However, the subsequent sentences introduce unrelated unlock and session information, which could confuse the agent about the tool's primary 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?

No explicit guidance on when to use this tool versus siblings. The mention of unlock methods and legacy session claims appears tangential and does not clarify the tool's appropriate use case.

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, which covers the safety profile. The description adds the specific semantic guarantee (exact settle success ≠ listing freshness) but does not disclose return format, failure behavior, or other side effects. With annotations in place, the added context is useful but not extensive.

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, consisting of two sentences that front-load the core concept ('Free effects prover') and then provide a pointer and use case. Each sentence earns its place, though the cryptic wording reduces immediate comprehensibility. It is appropriately sized for a no-parameter tool.

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

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

The tool has no output schema, so the description should explain what the tool returns or provides. The description mentions the endpoint and the honesty-check context but does not state what the agent will receive after invocation (e.g., a boolean, a proof, data). Given the low complexity (no params) and presence of annotations, it is somewhat complete but leaves a significant gap regarding the output.

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 trivially covered (100%). With no parameters to describe, the baseline is 4, and the description does not need to add parameter-level detail. There is no ambiguity to resolve.

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 action ('prover') and resource ('effects', GET /v1/effects), but its meaning is obscured by domain jargon ('Settle≠discovery', 'Bazaar/catalog listing freshness'). It doesn't clearly state in plain terms what the tool does, making it difficult for an unfamiliar agent to understand. It partially distinguishes from siblings by focusing on effects, but the vague terminology limits clarity.

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 'CDP/Bazaar honesty checks on Session/Cert' but does not explicitly state when to use this tool over the many sibling tools or provide exclusions. The intended context is present but not articulated as direct guidance, so it remains at the 'implied usage' level rather than giving clear instructions.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds valuable behavior: fail-closed behavior on validation failure, 'Issues nothing' confirming no side effects, and the conditional mandate parameter when BIND. These details help the agent understand exactly what happens when the gate is invoked.

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

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

The description is two sentences long and front-loaded with the tool's identity and purpose. It includes the endpoint, required inputs, usage context, and behavioral outcome without any 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?

With an output schema present and annotations covering safety, the description sufficiently covers the tool's purpose, usage timing, failure behavior, and conditional parameters. No important aspects of the tool's behavior are missing for a pre-execution authorization gate.

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 each parameter already well-documented (e.g., 'Exact SQL about to execute (must match sql_hash)', 'Ed25519 signature'). The description adds only a brief summary of the parameter combination ('certificate+signature+sql (+ mandate when BIND)'), which provides no new semantic information 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 clearly identifies the tool as an authorization gate ('ABMP GATE — free portable authorize bus') with a specific endpoint (POST /v1/gate) and inputs. It distinguishes itself from sibling business tools by stating that 'any mutating agent tool fail-closes here before execute,' marking it as the pre-execution checkpoint.

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 the tool ('before execute' for mutating agent tools) and provides clear context that this is a mandatory gate. It does not name alternatives, but the 'fail-closes here' phrasing implies it is the required authorization step, making the usage context unambiguous.

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 non-destructive behavior. The description adds that it pulls everything 'in one call', is a 'free discovery magnet', and mentions alternative behavior of Probe/Instant. However, phrases like 'LEGACY OFF TABLE' and 'taste-only' are cryptic and not explained, reducing the practical transparency beyond 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 front-loaded with the main purpose and fairly brief. However, it is fragment-heavy and includes unexplained jargon ('Pilot Challenge Exact $100 wealth unlock', 'LEGACY OFF TABLE', 'taste-only'), making it less clean and structured than ideal.

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 an output schema and good annotations, the description provides a usable but incomplete context. Key terms like 'Pilot Challenge Exact $100 wealth unlock' and 'LEGACY OFF TABLE' are not defined, and there is no explicit statement of when to invoke this tool versus related siblings.

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

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

The tool has 0 parameters and schema coverage is 100%, so there is no parameter surface for the description to clarify. The 0-parameter baseline of 4 applies, and the description adds no conflicting or misleading 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 uses a specific verb ('Pull') and identifies concrete resources ('ranked open DENYs + Pilot Challenge Exact $100 wealth unlock', 'Denial Exchange inventory'). This makes the main function clear, but it does not explicitly contrast with sibling tools like sqlguard_denials or sqlguard_challenge, 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?

The description implies usage as a 'Free discovery magnet' and mentions that Probe remains free/not authorized and Instant remains taste-only, giving some comparative context. However, it never explicitly states when to use Gravity versus alternatives or lists exclusions, leaving usage guidance implied rather than 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?

Annotations already declare readOnly, idempotent, non-destructive; description adds context about being the first tool and the routing outcomes, including specific endpoints for challenges, without contradicting 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?

Description is compact yet dense, with each clause providing actionable routing or usage information; no fluff.

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

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

Given it's a simple handshake tool with full schema and output schema, the description covers purpose, routing, exclusions, and proper ordering relative to other tools.

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

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

Schema covers both parameters fully (need with examples, agent_id for routing context). Description reinforces need as a one-sentence intent and adds the important insight that the need value determines routing, which is not in the schema.

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

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

States clearly it is the 'FIRST tool on connect' and 'Asks: What do you need?' establishing its role as an initial intake/routing tool. It distinguishes from siblings by its position and explicit routing directives.

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

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

Provides explicit when-to-use guidance: 'FIRST tool on connect', 'Call before sqlguard_catalog when unsure', and gives conditional routes for various needs (org/migrate/mutate/production → sqlguard_challenge, company invoice → /gateway). Also states what is off-table (Session/Cert).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds 'opens 7d / 500 PASS' and 'Burn via POST /v1/session/cert + verify,' but these are unexplained and may even conflict with readOnlyHint (opening a window suggests a state change). No clear account of what happens, side effects, or required auth is given. The cryptic 'burn' step could imply destruction, but the description does not reconcile it with the non-destructive annotation.

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

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

The description is a collection of fragmented phrases rather than a structured explanation. It is not front-loaded with the primary purpose; instead it leads with unclear references like 'Wealth Exact alt.' While it is short, the density of unexplained terminology makes it inefficient and confusing. Every phrase does not earn its place because most require external context to interpret.

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 an output schema but the description is completely inadequate for an agent to decide when to invoke it. It fails to explain what a 'pilot' is, what '500 PASS' means, what the relationship to 'Wealth Exact' is, or what 'Burn via POST /v1/session/cert + verify' entails. The cryptic references to 'Session/Workday OFF TABLE' and 'Invoice alt $299/mo' leave the tool's behavior and domain almost entirely unexplained, making it impossible to use correctly without external documentation.

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% for the two parameters (agent_id, company), both with descriptions. The tool description adds no extra meaning about how these parameters relate to the pilot or how to set them. Baseline 3 is appropriate because the schema already handles parameter semantics; the description does not compensate with additional context.

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

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

The description does not clearly state a verb + resource. It opens with 'Wealth Exact alt' and 'Exact USDC $100.00 opens 7d / 500 PASS,' which is cryptic jargon. There is no explicit statement like 'creates a pilot' or 'activates a gateway.' It vaguely suggests an alternative or pilot, but the core purpose is obscured. It does reference sibling tools, but not in a way that clarifies its own role.

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 one explicit alternative: 'Prefer sqlguard_challenge when you have a DENY.' It also hints at exclusions with 'Session/Workday OFF TABLE as primary.' However, these are terse and assume domain knowledge. It does not clearly state when this tool should be used, prerequisites, or how to decide between it and other siblings beyond the DENY condition.

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

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

Beyond annotations (readOnly, non-destructive), the description discloses that no Execution Certificate is issued, that CDP Bazaar may retain stale paid rows, and that Session/Cert is 'OFF TABLE as primary.' These are non-obvious behavioral details not captured by the annotations, significantly enhancing 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 a dense, jargon-laden block lacking clear structure. Phrases like 'CDP Bazaar may retain a stale paid row; Fly wire is free' and 'Session/Cert OFF TABLE as primary' are confusing and do not contribute to tool invocation clarity. While short, it is not effectively concise or well-organized.

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 presence of an output schema and annotations, the description adequately covers key non-obvious aspects: no Execution Certificate, authorization path via sqlguard_challenge, potential stale data, and a reference to GET /v1/effects. It misses an explicit 'when not to use' statement, but overall provides sufficient context for a risk-tip 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?

With 100% schema coverage, the baseline is 3. The description adds meaningful specificity to the sql parameter by enumerating risk patterns (DROP/TRUNCATE/DELETE-without-WHERE) and reinforcing the 'risk-score not authorize' nature. It doesn't elaborate on agent_id or schema_ddl, but they are self-explanatory from the schema.

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

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

The description clearly identifies the tool as a free risk tip for mutating SQL (DROP/TRUNCATE/DELETE-without-WHERE) and explicitly states it never issues an Execution Certificate, distinguishing it from authorization-focused tools like sqlguard_challenge. The title 'Free risk tip (not authorize)' reinforces this specific purpose.

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 implies usage for risk assessment before authorization, and explicitly mentions sqlguard_challenge as the subsequent authorization step. However, it lacks explicit 'use when' or 'do not use' statements relative to other siblings, and the phrase 'Session/Cert OFF TABLE as primary' is cryptic, preventing a perfect score.

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 idempotent behavior. The description adds cryptic phrases like 'Probe free/not authorize' and 'Bind $0.05 mandate', but these are unclear and do not disclose concrete behavioral traits such as auth requirements or side effects beyond what annotations state.

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 suffers from fragmented grammar and unexplained jargon. It front-loads 'Machine Profit OS' but the rest is a set of terse directives that are difficult to parse.

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

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

Even with no parameters and an output schema, the description fails to explain the tool's core function or return value. The cryptic constraints make it incomplete for an agent to understand when and why to invoke this 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?

The tool has zero parameters, so the schema covers everything. The description does not need to explain parameters, and the baseline is 4; no additional parameter information is provided or required.

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 does not state what the tool does; it provides directives like 'wealth ONLY Pilot Challenge Exact $100 unlock' and 'Bind $0.05 mandate' without an action verb. The title hints at a profit system, but the purpose is left ambiguous.

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 names 'Session/Workday/Cert OFF TABLE as primary', telling the agent not to use those sibling tools as primary alternatives. It also instructs 'Call before picking a SKU when optimizing spend/friction', giving a specific scenario for using this tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that the tool returns specific content (rules, wealth path, invoice amount, guidance) and notes LEGACY Session/Workday OFF TABLE as primary, which provides some behavioral context beyond annotations. However, these references are cryptic and not fully explained, so the added transparency is partial.

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

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

The description is concise, with two sentences that cover the protocol identity, key returns, and sharing purpose. It is front-loaded with the tool's role ('ABMP normative protocol') and avoids redundant text. Slight deduction for jargon density ('Pilot Challenge Exact $100 wealth path', 'LEGACY Session/Workday OFF TABLE') that could confuse the reader, but overall it 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?

Despite having an output schema and annotations, the description is insufficient for fully understanding the tool's behavior. Terms like 'Pilot Challenge Exact $100 wealth path', 'Gateway invoice $299', and 'LEGACY Session/Workday OFF TABLE' are unexplained, leaving the agent uncertain about what the tool actually returns or how it relates to specific workflows. The description provides a high-level overview but omits critical context for a non-trivial protocol 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?

The tool has zero parameters, and the schema confirms this with no properties. According to the rubric, the baseline for 0 parameters is 4. The description does not need to explain parameters, and it does not. No deduction is warranted since there are no parameter semantics to clarify.

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 the ABMP normative protocol with SQLGuard as the reference implementation, and states it returns MUST/MUST_NOT rules and guidance. This distinguishes it from sibling tools like sqlguard_probe or sqlguard_validate, which likely perform specific actions. However, it lacks a strong action verb (e.g., 'provides', 'documents') and is a bit abstract, so not 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?

The description implies the tool is for sharing protocol rules with other agent runtimes ('Share with other agent runtimes') and mentions 'free Probe-not-authorize guidance', which hints at a comparison with sqlguard_probe. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or prerequisites. Usage context is implied but not clearly delineated.

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 destructiveHint=false, but the description adds meaningful behavioral context beyond them: it is 'fail-closed,' blocks SQL write tools, and 'Returns compliance_loop + buy URLs.' This helps an agent understand the tool's safety posture and outcome without 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?

The description is four short sentences, each providing essential information: type, blocking behavior, exclusions, and return value. It is front-loaded with 'fail-closed policy' and avoids fluff. Some phrasing like 'Session/Cert OFF TABLE as primary' is cryptic but concise, so it loses a point for clarity while remaining 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 policy tool, the description covers the core purpose, the exact gating condition, and the expected return values. An output schema exists, so return details need not be fully restated. Minor gaps like what 'PASS + verify' entails procedurally keep it from being perfect, but it is sufficiently complete for an agent to invoke it correctly.

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

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

The input schema is empty with zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and the schema coverage is 100%. No additional parameter information is necessary.

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

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

The description clearly states the tool is an 'Embeddable ABMP fail-closed policy' and specifies its action: 'Agent runtimes MUST block SQL write tools until Pilot Challenge Exact $100 unlock (or Gateway invoice $299) PASS + verify.' This is a specific verb+resource+condition that distinguishes it from sibling tools like sqlguard_affiliate or sqlguard_balance, which have different purposes.

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 explains when to use this tool: before SQL write tools are allowed, until a payment/verification condition passes. It also provides a when-not: 'Session/Cert OFF TABLE as primary,' which excludes alternative payment/certification paths. This gives clear context for choosing this policy over siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds that it returns install information and the ladder, but does not disclose any potential side effects, permissions, or rate limits, which is acceptable given 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 brief, but the second sentence 'Session/Instant OFF TABLE as primary' is confusing and appears to add more noise than clarity. It could be omitted or explained better.

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 present, the description gives a good overview of what is returned (install and ladder). However, the cryptic reference to session/instant leaves some ambiguity about the tool's exact role.

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 accepts zero parameters, so the input schema is empty. The description adds overall purpose but no parameter-specific details, staying at the baseline for no-parameter tools.

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 the specific verb 'Returns' and clearly identifies the resource as npm/CDN install for sqlguard-client, plus the wealth ladder. This distinguishes it from sibling tools like sqlguard_client or sqlguard_handshake by focusing on installation and upsell sequence.

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 guidance on when to use this tool versus alternatives. The phrase 'Session/Instant OFF TABLE as primary' is opaque and does not clarify usage context or exclusions.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds policy context like 'Doctrine: no_money_no_service' and 'burn compatibility,' but these are more about commercial gating and legacy status than technical behavior. There is no contradiction with annotations, but the description does not disclose what actually happens when the tool is invoked (e.g., what a session cert is, whether it returns a token).

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 (two sentences) but uses cryptic, informal jargon like 'OFF TABLE,' 'burn compatibility,' and 'Doctrine.' While it front-loads the critical legacy status, the lack of clarity and structure makes it less effective than a clean, straightforward explanation. It is concise in word count but not in communicative efficiency.

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

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

For a one-parameter tool with an output schema, the description still under-specifies functionality. It never explains what a 'Session Cert' is, what 'burn compatibility' requires, or what the tool actually returns. The heavy focus on deprecation and pricing leaves gaps for an agent trying to understand the tool's behavior and prerequisites. The output schema may cover return values, but the description does not provide enough operational 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?

Schema description coverage is 100% for the single parameter agent_id, described as 'Agent or wallet id that will own the session.' The description adds no additional meaning about the parameter syntax, format, or constraints. Baseline of 3 is appropriate because the schema fully documents the parameter.

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 does not clearly state what the tool does; it focuses on its legacy/deprecated status ('LEGACY / OFF TABLE') and commercial positioning ('$0.25 / 10') rather than a specific verb+resource. The title 'Session Cert' and name 'sqlguard_session' hint at issuing a session certificate, but the description never explicitly describes the function. It is closer to a deprecation notice than a purpose statement.

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

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

The description explicitly tells the agent when NOT to use this tool and provides clear alternatives: 'Prefer sqlguard_challenge → Exact Pilot unlock $100 or Gateway invoice $299+.' It also states 'Endpoint kept for burn compatibility only,' which clearly defines the only use case. This is excellent guidance that distinguishes it from 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?

The description says 'Burn via POST /v1/session/cert + X-SQLGuard-Session', which implies a destructive/consuming action, directly contradicting the readOnlyHint=true and destructiveHint=false annotations. It also fails to disclose side effects or state changes.

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 brief but includes a fragment ('Returning-wallet lane.') and cryptic syntax ('Exact USDC', 'Burn via...'). It mixes purpose and usage instructions in a way that is not well structured, though it is short.

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?

Even with annotations and a one-parameter schema, the description is insufficient: it does not explain what a 'PASS window' is, what 'between Workday and Pilot' means, or what the output represents. The contradiction between the described 'burn' action and the readOnlyHint further undermines completeness.

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

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

The input schema already has 100% coverage for the single parameter agent_id, with a clear description ('Agent or wallet id that will own the sprint window'). The tool description adds no additional parameter-level meaning, so the baseline score 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 states a specific action ('opens a 7-day Ed25519 PASS window') but relies on unexplained jargon such as 'Returning-wallet lane', 'Workday', and 'Pilot'. It does not clearly differentiate this tool from siblings like sqlguard_session or sqlguard_pilot, making the purpose ambiguous for an agent.

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 context ('Returning-wallet lane', 'between Workday and Pilot') and instructs to 'then sqlguard_verify before execute', but it does not explicitly state when to use this tool versus alternatives, nor when not to use it.

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 annotations (readOnlyHint false, destructiveHint false) the description adds crucial behavioral context: it burns prepaid credits, a financial side-effect not captured by annotations. The safety warning 'Never execute FAIL or unverified certs' also adds risk disclosure. 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 concise at three sentences and front-loads the key identity as 'Legacy prepaid burn path'. Every sentence contributes, though terms like 'OFF TABLE as wealth' are cryptic and slightly wasteful. Overall compact and structured well.

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 exists and parameters are fully described, the description covers the tool's role in a broader flow, its legacy status, and safety warnings. It is complete enough for an agent to decide when to use it, despite some cryptic phrasing that could confuse.

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 schema already explains each parameter (agent_id, schema_ddl, sql). The description adds no extra meaning beyond noting 'prepaid credits to debit' and 'Exact $100 unlock' for the production path, but does not enhance 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 identifies the tool as a 'Legacy prepaid burn path' that 'burns prepaid credits only', suggesting it validates SQL via credit burn. However, the exact action ('validate SQL') is only in the title, and the description's focus on 'burn path' and 'OFF TABLE as wealth' obscures what the tool actually does. It distinguishes from production siblings but remains vague about the core 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?

Explicit usage guidance is provided: 'For production authorize use sqlguard_challenge → Exact $100 unlock → sqlguard_verify' directly names alternatives and states when not to use this tool. It also warns 'Never execute FAIL or unverified certs', giving clear boundary 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?

Annotations already declare read-only and non-destructive behavior. The description adds valuable workflow constraints: it must run before production execution and instructs not to write if verification fails. This goes beyond the annotation-provided safety profile without contradicting it.

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 succinct sentences, front-loaded with the critical 'REQUIRED' note. Every sentence provides meaningful information without waste.

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

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

With a rich output schema and full parameter descriptions, the tool is well-documented. The description adds the essential workflow context and conditional behavior, making it complete enough for a verification tool of this complexity.

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

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

Input schema covers all 6 parameters with descriptions (100% coverage), so the baseline is 3. The description itself does not elaborate on parameter semantics, leaving the schema to carry the full burden, which it does adequately.

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

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

The description clearly states the tool verifies an Execution Certificate's signature, expiry, and PASS status. The 'REQUIRED before production execute' context differentiates it from sibling validation tools, making the purpose specific and unambiguous.

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

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

Explicitly states when the tool is required ('before production execute'), providing strong usage context. However, it does not mention when not to use it or alternative tools, so it falls short of a 5.

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

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

The description says to 'burn via POST /v1/session/cert,' implying a consuming or writing operation, while annotations declare readOnlyHint=true and destructiveHint=false. This is an annotation contradiction. No additional side-effect, auth, or reversibility context is 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-loaded with the key decision signal ('LEGACY', 'OFF TABLE as primary buy') and alternatives. The second sentence is packed with useful legacy status but uses cryptic jargon ('burn via POST...') that reduces clarity, though every clause earns its place.

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

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

The description reads more like a deprecation notice than a definition of what the MCP tool does with agent_id. Despite having rich annotations and an output schema, it leaves the core function ambiguous and does not explain the tool's own behavior or return semantics.

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 fully covers the single required agent_id parameter (100% schema coverage), so the description does not need to add much. It adds no extra semantics about how agent_id should be used or formatted, so the 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 says 'Endpoints remain; burn via POST /v1/session/cert + verify still works,' but it never clearly states a verb+resource for what invoking this MCP tool does. The closest action, 'burn via POST,' refers to an HTTP endpoint rather than the tool's own behavior.

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?

Explicitly says not to use it as a primary buy and names concrete alternatives: 'Prefer sqlguard_challenge (Exact $100 unlock) or Gateway invoice $299.' It also notes that legacy endpoints remain, giving clear guidance for when it can still be used.

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