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

With no annotations, the description carries the full burden and does so well. It discloses that this is the only on-chain step, that it costs gas, that it should happen once, that empty balances cause payment refusal, and what the return values are. This is far beyond a bare 'deposit' statement.

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 efficiently structured: clear purpose paragraph, workflow guidance, prerequisite, and a returns summary. Every sentence adds useful information and nothing feels like filler or tautology.

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 3-parameter tool with no output schema, the description is complete: it explains the purpose, the workflow position, gas implications, the private key requirement, parameter nuances, and the exact return fields including units. An agent has enough to invoke it correctly and interpret the result.

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 the schema already documents amount, rpc_url, and at_least with units and defaults. The description reinforces the decimal-string format and USDC smallest-unit convention, but mostly repeats what the schema already provides. 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 opens with a specific verb and resource: 'Deposit USDC into Circle Gateway on Arc', and immediately states the downstream purpose (paying for proofs via nanopayments). This clearly distinguishes it from the sibling tools like gateway_balance and generate_proof, which serve different steps in the workflow.

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 when-to-use guidance: 'Do this ONCE, not per proof' and explains why, including gas cost and refusal of payments against an empty balance. It also notes the PAYMENT_PRIVATE_KEY requirement. It does not explicitly name an alternative sibling, but the situational guidance is concrete enough to route an agent correctly.

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

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

With no annotations, the description carries the behavioral burden and does meaningful work: it discloses that the operation reads a current balance, specifies USDC base units, and states the required private key. It does not explicitly say the call is read-only, but the wording strongly implies a non-mutating balance lookup.

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

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

Two compact sentences with no filler: the first states the tool's purpose and its relationship to nanopayments, and the second packs in unit semantics and an authentication requirement. 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 one-optional-parameter read tool, the description covers purpose, units, and auth. However, because there is no output schema, it does not specify the exact response shape or field name, and it does not address edge cases like an invalid key or missing gateway balance.

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 only parameter, rpc_url, is fully documented in the schema with its type and default value, so schema coverage is 100%. The description adds no parameter-specific detail, which aligns with the baseline score for high 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 clearly identifies the tool as reporting the buyer's current balance inside Circle Gateway on Arc and notes this is the balance nanopayments draw against. It distinguishes itself from deposit_to_gateway and proof-flow siblings, though it lacks an explicit imperative verb like 'get' or 'fetch'.

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

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

Usage is implied: call this when you need the current balance that nanopayments draw against. It also states a prerequisite (PAYMENT_PRIVATE_KEY), but it never explicitly says when to use this instead of deposit_to_gateway or other alternatives, nor provides exclusions.

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

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

With no annotations, the description carries full behavioral disclosure. It explains that the tool is a composite flow, returns either awaiting_approval or a full ProofResult with timing info, and requires human approval for action-bound proofs while ordinary proofs auto-sign. It also notes that ATTESTATION_KEY cannot authorize actions, which is a critical limitation. This is thorough and goes beyond basic 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 lengthy but well-structured with clear sections (CIRCUITS, WITH ACTION, RETURNS) and front-loaded with the core purpose. The length is justified by the complexity of the tool (12 parameters, 5 circuits, action approval flow). It is not wasteful; every section contributes necessary information.

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

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

For a tool with 12 parameters, nested objects, multiple circuits, and a two-step approval flow, the description covers all essential aspects: the combined operation, circuit-specific requirements, the action binding behavior, return types, and the separate verify_proof step. It is sufficiently complete for an agent to decide when to use it and how to handle the flows.

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 the description does not need to repeat parameter details. It adds value by tying parameters to circuits (e.g., 'Requires country_list and is_included' for coinbase_country, 'Requires jwt and scope' for oidc_domain) and by explaining the approval_id flow and the action parameter's role. This supplements the schema descriptions with cross-parameter 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 states a clear purpose: 'All-in-one ZK proof generation' that combines three steps (prepare inputs, request challenge, submit proof) in a single call. It explicitly differentiates itself from the individual step tools by naming them as alternatives for fine-grained control. The circuit list also clarifies the specific use cases.

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: 'Use this when you want the simplest path to a proof. For fine-grained control over each step, use prepare_inputs, request_challenge, and submit_proof individually.' It also provides circuit-specific requirements (e.g., coinbase_country requires country_list and is_included) and explains the action approval flow, including when to query get_action_approval and reuse approval_id.

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

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

