Compute Connector

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

With no annotations, the description carries the full burden and does well: it discloses that nothing executes, that free usage is watch-only and logged for the weekly report, and that the return is a warning plus a verdict. It stops short of stating permission/auth requirements or threshold behavior when floor_mb is violated.

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?

Three sentences, front-loaded with the pre-flight action, and each sentence adds something (what to send, what you get back, free-tier behavior). The closing clause 'Free watch-only logs would_offload for the weekly report; nothing runs' is slightly compressed and takes a re-read.

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 no output schema, the description sensibly describes the return as a memory warning plus a run_local/offload verdict, which is the key decision the agent needs. It omits the meaning of floor_mb and the total_mb parameter, so it is not fully complete for a 6-parameter 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?

Schema coverage is already 83%, so the schema documents most parameters. The description reinforces free_mb with concrete sources (free -m, os.freemem()) and describes job, but floor_mb and total_mb are never explained and total_mb has no schema description either, leaving one parameter undocumented in both places.

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 concrete verb and resource: send free memory plus the job you're about to run, and receive a memory warning plus a run_local/offload verdict. That is specific enough to distinguish it from run_job (it explicitly says 'nothing runs'), though it never names a sibling directly.

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?

Gives a clear trigger ('Before a heavy job') and the action to take when the answer is to offload ('offload with the provider to use'). It also explains the free-tier path (watch-only, logs would_offload for the weekly report), but does not explicitly route the agent to run_job or weekly_report by name.

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 and does disclose the key behavioral consequence: jobs on that key stop working immediately. That is the critical destructive-effect disclosure. It omits whether deletion is reversible, whether confirmation is required, and behavior when the name does not exist.

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, front-loaded with the access gate, then the action, then the consequence. No filler and 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?

For a destructive single-parameter tool with no annotations and no output schema, the description covers permission requirements and immediate impact. It lacks reversibility/confirmation details and error behavior, which are the remaining gaps for a delete operation.

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% and the single 'name' property is undocumented in the schema, so the description must compensate. 'Delete a saved provider key by name' clarifies that the parameter is the provider key's name, which is enough for a one-parameter tool, though it does not specify format or case-sensitivity.

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 (delete) and resource (a saved provider key) with the lookup key (by name) and the gating scope (Pro, owner only). It is trivially distinguishable from its counterpart save_provider_key and from list_providers.

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?

Gives clear preconditions for use – requires Pro tier and owner role – which tells the agent when this call is even permitted. It does not name alternatives or an explicit when-not-to-use (e.g., use save_provider_key to overwrite instead), so it stops short of full routing 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?

No annotations are provided, so the description carries the full burden. It does disclose two useful behaviors: output is scoped by authentication ('with your key') and it 'Never shows a key,' a meaningful security guarantee. It stops short of stating read-only status, whether the call has side effects, or any rate/size limits.

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?

It is a single sentence with no filler, front-loaded with the resource being listed. The parenthetical and the trailing field list make it slightly dense but nothing is redundant.

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 no output schema and no annotations, the description must cover return content, and it names the fields — a genuine plus. However, 'how each one runs' is left vague, and there is no indication of ordering, pagination, or what an unauthenticated caller receives.

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 schema has nothing to document and the baseline is 4. The description rightly spends no space explaining inputs.

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 resource (providers this connects to) and enumerates the fields returned (name, provider, fingerprint, default, last used), which makes the tool's scope clear. It lacks an explicit verb like 'list' and never names the delete_provider_key/save_provider_key siblings, but the resource is 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?

There is no statement of when to call this versus alternatives, nor any prerequisite beyond the parenthetical hint that saved keys appear only 'with your key'. An agent still has to infer that this is the read-side counterpart to save_provider_key and delete_provider_key.

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 are provided, so the description carries the burden. It usefully discloses that output is per-provider documentation and that Modal/Workers Sandbox responses include extra bridge code, but it never states that this is a read-only/idempotent lookup, and gives no note on auth requirements or whether the returned content is static versus live-fetched.

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?

