JarvisClaw — AI Gateway & API Marketplace

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 well: it discloses that the tool does not execute the intent, does not spend anything, and is 'Free'. This is critical behavioral information for an estimation tool. It does not mention potential limitations (e.g., estimate accuracy, rate limits), but the core guarantees are clearly stated.

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, front-loaded with the main purpose, followed by a use case and a key trait ('Free'). Every sentence earns its place, with no filler. The structure is clear and easily parseable.

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?

The description covers purpose, when to use, and the main behavioral outcome (no execution, no cost). It mentions 'get an estimated price', which hints at the return value. However, there is no output schema, and the description does not elaborate on the optimize_for parameter or estimate format, leaving minor gaps for a tool of this 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?

The schema has 50% coverage (intent is described, optimize_for is not). The description explains that the tool estimates cost 'for an intent', aligning with the intent parameter, and 'comparing options up front' vaguely hints at optimization choices. However, it does not explicitly explain the optimize_for parameter's role, leaving a gap for that parameter.

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 a specific verb ('Preview', 'get an estimated price') and resource ('an intent'), and distinguishes itself from execution tools by emphasizing 'without running it or spending anything'. It also includes use cases ('budget planning', 'comparing options'), making it 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 provides clear context: use this 'before committing' and 'without running it', which contrasts with execution tools like aip_execute_with_budget. It also mentions 'comparing options up front' as a specific scenario. However, it does not explicitly name alternative tools or state when not to use it, so it stops short of full explicitness.

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 behavioral disclosure burden, and it does well: it details the pipeline (resolve provider, risk check, pre-deduct budget, execute, settle via x402) and guarantees no overspending. It does not cover failure/refund behavior or account prerequisites, but it provides far more than a generic execution 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 front-loaded with the core purpose, then adds a compact process explanation and supported intents. Every sentence contributes useful information, and there is no redundant filler or vague marketing language.

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 financial execution tool with no annotations and no output schema, the description omits important operational details such as what the response contains, what happens on failure or insufficient balance, and whether a funded account or payment setup is required. The normal happy path is clear, but the surrounding context is incomplete.

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 all four parameters. The description mostly restates the intent enum and the max_total_usd hard cap already present in the schema; it adds only slight color like 'pre-deducts against your budget' without giving new parameter-level syntax or constraints.

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?

Description uses a specific verb and resource: 'Run an AI task end-to-end' with a hard spending cap. It clearly positions this as 'the primary AIP action' that combines provider resolution, execution, and on-chain settlement, which distinguishes it from siblings like aip_resolve and aip_estimate_cost.

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 provides clear context for when to use this tool: when you want a complete, budget-capped AI execution in one step. It does not explicitly name alternatives or say 'use aip_estimate_cost instead when...', so it stops short of full when/when-not 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?

With no annotations, the description carries the full burden. It discloses that the tool is free ('Free') and that it returns short descriptions for each task type. However, it does not detail output format, ordering, or whether hidden/system intents are excluded. For a straightforward listing tool, this is adequate but not rich.

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 sentences, with the first sentence delivering the core purpose and examples, and the second providing usage timing and cost. Every word earns its place; no filler or 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?

For a zero-parameter tool with no output schema, the description is nearly complete. It explains what the tool does, when to call it, and the cost factor. It could optionally mention the return format (e.g., a list of intents), but this is inferable and not critical for usage.

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 schema has 0 parameters, and the baseline for 0 params is 4. The description does not add parameter-related information, but none is needed. It does not contradict or confuse parameter usage.

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 function: 'Browse every AI task type AIP can route' and enumerates examples (chat, image, video, speech, web search, knowledge search). This specific verb+resource combination distinguishes it from sibling tools like list_models or discover_agents, which target different entities.

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 provides explicit usage guidance: 'Call this first to see what's on the menu before you resolve or execute.' This indicates the tool is a prerequisite step before using aip_resolve or aip_execute_with_budget. It does not mention alternatives to avoid, but the timing cue is valuable and clear.

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 disclosure burden and mostly meets it: it says the tool is free, does not execute or incur payment, and returns live price plus a ready-to-call endpoint. It adds value by describing what the result contains and implying a read-only lookup. It does not disclose auth needs, rate limits, or no-match behavior, so it is not a 5.

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 purpose and high-value usage context; every sentence contributes. However, the long parenthetical enumeration of all intent values duplicates the schema enum, adding redundancy that could have been trimmed or replaced.

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?

