Agentgates Compute
Server Details
Confidential VMs (Intel TDX) by the hour, paid in USDC over x402: live plans, prices, how to buy.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 3 tools
compute_docs is clearly documentation, compute_plans lists the catalog, and compute_quote prices a specific configuration. Plans and quote both expose pricing, so an agent might initially confuse them, but the descriptions distinguish catalog browsing from an exact 402 offer.
All three tools use the same compute_ prefix followed by a clear noun (docs, plans, quote). The pattern is predictable and consistent throughout.
Three tools are tightly scoped and each earns its place for discovery and quoting. Given the rental lifecycle implied by the domain, the set is slightly under-scoped, but not thin enough to be a major issue.
There are no tools for creating, polling, renewing, or controlling machines; agents must follow compute_docs and make raw HTTP calls for the core lifecycle. This is a significant gap for a compute rental server, though discovery and quote coverage are solid.
Available Tools
3 toolscompute_docsHow to buy, poll, renew and control a machineARead-onlyIdempotentInspect
Returns the Agentgates compute docs, read live (markdown written for an agent to follow in one pass): the plans with live prices, how to pay the 402 on each network, how to poll a machine until it runs, how to renew it (any wallet may pay a renewal), how to sign owner calls (X-Wallet-Auth: EIP-191 over METHOD\npath\nnonce\ntimestamp, by the wallet that paid), the controls (stop, start, restart, resize, update), and what a lost answer or a refusal means.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| ok | Yes | |
| code | No | |
| error | No | |
| source | No | |
| markdown | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, openWorld, idempotent, and non-destructive behavior, and the description adds substantial context beyond that: live prices, 402 payment per network, polling behavior, renewal payment rules, owner-call signing details, control operations, and interpretation of lost answers or refusals. This is rich behavioral disclosure with no contradiction.
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 core action and then enumerates the document contents efficiently. It is dense but every clause is relevant; the single long sentence is slightly packed but not wasteful.
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 that annotations cover safety traits and an output schema exists, the description provides enough detail about what the documentation contains and how an agent should use it. Nothing essential for calling this zero-parameter docs tool 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?
The tool takes zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and the empty schema is consistent with a documentation-fetching 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?
The description states a specific verb and resource: it returns Agentgates compute docs, read live as markdown. It clearly describes the document contents, but it does not explicitly distinguish this tool from siblings compute_plans and compute_quote, which may overlap with the plans/pricing material mentioned.
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 phrase 'markdown written for an agent to follow in one pass' implies this is the workflow reference to consult before buying, polling, renewing, or controlling a machine. However, it gives no explicit when-to-use guidance versus compute_plans or compute_quote, nor any when-not-to-use conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compute_plansConfidential VM plans and pricesARead-onlyIdempotentInspect
Lists the confidential virtual machines (Intel TDX, memory encrypted in use) Agentgates rents to agents by the hour: each plan's vCPU, memory, disk and traffic, the hours one payment may buy, and the live price of each block of hours on each payment network (USDC over x402). Read from the live catalog at call time. Free: no account, no wallet, no payment. Pass plan to read one plan.
| Name | Required | Description | Default |
|---|---|---|---|
| plan | No | One plan id, to read only that plan. Omit for every plan on sale. |
Output Schema
| Name | Required | Description |
|---|---|---|
| ok | Yes | |
| code | No | |
| note | No | |
| error | No | |
| plans | No | |
| source | No | |
| networks | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only, idempotent, open-world and non-destructive, so the safety profile is covered. The description adds genuinely new behavioral facts: data is read live from the catalog at call time (freshness), and no account, wallet or payment is required (auth/prerequisite). It says nothing about pagination or result size, but an output schema 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 core purpose is front-loaded in the first sentence, followed by short operational sentences that each carry information. The opening sentence is dense and stacks several clauses (hardware, per-plan specs, hour blocks, payment network), but nothing is redundant padding.
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 tool with full annotations and an output schema, the description covers what the tool returns conceptually, the payment/auth model and data freshness without needing to describe return shapes. The only meaningful omission is sibling routing relative to compute_quote.
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% and the single `plan` parameter is already documented in the schema with the same omit-for-all semantics. The description's 'Pass `plan` to read one plan' restates the schema rather than adding format, id conventions or error behavior, so the 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?
Specific verb and resource: 'Lists the confidential virtual machines ... Agentgates rents to agents by the hour', with the per-plan fields (vCPU, memory, disk, traffic) and pricing model spelled out. It is clearly a catalog-listing tool, but it never names compute_quote or compute_docs, so the boundary with the siblings is left to inference.
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?
'Pass `plan` to read one plan' and 'Omit for every plan on sale' cover how to narrow the call, and 'Free: no account, no wallet, no payment' signals it is safe to call speculatively. However, there is no statement of when to use this versus compute_quote (the obvious listing-vs-pricing routing decision), so usage is implied rather than prescribed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compute_quotePrice one machine (the x402 offer)ARead-onlyIdempotentInspect
Gets the exact price of one machine without paying: sends the create request with no payment and returns the API's HTTP 402 offer, one leg per network, each with the amount in USDC, the address it is paid to, the token, how long a signature stays good, and what to sign. The API checks the plan, the hours and the setup first, so a refusal costs nothing. Pass machine_id and hours instead to price a renewal of a running machine (any wallet may pay one). To buy, sign one leg with your own wallet and send the same request with an X-PAYMENT header (compute_docs has the whole contract).
| Name | Required | Description | Default |
|---|---|---|---|
| plan | No | A plan id from compute_plans. Not with machine_id. | |
| port | No | With image: the container port behind 8080 (default 80). | |
| hours | Yes | Prepaid hours (within the plan's range), or hours to add on a renewal. | |
| image | No | One container image, served on host port 8080, e.g. nginx:alpine. Or send compose. | |
| compose | No | A docker-compose.yml as a string. It must publish a port. Or send image. | |
| machine_id | No | Price a renewal of this machine instead of a new one (with hours only). |
Output Schema
| Name | Required | Description |
|---|---|---|
| ok | Yes | |
| code | No | |
| kind | No | |
| legs | No | |
| next | No | |
| error | No | |
| status | No | |
| request | No | |
| resource | No | |
| description | No | |
| x402Version | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish readOnly/idempotent/non-destructive, but the description adds real behavioral context beyond that: the API validates plan, hours and setup before returning an offer, so a refusal is free; the response contains one leg per network with amount in USDC, pay-to address, token, signature validity window, and signing payload. That is exactly the kind of pre-call and post-call behavior an agent needs for a payment flow.
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?
Front-loaded with the core action and tightly written, but the enumeration of offer fields and parenthetical asides make it denser than necessary; a little of the return-value detail is redundant against the output schema. Still efficient overall.
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 pricing/preflight tool in a payment workflow, it covers the mode switch, the validation-before-charge guarantee, the contents of the offer, and the handoff to the purchase path. With an output schema present and annotations covering the safety profile, nothing material is missing 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 schema already defines every parameter, including the machine_id-for-renewal semantics and the image/compose and plan port relationships. The description reinforces the renewal form but adds no syntax, format, or constraint detail beyond the schema; 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?
States a specific verb and resource ('Gets the exact price of one machine without paying') and immediately explains the mechanism (create request with no payment → HTTP 402 offer). It also distinguishes the two modes (new machine vs. renewal via machine_id + hours), so an agent can tell exactly what this tool returns before opening the schema.
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 when to use it (price without paying), when to switch form (pass machine_id and hours to price a renewal, payable by any wallet), and what the alternative path is (sign a leg and send the same request with X-PAYMENT to actually buy, with compute_docs as the reference). Nothing is left to inference.
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
compute_docs - First observed
compute_plans - First observed
compute_quote
Related MCP Connectors
Confidential compute and inference sold to agents over x402 USDC, plus an agent wallet over MCP.
72 x402 endpoints: trading, AI inference, blockchain, escrow. USDC on Base+Solana.
No-KYC VPS + per-second code sandboxes AI agents run over MCP — 75 tools, SDK, pay BTC/XMR/USDC/USDT
Accountless pay-per-use sandbox, storage, locks, attestation, email inbox and DNS names via x402.
Related MCP Servers
- AlicenseAqualityBmaintenanceEnables AI agents to provision, manage, and renew cloud servers with USDC payments via x402, requiring no human signup.11262 npm2MIT
- AlicenseAqualityBmaintenanceNo-KYC crypto VPS hosting with an MCP server that lets AI agents provision VPS programmatically. Pay with USDC/USDT on Base and Ethereum, no accounts or verification required.21MIT
- AlicenseAqualityDmaintenancePay-per-call x402 data products on Base mainnet — sanctions screening, aviation weather, mortgage rates, US property dossier, title chain, wallet balance, and agent session auth. Every call settles in USDC with an on-chain receipt, no accounts or API keys.769 npmMIT
- AlicenseAqualityBmaintenanceNon-custodial x402 MCP payment layer for AI agents — the open-source alternative to Vercel x402-mcp11461 npm8MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.