A single sentence that front-loads the core purpose ('Step-by-step setup for one provider') and then lists the payload. Dense but every clause adds information about what the caller receives; only mildly overstuffed for one sentence.

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 informational tool with no output schema and no nested objects, the description adequately covers what the tool returns and the provider-specific variation. The remaining gap is workflow positioning relative to list_providers and save_provider_key.

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 param is documented, so the baseline is 3. The description goes beyond the schema by disclosing that the response content varies by provider value, specifically that Modal or Workers Sandbox yields additional bridge code to deploy on the user's own account.

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 resource (setup for one provider) and enumerates the returned content: key acquisition steps, what to pass to save_provider_key, doc and price links, plus bridge code for Modal/Workers Sandbox. The reference to save_provider_key implicitly separates it from sibling write tools, though it never names a competing read tool like list_providers.

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 only implied: an agent can infer this is the pre-step before calling save_provider_key, since the description says it explains 'what to pass to save_provider_key'. There is no explicit when-to-use statement, no exclusion, and no mention of the alternatives in the sibling set.

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 and does well: it discloses the sandbox lifecycle ('created for the job and stopped right after, so nothing idles on your bill'), the exact return shape (exit code plus last 16 KB of stdout/stderr), and the non-secret constraint on env vars. It stops short of stating auth/key prerequisites for provider selection or what happens on timeout or 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 core capability, lifecycle and return values are front-loaded and tight, but the trailing sentence 'Free watch-only logs would_offload and runs nothing' is incoherent and fails to earn its place, diluting an otherwise efficient description.

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 an 8-parameter tool with nested file objects and no output schema, the description supplies the missing return-value information (exit code, truncated stdout/stderr), the sandbox lifecycle and provider defaults. It is nearly complete, lacking only failure/timeout behavior and provider-key prerequisites.

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 documents cmd, env, files, runtime, provider, template, timeout_s and free_mb. The description adds only marginal meaning ('Send small input files with it', the non-secret qualifier on env), so 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?

States a specific verb+resource (run a shell command) plus the execution environment (fresh cloud sandbox on the caller's own provider account) and enumerates the concrete providers. Nothing in the sibling set (provider keys, memory, reports) overlaps with this, so an agent can identify it immediately.

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 only implied: 'Send small input files with it' hints at the input-files use case, and 'Free watch-only logs would_offload and runs nothing' gestures at a when-not boundary but is garbled and names no real sibling tool. There is no explicit guidance on when to prefer this over any 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?

With no annotations, the description carries the full burden and does so well: AES-256-GCM sealing before DB write, key never returned or logged, a read-only validation call first, and the skip_check bypass. It omits error behavior on failed checks and whether re-saving overwrites an existing key, but the disclosure is far above typical.

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 access gate ('Pro, owner only') and then packed with provider mappings and security behavior in a few dense sentences. Every sentence earns its place with no filler.

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 9-param mutation tool with no annotations and no output schema, the description covers the critical behavioral surface: auth/tier, encryption, validation, and provider-specific inputs. Minor gaps remain around overwrite/idempotency behavior and failure modes, but an agent has enough to call 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?

Schema coverage is already 89%, so baseline is 3; the description adds real value beyond the schema by mapping provider-specific requirements (Vercel needs team_id/project_id, Modal/Workers need bridge_url) and noting vercel is the default. It stops short of explaining skip_check's risk or make_default semantics in the prose, but clearly exceeds baseline.

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+resource ('save one provider key') and scopes it precisely against siblings delete_provider_key and list_providers. It even enumerates the provider domain, so an agent knows exactly what resource it operates on.

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?

Gives clear prerequisites ('Pro, owner only') and routes the agent to provider_setup for the bridge_url requirement. It does not explicitly state when to save vs. delete or list, but those alternatives are self-evident from the names and the tier gate is well conveyed.

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, so the description carries the burden. It adds useful context: free tier of 500 calls/day, not metered. However, it doesn't state whether the call itself counts toward quota, rate limits, or whether the upgrade link is static/dynamic.

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, front-loaded sentences with no waste. The primary output is stated first, followed by the supporting quota 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?

For a no-param, no-output-schema read tool, the description covers what is returned (usage and upgrade link) and the quota context. It lacks detail on return format, but that's minor given the simplicity.

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?

Zero parameters, so baseline is 4. The description correctly indicates the scope is implicit (your key or IP), needing no input.

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 ('Show') and resource ('today's usage for your key or IP') plus a secondary output (the upgrade link). It's clearly distinguishable from siblings like budget_status and weekly_report which deal with budgets/reports.

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?

Implied usage via 'today's usage' and the free-tier context, but no explicit when-to-use or when-not-to-use versus siblings like budget_status or weekly_report. The agent must infer that this is a quick self-check rather than a budget query.

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 and does disclose the safety profile ('Read-only; sends nothing') plus the auth requirement (API key) and the report's content categories. It stops short of describing return format or ordering, but for a parameterless read-only tool this is solid disclosure.

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?

A single dense sentence that front-loads the core purpose (7-day summary) and then compresses the contents, followed by short safety/auth clauses. Every clause carries information, though the list-like density is slightly heavy.

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 zero params, no annotations, and no output schema, the description is the sole source of information and it covers content, safety, side effects, and auth. It omits sorting/timezone/pagination details, but those are minor for a fixed-window weekly summary.

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 no parameters, so there is nothing for the description to clarify; the 4 baseline for zero-parameter tools 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+resource ('Plain-English summary of the last 7 days') and enumerates the report's contents (memory checks, warnings, offloaded/ran jobs by provider, minutes, failures), so the agent knows exactly what it produces. It does not name a sibling to distinguish from, so it falls short of 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?

Usage is only implied by the weekly framing, and the prerequisite 'Needs an API key' is stated, but there is no explicit when-to-use vs. when-not guidance and no routing against the adjacent usage_and_upgrade or check_memory tools.

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