With no annotations present, the description takes on the behavioral disclosure burden. It explicitly states the operation is read-only and has no side effects on proofs or payments, which is valuable for an agent deciding whether invocation is safe. It does not detail authorization requirements or possible returned statuses, but the core side-effect guarantee is clear.

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

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

Two short sentences with no filler. The primary purpose is front-loaded, and the safety-relevant negation is placed second to reinforce the read-only nature. Every word contributes value.

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

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

For a one-parameter read-only tool, this is largely complete: it identifies what the approval is, where its ID comes from, and that no proof or payment is initiated. It does not describe output fields, but no output schema exists and the tool's role as a status poller is adequately communicated through the sibling 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%, so the baseline is 3. The description reinforces that approval_id comes from generate_proof or prepare_inputs, but that same provenance detail also appears in the schema property description. No additional parameter semantics beyond the structured schema are provided.

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

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

The description opens with a specific action and resource: 'Read the status of a human wallet approval created by this MCP client.' This clearly separates it from sibling proof/payment tools, and the second sentence reinforces that it is not a proof-starting or payment-triggering operation.

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 for when to use the tool: after an approval has been created by this MCP client, to read its status. It also states a key exclusion ('never starts a proof or payment'), although it does not explicitly name alternative tools or define exact polling 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?

No annotations provided, so description must disclose behavior. It mentions no parameters required but does not state if it's read-only or any side effects. Minimal behavioral info, but acceptable for a simple listing tool.

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

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

Two sentences, no wasted words. Efficiently conveys purpose, output contents, and usage order.

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 zero parameters and no output schema, the description adequately covers purpose and guidance. Could mention output format or safety of repeated calls, but it's mostly 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?

No parameters defined; description adds value by explicitly stating 'No parameters required,' which reassures the agent. Baseline 4 for zero-parameter tools with 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?

Clearly states the tool lists all ZK circuits with specific details (verifier addresses and authorized signers). Distinguishes from siblings by being a discovery step before proof generation.

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 'Call this first to discover available circuits before starting proof generation,' which guides when to use it. Could be improved by specifying when not to use it or naming alternatives, but it's clear for a discovery tool.

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

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

With no annotations provided, the description carries the full burden and does so well. It discloses async behavior (returns awaiting_approval until resumed with approval_id), persistence semantics (witnesses stay in private local storage), the difference between action and no-action behavior, and a critical security caveat (never expose private witnesses to dApp/model/logs). This goes far beyond the schema.

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

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

The description is dense but well-organized, with WITH ACTION/WITHOUT ACTION framing and a clear security warning. It front-loads the tool's role in the flow. A few ideas are compressed into long sentences, but every sentence contributes necessary behavioral or sequencing information.

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

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

For a complex tool with 8 parameters, nested action objects, async approval, and no output schema, the description covers the essential runtime behaviors, sequencing, and security constraints. It partially describes return values (awaiting_approval, prepared_inputs_id) and the resume mechanismamazon. It does not enumerate all possible return fields or error cases, but the schema and flow context make it sufficient for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3 and the schema already documents every parameter. The description adds workflow-level meaning: jwt and scope are explicitly required for oidc_domain, approval_id resumes the same original action, and action maps to the WITH ACTION mode. This enriches but does not replace the schema detail.

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 this as 'Step 1 of the step-by-step flow' and explains its concrete role: producing a prepared_inputs_id to pass to submit_proof)SkipSignal. It also distinguishes itself from sibling tools by naming the required ordering ('Call this BEFORE request_challenge') and the handoff to submit_proof. The action/no-action modes further clarify what the tool 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 invocation conditions: WITH ACTION requires human wallet approval, WITHOUT ACTION retains existing signatures, and oidc_domain requires jwt and scope. It also states the correct ordering relative to request_challenge. It does not, however, explicitly say when to prefer sibling tools like get_action_approval or generate_proof, so guidance is strong but not fully exhaustive.

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

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