The description is strong for a tool with no output schema: it names the return fields (provider, model, live price, endpoint) and the cost-safety behavior. But the plain-language-query instruction versus enum-only schema leaves a genuine invocation ambiguity, and details like auth and no-match behavior are absent. Overall it is close but not fully 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?

Schema description coverage is 100%, so a 3 baseline applies. The description adds the structured-routing vs semantic-matching distinction and lists valid intent values, but this conflicts with the input schema, which restricts intent to a strict enum with no free-text option — so an agent may attempt an invalid plain-language query. It also adds nothing about features, optimize_for, or max_price_usd 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?

Clearly identifies a specific verb and resource: find/resolve the best AI provider for a task and return ranked, priced options. It also separates itself from execution-oriented siblings by saying it happens 'before you commit a cent' and returns a ready-to-call endpoint. This distinguishes it from aip_estimate_cost and aip_execute_with_budget enough to orient an agent.

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 establishes the intended moment to use the tool — before committing money or executing — and states that the call is free. It also explains the two input modes: structured intent or semantic query. It does not explicitly name sibling tools to use instead in other scenarios, so it stops short of full alternative 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?

No annotations are provided, so the description must disclose behavior on its own. It discloses unified multi-provider access and smart auto-routing, but omits response shape, streaming/async behavior, rate limits, or cost implications. This is adequate but not rich.

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 short, front-loaded sentences; every sentence carries value. Avoids restating schema boilerplate and includes a memorable value proposition.

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 tool purpose, model breadth, and routing strategy in minimal space; 'OpenAI-compatible' hints at response format. However, without output schema it leaves return details and error/cost behavior implicit, which is acceptable for a simple chat-completion tool but not exhaustive.

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?

Input schema covers all four parameters with descriptions, so baseline is 3. The description reiterates the 'auto' option already present in the model parameter schema and adds provider examples, but adds no new semantics for messages, max_tokens, or temperature.

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?

Opening verb 'Send' plus object 'a chat completion' clearly states the action, and 'any model on JarvisClaw through one OpenAI-compatible endpoint' defines the resource and scope. Mentioning GPT/Claude/Gemini/DeepSeek and auto-routing differentiates it from sibling list/search/discovery tools.

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?

Description gives clear context: use this for chat completions across models, with 'auto' routing as a notable option. It implies it supersedes per-provider setup but doesn't explicitly name alternatives or state when not to use it (e.g., for model discovery or cost estimation).

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?

