JarvisClaw AI Gateway

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 provided, the description fully discloses important behavioral traits: it resolves providers, runs a risk check, pre-deducts budget, executes, and settles on-chain automatically. It also explicitly guarantees no overspending beyond max_total_usd, which is critical for budget-sensitive operations.

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 sentences long, front-loaded with the core purpose, and packs substantial behavioral and scoping information without redundancy. Every sentence earns its place, making it highly efficient.

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 the key context: budget cap, process steps, supported intents, and settlement mechanism. However, it does not describe the return value or output format, which is a gap given that no output schema is provided. Despite this, the tool is well-situated among siblings and the description is rich enough for an agent to use 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 100%, so the baseline is 3. The description adds meaningful context beyond the schema by explaining how max_total_usd acts as a hard cap and that settlement is automatic, giving the agent a better understanding of the parameter's behavioral impact. It does not detail payload structure, but the schema already covers that.

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 runs an AI task end-to-end with a hard spending cap, using specific verbs and resources. It distinguishes itself as the 'primary AIP action' and enumerates supported intents, setting it apart from siblings like aip_estimate_cost and aip_resolve.

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 positions this as the primary execution tool, implying it is the go-to for actually running AI tasks, while alternatives like aip_estimate_cost handle estimation only. However, it does not explicitly name alternatives or provide direct 'when not to use' guidance, though the context and phrase 'primary action' give clear enough direction for most cases.

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 burden. It discloses that the call is free, returns ranked options with provider/model/price/endpoint, and supports semantic matching. However, it misleadingly claims 'plain-language query' support that is not reflected in the input schema (intent is an enum), creating a significant inconsistency that undermines transparency.

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 sentences, front-loaded with the main purpose. The second sentence redundantly lists enum values already present in the schema, and the plain-language query addition adds confusion, but overall it is reasonably concise and each sentence contributes to understanding.

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 explains the core value, cost, and return fields (provider, model, price, endpoint). However, the unsupported plain-language query mode creates a notable gap between description and schema, leaving the agent uncertain how to invoke semantic matching. With no output schema, more detail on response structure would help, but the essentials are covered.

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 all parameters have descriptions, so baseline is 3. But the description adds a 'plain-language query' mode that conflicts with the required enum 'intent', implying a parameter that does not exist and confusing the meaning of the supplied parameters. This deducts from clarity.

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 purpose: 'Find the best AI provider for a task and get ranked, priced options before you commit a cent.' It enumerates known intent types and distinguishes itself from siblings like aip_estimate_cost (cost estimation) and aip_execute_with_budget (execution) by focusing on discovery and routing.

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 context for when to use the tool ('before you commit a cent') and how to pass input: a known intent type for structured routing or a plain-language query for semantic matching. It does not explicitly name alternatives or exclusions, but the 'free to call — no payment until you execute' phrasing implies a pre-execution discovery use case.

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.