With no annotations provided, the description carries the full burden. It discloses security-relevant behavior: that the tool does not sign payments or encrypt inputs, and that '{}' prevents transmission of private witness data. It also highlights the server-side nonce issuance and its necessity for subsequent steps.

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 yet information-dense, with critical points front-loaded: step indication, the recommendation to use '{}', and the nonce requirement. Every sentence earns its place, covering purpose, usage, and security implications without redundancy.

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

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

Given the tool's moderate complexity (2 params, no output schema), the description provides comprehensive guidance on what the tool does, when to use it, how to use it safely, and what to do with the result (pass nonce to submit_proof). It also covers the alternative for paid/encrypted use, making it self-sufficient for an agent.

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

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

Even though schema coverage is 100%, the description adds crucial meaning: it explains that '{}' is sufficient for anonymous discovery, warns that providing witness data sends it to the prover and must be kept out of context/logs, and clarifies the circuit enum's purpose. This goes well beyond the schema's minimal descriptions.

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

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

The description clearly states it is 'Step 2 of the step-by-step flow: Request a challenge from the server' and specifies the resource and action. It distinguishes itself from siblings like submit_proof by explaining its role and the critical dependency on the returned nonce.

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 recommends passing '{}' to avoid transmitting private data, warns against using submit_proof for signing, and directs to generate_proof or the SDK for paid/encrypted flows. This provides clear when-to-use and when-not-to-use guidance with specific 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?

With no annotations, the description carries the full burden of behavioral disclosure, and it delivers: it states the TEE server runs the Noir circuit, the operation takes 30-90 seconds, Prover.toml is built from inputs, the response is an UltraHonk proof, and omitting the nonce triggers a fresh 402 challenge. This is strong, concrete behavioral transparency for a no-annotation tool.

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

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

The description is front-loaded with its purpose and structured as a short overview followed by a critical usage warning. It is not bloated, though the first paragraph mentions the TEE server twice ('runs the Noir circuit' and 'builds Prover.toml'), which is a minor redundancy. Otherwise, every sentence contributes useful information.

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

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

For a tool with no annotations and no output schema, the description covers workflow position, prerequisites, latency, a failure mode, and the expected result type. The schema covers the parameter-level details such as the choice between `inputs` and `prepared_inputs_id`. It is not exhaustive about the exact response shape, but it gives enough context for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already documents `nonce`, `inputs`, `circuit`, and `prepared_inputs_id` with their constraints. The description adds emphasis that the nonce is mandatory and that the server builds Prover.toml from inputs, but it does not add substantial new parameter-level meaning. A 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 opens with 'Step 3 of the step-by-step flow' and a specific verb+object: 'Submit prepared inputs to generate the ZK proof.' It clearly identifies the resource (prepared inputs) and the outcome (UltraHonk proof). However, it does not explicitly contrast itself with the sibling `generate_proof`, so differentiation is implicit rather than direct.

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 clear positional context ('Step 3'), names the required prerequisite inputs (prepared inputs, nonce from request_challenge), and states the hard requirement to include the nonce. The warning about the 402 challenge tells the agent when a submission cannot succeed. It does not enumerate alternatives or when-not-to-use, but the step-based context is sufficient for 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?

With no annotations, the description must disclose all behavioral traits. It states the tool verifies on-chain and returns a success object, but does not mention potential gas costs, network dependencies, failure responses, or side effects.

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

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

The description is three sentences with no wasted words. It front-loads the purpose and incrementally adds context on how to use the tool and what to expect.

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 nested object parameter and lack of output schema, the description effectively covers the main use case and expected return for a valid proof. However, it omits error handling, edge cases, and a full return structure 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 input schema has 100% coverage with descriptions for all properties. The description adds value by explaining to pass the result object directly, but it reinforces usage rather than adding new semantic meaning beyond 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 states the tool's action ('Verify a ZK proof on-chain'), the specific resource ('against the deployed verifier contract'), and its place in a workflow ('Step 4 (optional)'). It distinguishes itself from siblings like generate_proof and submit_proof.

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 instructs users to 'Pass the full generate_proof result object directly,' providing clear how-to guidance. It frames the tool as an optional step after proof generation, but lacks explicit when-not-to-use or mention of alternatives.

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