Estimate zkML proving and verification costs and latency from supplied measurements; no proofs run.
Scored across 3 tools
search and fetch have distinct roles (find vs. retrieve by ID), and plan_zkml_costs is a unique action. However, fetch's description only mentions public tool references, while plan_zkml_costs implies fetch can also retrieve proofs, creating minor scope ambiguity.
All tool names use lowercase snake_case and start with a verb, but fetch and search are bare verbs while plan_zkml_costs follows a verb_noun pattern. This is a minor deviation from a fully consistent convention.
Three tools is at the lower bound of the typical 3-15 range and each appears to serve a distinct purpose. For a narrow proof-planning and reference service this is reasonable, though it may feel thin given the broader 'agiscorecard' branding.
The core search, fetch, and cost-planning workflow is present, but there is no explicit tool to retrieve or manage previously created plans, and no scoring/scorecard operations despite the server name. Proof generation and verification are intentionally excluded, but the lifecycle still has notable gaps.
Retrieve a public tool reference by the ID returned from search. Contains methodology, limits, official source links and fictional worked examples; no user records. Cite the returned canonical URL.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes |
| Name | Required | Description |
|---|---|---|
| id | Yes | |
| url | Yes | |
| text | Yes | |
| title | Yes | |
| metadata | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds useful content-level context (methodology, limits, source links, fictional examples, no user records) and an output action (cite the canonical URL), exceeding the annotation bar without detailing pagination or error behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One dense sentence plus one short imperative; every clause earns its place, with the search-derived ID and the 'no user records' caveat front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers provenance of the ID, payload contents, and required citation behavior, and an output schema exists so return values need not be described. Minor gap: no error behavior for a stale or unknown ID, and no explicit sibling routing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is only one parameter, and schema coverage is 0%, but the description supplies its origin: the ID returned by search. The enum itself ('proof') is self-documenting in the schema. Baseline is 3 for a lightweight, fully required single-param tool.
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 a specific verb (Retrieve) and resource (public tool reference) with a distinguishing constraint: it works off the ID returned from search, which cleanly separates it from the search sibling. The name 'fetch' is generic, but the description carries the meaning.
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 ties usage to a prerequisite ('the ID returned from search'), routing the agent through the sibling first. It does not name plan_zkml_costs or state when-not-to-use, so it stops short of the top score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Proof Plan estimates proving compute and onchain verification costs from your own measurements. It checks a per-job latency target and preserves model, input and verification-key hashes. It plans an integration; it does not generate or verify a zero-knowledge proof. No ZK proof generation or cryptographic verification. File hashing verifies bytes only; it is not proof of model correctness. Retrieve proof with fetch or read its example resource to obtain exact inputs. Parameters are processed remotely without application persistence.
| Name | Required | Description | Default |
|---|---|---|---|
| jobs | Yes | Jobs | |
| verifyMs | Yes | Verification time (ms) | |
| budgetUsd | Yes | Budget (USD) | |
| inputHash | Yes | Input Hash (preserve source text; decimal amounts must stay strings) | |
| modelHash | Yes | Model Hash (preserve source text; decimal amounts must stay strings) | |
| statement | Yes | Statement (preserve source text; decimal amounts must stay strings) | |
| proofBytes | Yes | Proof size (bytes) | |
| gasPerVerify | Yes | Gas per verification | |
| gasPriceGwei | Yes | Gas Price Gwei | |
| proveSeconds | Yes | Proving time (seconds) | |
| nativePriceUsd | Yes | Native token price (USD) | |
| verifierVersion | Yes | Verifier Version (preserve source text; decimal amounts must stay strings) | |
| computeHourlyUsd | Yes | Proving compute (USD/hour) | |
| latencySlaSeconds | Yes | Latency target (seconds) | |
| verificationKeyHash | Yes | Verification Key Hash (preserve source text; decimal amounts must stay strings) |
| Name | Required | Description |
|---|---|---|
| report | Yes | |
| toolId | Yes | |
| version | Yes | |
| citation | Yes | |
| revision | Yes | |
| processing | Yes | |
| limitations | Yes | |
| evidenceStatus | Yes | |
| officialReferences | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnly, idempotent, and non-destructive annotations, the description adds meaningful behavioral detail: it preserves hashes, checks a latency SLA, treats file hashing as byte-only verification rather than proof of correctness, and states that parameters are processed remotely without application persistence. No contradiction with annotations exists.
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 and generally economical, but it has redundancy: 'it does not generate or verify a zero-knowledge proof' is immediately restated as 'No ZK proof generation or cryptographic verification.' The remaining sentences each add distinct caveats or usage context.
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 high complexity (15 required parameters) and the presence of an output schema, the description covers the essential call semantics, safety profile, input provenance, and limitations. It could mention failure behavior when the SLA/budget check fails, but that is a minor gap given the schema and output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds useful semantic context by framing the numeric inputs as user measurements, tying the per-job latency target to the SLA field, and identifying model/input/verification-key hashes as preserved values; individual parameter formulas and units are still left mostly to 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 states a specific action and resource: it estimates proving compute and onchain verification costs from user-supplied measurements, checks a per-job latency target, and preserves hash inputs. It explicitly distinguishes itself from proof-generation tools by stating it does not generate or verify a zero-knowledge 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?
It gives clear context for when to use the tool: when you have your own measurements and want an integration cost plan. It also names exclusions (no proof generation/verification) and points to fetch or the example resource for exact inputs, though it does not fully route among all siblings such as compare_compute_costs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search this server’s public AI/Web3 tools and citation pages. English and Chinese names supported. Empty query lists the available worksheets.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes |
| Name | Required | Description |
|---|---|---|
| results | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish read-only, idempotent, non-destructive behavior, and the description adds valuable behavioral context: bilingual (English and Chinese) name support, public scope, and the empty-query listing behavior. These details go beyond what annotations or schema provide 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 clean sentences with no filler. The primary action is front-loaded, and the supporting usage details are kept minimal and relevant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter search tool with annotations and an output schema, the description is complete: it defines the search scope, supported query forms, and the empty-query behavior. No essential information for invoking the tool correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description carries the burden of explaining the query parameter. It clarifies that queries are names, that English and Chinese are accepted, and that an empty query has special meaning. It does not fully specify matching behavior (e.g., exact vs partial), but it compensates well for the schema gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Search') and resource ('this server’s public AI/Web3 tools and citation pages'), making the tool’s function immediately clear. It is distinct from all sibling tools, which focus on checking permissions, comparing costs, or reading profiles rather than searching a corpus. The title and description align well.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly indicates when to use the tool: when searching for AI/Web3 tools or citation pages on this server. The note about empty query listing available worksheets provides a concrete usage scenario. It does not explicitly name alternatives or exclusion conditions, so it misses the top score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
fetchplan_zkml_costssearchCompare GPU workload costs per accepted output, including setup, storage, egress and failed work.
Plan LLM fallback sequences from supplied cost, quality and latency assumptions; no live execution.
Pay-per-call ($0.25 USDC) project cost estimator: modules + cheapest model mix that clears quality.
Educational model-memory, facility-energy and completed-token cost calculations.
Add one secure layer between your agents and this server.
