agiscorecard-web3-compute
Server Details
Compare GPU workload costs per accepted output, including setup, storage, egress and failed work.
- Status
- Healthy
- Uptime
- 100.0% over 22 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- f-tiger/agi-site
- GitHub Stars
- 0
TDQS
Scored across 3 tools
The three tools form a discovery/retrieval/analysis chain: search finds references, fetch retrieves one by ID, and compare_compute_costs performs cost analysis. Boundaries are mostly clear, though fetch and compare_compute_costs partially overlap since the latter's inputs must be retrieved via fetch, which could cause minor misselection.
All names use lowercase snake_case imperative verbs, which is predictable and readable. The one deviation is that search/fetch are bare verbs while compare_compute_costs is a compound verb_noun, a minor stylistic inconsistency rather than a confusing one.
Three tools is thin for the apparent scope, since only compare_compute_costs is a real capability and the other two are generic retrieval helpers. It is borderline but defensible for a read-only public reference server.
The search → fetch → compare flow covers a basic read-only lifecycle, but there is no way to enumerate compute options or workloads directly, and the server explicitly disclaims live quotes, benchmarking, and reservations. Notable gaps remain for anything beyond fictional example comparison.
Available Tools
3 toolscompare_compute_costsCompute LensARead-onlyIdempotentInspect
Compute Lens compares measured workload runs using total entered compute, setup, storage and egress costs per accepted output. It filters mismatched workload labels, currencies, quality and memory limits. All examples are fictional; no live GPU quotes are supplied. No live GPU inventory, automatic benchmarking, reservation, infrastructure management or verified savings. Retrieve compute with fetch or read its example resource to obtain exact inputs. Parameters are processed remotely without application persistence.
| Name | Required | Description | Default |
|---|---|---|---|
| runs | Yes | Runs | |
| model | Yes | Model (preserve source text; decimal amounts must stay strings) | |
| currency | Yes | Currency (preserve source text; decimal amounts must stay strings) | |
| workload | Yes | Workload (preserve source text; decimal amounts must stay strings) | |
| minimumPassRate | Yes | Minimum accepted fraction (0–1) |
Output Schema
| Name | Required | Description |
|---|---|---|
| report | Yes | |
| toolId | Yes | |
| version | Yes | |
| citation | Yes | |
| revision | Yes | |
| processing | Yes | |
| limitations | Yes | |
| evidenceStatus | Yes | |
| officialReferences | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds valuable behavioral context: all examples are fictional, no live GPU quotes are supplied, no automatic benchmarking or reservation occurs, and parameters are processed without persistence. This goes beyond the annotations and helps set accurate expectations.
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 sentences and front-loads the core purpose before adding exclusions and input-source guidance. Each sentence adds distinct information, though the list of negations could be slightly tighter. Overall it is appropriately sized for the tool's complexity.
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 input schema, output schema, and annotations, the description covers the essential context: what the tool compares, what it filters, what it does not do, and where to get exact inputs. It does not need to explain return values because an output schema exists. The only minor gap is not explicitly stating when to prefer this over sibling cost-planning tools, but the exclusions largely compensate.
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 each parameter. The description adds semantic meaning by explaining that compute, setup, storage, and egress costs are combined 'per accepted output,' and that mismatched workload labels, currencies, quality, and memory limits are filtered. This clarifies how the parameters relate to each other beyond their individual schema 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 names a specific verb ('compares measured workload runs') and a specific resource (compute costs) with the exact cost components considered. It also distinguishes itself from siblings by explicitly negating live GPU quotes, inventory, benchmarking, reservation, and infrastructure management, making its scope 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 gives clear context for when to use the tool: comparing entered workload runs rather than obtaining live data. It also provides a concrete instruction to 'Retrieve compute with fetch or read its example resource to obtain exact inputs,' which routes the agent to the correct data source. It does not explicitly name sibling tools as alternatives, but the exclusions effectively communicate what this tool is not for.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
fetchRead a Web3 method and sourcesARead-onlyIdempotentInspect
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 |
Output Schema
| Name | Required | Description |
|---|---|---|
| id | Yes | |
| url | Yes | |
| text | Yes | |
| title | Yes | |
| metadata | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already certify this as a read-only, idempotent, non-destructive, non-open-world call. The description adds useful non-annotation context: the reference contains methodology, limits, official source links, and fictional worked examples, and it explicitly says 'no user records,' which matters for privacy. It also gives an action instruction (cite the canonical URL), rounding out the behavioral picture.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three tight sentences: purpose first, then content disclosure, then an actionable instruction. Every sentence adds information, and nothing is repeated from the schema or annotations.
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 fetch tool with a full output schema and rich annotations, the description supplies everything the agent needs: it identifies the resource, the source of the ID, the nature of the returned content, and a citation requirement. The absence of explicit sibling routing is minor given the simple operation and available annotations.
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 one parameter, id, and the schema provides only a bare enum value ('compute') with zero description coverage. The description compensates by saying the ID comes from search, which tells the agent where to obtain a valid value. It does not explain the enum constraint or any format details, so the semantic coverage remains partial.
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 the exact verb (Retrieve) and resource (a public tool reference) and scopes it to an ID returned by search, which cleanly differentiates it from the sibling search tool. The mention of content (methodology, limits, sources, examples) further clarifies what kind of reference is being fetched. It does not name compare_compute_costs, but that sibling serves a different purpose, so the risk of confusion is low.
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?
Tells the agent to call this after search and to use the ID that search returned, establishing a clear workflow context. It does not spell out when not to use the tool or explicitly route cost-comparison queries to compare_compute_costs, so it stops short of the highest bar.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
searchFind a Web3 worksheetARead-onlyIdempotentInspect
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 |
Output Schema
| Name | Required | Description |
|---|---|---|
| results | Yes |
TDQS
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.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
- First observed
compare_compute_costs - First observed
fetch - First observed
search
Related MCP Connectors
Compare GPU clouds for training and inference.
Compare live GPU cloud rental prices and match workloads to the cheapest provider.
Hourly cloud GPU prices from 80+ providers: find, compare, cost and track GPUs.
GPU rental reference prices (spot, on-demand, DePIN), key-free; every value carries a verify URL.
Related MCP Servers
- AlicenseAqualityDmaintenanceEstimates GPU requirements, training/inference costs, and cloud-vs-on-prem TCO for AI workloads using deterministic calculators.121MIT
- AlicenseNot gradedqualityAmaintenanceEnables AI assistants to compare costs, performance, and quality across 150+ models from 26 LLM providers, estimate or predict workload spend, route tasks to cost-effective models, and track actual recorded usage. Prices are cross-checked against a live external registry so drifted figures are flagged rather than silently served.MIT

OptimToken MCPofficial
AlicenseNot gradedqualityAmaintenanceEnables AI assistants to fetch live, dated prices for LLM models and cloud compute instances across providers, compare and recommend models, and estimate monthly costs based on workload-specific token shapes and constraints.MIT- FlicenseNot gradedqualityAmaintenanceEnables users to describe an LLM fine-tuning job once and get the cheapest, fastest, or most balanced GPU options across multiple cloud providers by estimating required VRAM and FLOPs.-
Glama MCP Gateway
Add one secure layer between your agents and this server.