There are no annotations, so the description carries the full burden. It clearly implies a read-only lookup operation ('Find', 'get each agent's MCP URL and API endpoints') and explains the outcome without suggesting any side effects or mutations. It does not disclose rate limits or pagination, but for a discovery tool this is adequate.

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 sentences, front-loaded with the primary action and resource, and every phrase adds value. It efficiently covers what, why, and the expected return without unnecessary fluff.

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?

The tool has no output schema and no annotations, but the description explains the return value (MCP URL and API endpoints) and the use case. It does not specify the exact response format, but it provides enough context for a simple discovery 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 100%, so the baseline is 3. The description adds some meaning by mapping 'capability, category, or name' to the tags/category/search parameters, but it does not add syntax or format details beyond what the input schema already provides.

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 uses a specific verb ('Find') with a clear resource ('other AI agents registered on JarvisClaw') and explicitly states what the agent gets (MCP URL and API endpoints). It distinguishes itself from sibling tools like search_apis by focusing on agents rather than APIs.

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 provides clear context for when to use the tool: to discover and connect to other agents for delegation, collaboration, or chaining work. It does not explicitly name alternatives or exclusions, but the use case is well-implied relative to the sibling tools.

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 burden of disclosing behavior. It adds valuable context by specifying the output contents (pricing, method, exact request) and the input flexibility (slug or catalogue handle, including shorthand '40'). This goes beyond the bare name and helps the agent understand what to expect.

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 sentences, front-loaded with the main purpose and followed by input format details. Every word earns its place with no redundancy or 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 simple single-parameter tool with no output schema and no annotations, the description is nearly complete: it covers what the tool does, what the input can look like, and when to use it. It doesn't address error conditions or prerequisites, but for a read-only lookup this is acceptable.

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 schema already provides 100% parameter coverage, explaining both slug formats. The description restates this information but adds the key context that the slug comes from search_apis results. This is helpful but doesn't significantly extend beyond the schema's description.

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 function: retrieving the full spec for an API, including pricing, method, and exact request. It distinguishes itself by referencing its input source (search_apis) and its position in the workflow (before wiring a call), making its purpose 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 explicitly tells when to use the tool ('Use this before wiring a call in') and clarifies accepted input formats (user-published slug or catalogue handle). It doesn't name alternatives or exclusions, but the context is strong enough to guide an agent on appropriate usage.

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 burden of behavioral disclosure. It states the tool is 'Free' and lists all models, but does not mention any limitations, response format, or potential pagination. This is adequate for a simple list operation but leaves some unknowns.

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, front-loaded with the main action, and every word adds value. It efficiently conveys what it does, what it returns, and why it is beneficial.

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-parameter list tool with no output schema, the description covers the key points: what is listed, the IDs are usable in chat, and it is free. It does not describe the exact output structure, but this is not critical for such a simple 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?

The tool has zero parameters, so the description need not add parameter semantics. The baseline for 0 params is 4, and the description appropriately focuses on the output and use case instead.

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 starts with a specific verb+resource ('List every AI model available on JarvisClaw') and includes examples (GPT, Claude, Gemini, DeepSeek) that distinguish it from sibling tools like get_api_detail or search_apis. It clearly states the tool's output (model IDs) and its purpose (for use in the chat tool).

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 provides clear context for when to use it: to get model IDs for the chat tool, and calls it 'the fastest way to see what you can call.' However, it does not explicitly mention alternatives or when not to use it, so it stops short of a 5.

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 discloses cost behavior ('Free to search; you only pay when you invoke'), output characteristics ('exact invocation path and per-call price'), and scope (all APIs including developer-published ones). This goes beyond a simple read-only implication, though it doesn't mention side effects or rate 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?

The description is three concise sentences: first defines scope, second describes result usage, third clarifies pricing. It is front-loaded with the action and resource, and every sentence provides value 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?

The tool is simple with two parameters and no output schema. The description covers key context: what is searched, what the results contain (path and price), and the cost implication. It doesn't mention pagination or authentication, but for a read-only search tool this is adequate.

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%, and the schema already explains that 'query' matches name/description/tags/category and 'category' is an optional filter with examples. The description adds no extra parameter-level meaning beyond reinforcing the broad search scope, so it sits at the baseline 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 starts with 'Search every API on JarvisClaw', which clearly specifies the verb (search) and resource (every API on JarvisClaw), including developer-published APIs. This distinguishes it from siblings like get_api_detail, which presumably targets a specific API, and discover_agents, which targets agents rather than APIs.

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 implies a usage context: use this tool to find callable APIs, and the returned invocation path and price let you call one directly afterwards. It does not explicitly state alternatives or when-not-to-use, but the context is clear enough for the agent to select it over siblings that focus on specific APIs or agent discovery.

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