ypollak2/llm-router

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes what the tool does (browse, show providers/capabilities) but does not disclose side effects, permissions, read-only nature, rate limits, or any limitations. The mention of 'trust-verified' is about result content, not behavior.

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 concise sentences: first states purpose, second adds detail on what is shown, third specifies return format. No wasted words, information is front-loaded.

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 no-parameter browsing tool, the description covers purpose, what is shown, and return format. The output schema exists to handle return value details. Minor gap: no mention of read-only or idempotency, but overall 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?

There are zero parameters, so the description need not add parameter meaning beyond the schema. The schema already shows no input required. The description adds value by stating the return format (JSON list of capabilities), which aids understanding.

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 verb 'Browse' and the resource 'available services on the Agoragentic marketplace'. It distinguishes itself from sibling tools like agoragentic_status (status) and agoragentic_wallet (wallet) by focusing on marketplace services.

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 usage for browsing services but provides no explicit guidance on when to use this tool versus alternatives like agoragentic_status or other marketplace tools. No 'when not to use' or alternative recommendations are given.

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 carries the full burden. It indicates a read operation ('Get... status') but does not disclose any behavioral traits such as side effects, rate limits, or authentication needs. The description is adequate for a simple status check but lacks additional context.

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 extremely concise: one sentence and a brief bullet about return value. It is front-loaded with the core action, and every word adds 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?

Given the tool's simplicity (no parameters, output schema exists), the description is complete. It states the purpose, what is shown, and the return format (JSON). No additional information is necessary 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?

The tool has no parameters, and schema coverage is 100% (vacuous). The description correctly adds no parameter information since none exist, meeting the baseline expectation for zero-parameter tools.

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 'Get llm-router agent status on Agoragentic', specifying the verb and resource. It lists what is shown (registration status, available seller slots, listings), differentiating it from sibling tools like agoragentic_browse, agoragentic_task, and agoragentic_wallet.

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 usage when needing agent status but does not explicitly state when to use or not use this tool versus alternatives. No guidance on prerequisites or context is provided, leaving the agent to infer 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 provided, the description carries full burden. It discloses routing logic and USDC settlement on Base L2, but misses important behavioral details such as whether the tool is destructive, if it costs money, required permissions, or validation steps. Partial transparency but insufficient for full confidence.

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 concise and well-structured, with a clear purpose statement, parameter list, and return type. Every sentence is useful, and the key actions are front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of a marketplace tool with blockchain settlement, the description covers core purpose and parameters but omits prerequisites (e.g., wallet setup), error scenarios, budget enforcement behavior, and routing criteria. It needs more context for safe 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 coverage is 0%, so description compensates by listing parameters with explanations and examples (e.g., task types like 'code_review'). This adds value beyond the bare schema, though it lacks detailed format for input_json or allowed task enumerations.

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 executes a task on the Agoragentic capability marketplace, with specific verb 'Execute' and resource 'task'. It distinguishes from sibling tools like agoragentic_browse and agoragentic_status by focusing on task execution rather than browsing or status checking.

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 mentions automated routing to best provider, but provides no explicit guidance on when to use this tool versus alternative tool groups like llm_generate or llm_query. No when-to-use or when-not-to-use criteria are given.

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?

Description implies a read-only check operation ('Check') but does not explicitly state behavioral traits such as authentication requirements, rate limits, or side effects. With no annotations, the description carries full burden; it is adequate but lacks depth.

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 action. No extraneous information. Every sentence serves a purpose.

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 read-only wallet check with no parameters and an output schema, the description is sufficiently complete. It covers what it returns, though behavioral details (e.g., read-only guarantee) are missing. Output schema likely covers return structure.

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?

Tool has zero parameters, so parameter semantics are not needed. Description adds value by explaining the return values (balance, chain, currency), which is beyond the input schema. Baseline for no params is 4.

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 clearly states 'Check Agoragentic wallet balance and status' using a specific verb and resource. It distinguishes from sibling tools like agoragentic_browse and agoragentic_status by focusing solely on wallet information.

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?

No guidance on when to use this tool versus alternatives. Does not specify prerequisites, limitations, or when not to use it. Sibling tools exist (e.g., agoragentic_browse, agoragentic_status) but no differentiation is provided.

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 bears full responsibility for behavioral disclosure. It explains model routing based on complexity parameter but omits important details such as cost implications, rate limits, or potential side effects (e.g., high token usage). The guidance on complexity levels is helpful but incomplete.

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 extremely concise: a one-line purpose statement followed by a bulleted list of parameters. Every sentence adds value, and the structure is front-loaded with the most important information. No redundant or irrelevant content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (5 parameters, output schema exists), the description covers purpose, typical use cases, and parameter details. However, it lacks guidance on error conditions or how the output schema is structured. The presence of an output schema partially mitigates this, but additional context on expected results would improve completeness.

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 input schema has 0% description coverage, so the parameter descriptions in the tool description add significant value. Each parameter is explained with usage notes (e.g., complexity defaulting to moderate, complex for multi-file reviews). This compensates for the schema gap, though further detail on system_prompt and context could enhance 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 explicitly states 'Deep analysis task — routes to the strongest reasoning model' and lists specific uses like data analysis and code review. This makes the purpose clear but does not contrast with sibling tools like llm_classify or llm_auto, leaving some ambiguity about when to choose this over others.

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 includes a 'Best for' section that implies appropriate use cases. However, it does not provide explicit guidance on when not to use the tool or mention alternative tools, leaving the agent to infer usage boundaries without clear exclusions.

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 carries the full burden. It discloses that the tool approves or cancels a pending call and that the call is stored server-side. However, it does not mention possible side effects like whether approval triggers immediate execution or cancellation removes the pending call, nor does it discuss error states. Still, the core behavior is transparent enough for an agent.

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 very concise: a single-sentence purpose, a short usage context paragraph, and a clear Args section. Every sentence adds value, and the structure front-loads the key action.

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 2-parameter tool with an output schema (not shown but present), the description covers purpose, usage, and parameters adequately. It lacks mention of error handling or timeout behavior for the pending call, but these are minor given the tool's 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?

Schema coverage is 0%, so the description must explain parameters. It does so clearly: approve (boolean to proceed or cancel) and downgrade_to (optional string with an example like 'gemini/gemini-2.5-flash' for a cheaper model). This adds meaning well beyond the bare schema types.

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: 'Approve or reject a pending high-cost routing decision.' It specifies the verb (approve/reject) and resource (pending high-cost routing decision), and among siblings like llm_route and llm_reroute, this tool uniquely handles the approval step after a cost-based block.

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 states when to use: when llm_route (or any routing tool) blocked a call due to cost exceeding LLM_ROUTER_ESCALATE_ABOVE. It also explains the pending call is stored server-side, implying that you need to use this tool before the call is dropped. This leaves no ambiguity about the context.

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 full responsibility for behavioral disclosure. It mentions routing to external services but does not disclose API dependencies, potential costs, latency, or side effects. The agent lacks critical context about external service requirements.

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 in one sentence, followed by a compact argument list. It is efficient but could be slightly more concise by removing the 'Args' docstring format in favor of inline text.

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 parameter options but lacks important context such as return value type (audio data) and any output schema details. Considering the output schema exists, the description is adequate but not fully complete in behavior and usage context.

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%, but the description adds meaningful details for all three parameters: it explains the text input, lists specific model options (e.g., 'openai/tts-1-hd'), and enumerates voice choices for both providers. This compensates well for the schema gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool generates speech/audio and explicitly mentions routing to ElevenLabs or OpenAI TTS. It distinguishes itself from sibling tools like llm_image or llm_video which handle other modalities.

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 usage for text-to-speech conversion but does not explicitly state when to use this tool versus alternatives (e.g., other audio generation tools), nor does it provide any when-not-to-use 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?

Since no annotations are provided, the description must fully disclose behavioral traits. It clearly explains that the tool flushes pending hook-written savings records into SQLite before routing and appends a savings envelope every 5 calls, and that savings are tracked server-side. However, it doesn't mention potential side effects on the routing process itself (e.g., latency) or any error scenarios, but the core extra behavior is well communicated.

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 concise at about 160 words, with a logical structure: summary, differentiation from sibling, usage guidance, and parameter list. Every sentence adds value, and there is no redundant or extraneous information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (routing with savings tracking, 5 params, no annotations), the description covers purpose, behavioral traits, usage guidelines, and all parameters. It does not describe the output schema, but since an output schema is provided separately, that is acceptable. It could mention error handling or response format, but the current completeness is sufficient for most use cases.

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 0%, so the description must compensate, and it does thoroughly. The 'Args' section provides clear, meaningful descriptions for all 5 parameters, including allowed values for task_type and profile_override, which are not enumerated in the schema. Each parameter's purpose and optionality are explicitly stated.

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 defines the tool as an auto-routing wrapper with persistent savings tracking, distinguishes it from the sibling llm_route by explaining the additional flushing and savings envelope behavior, and specifies it works from any host. The verb 'route' and resource 'prompt' are clear, and the scope is well-defined.

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 states when to use llm_auto over llm_route: 'Use llm_auto instead of llm_route when you are in a host that lacks a UserPromptSubmit hook (Codex CLI, Claude Desktop, GitHub Copilot).' It also provides context about server-side tracking, making the usage guidance extremely 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 provided, the description bears the full burden. It discloses that accuracy is based on user ratings (llm_rate) and that an optional community export status is shown if LLM_ROUTER_COMMUNITY=true. It does not mention data freshness, aggregation period, or any side effects. While it avoids contradictions, more behavioral details (e.g., real-time vs cached) would improve 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 concise: three sentences with no wasted words. The first sentence front-loads the primary purpose, followed by necessary context about accuracy computation and an optional feature. Every sentence 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?

Given no required parameters and an existing output schema, the description covers the essential aspects: what is shown (benchmarks by task type), how accuracy is derived (from llm_rate feedback), and a conditional element (community export). It is reasonably complete for a display tool, though it could mention expected output format or time range 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?

The tool has no parameters, so the input schema is empty (100% coverage, baseline 4). The description adds value by explaining what the tool shows (benchmarks, community export status) and the data source, which is beyond what the empty schema provides. Thus, it fully compensates for the lack of parameter details.

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: 'Show routing accuracy benchmarks by task type.' It uses a specific verb ('Show') and resource ('routing accuracy benchmarks by task type'), effectively distinguishing it from siblings like llm_rate (for rating) and llm_model_eval.

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 about the data source (accuracy computed from llm_rate feedback) and notes that rating more improves accuracy, implying when it becomes more useful. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or best practices. The guidance is implied but not explicit.

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 present, the description fully discloses behavior: it reads from Budget Oracle, normalizes provider quota, details pressure calculation per provider type (local, Claude, API-key), and returns a formatted summary with pressure bars. This is comprehensive.

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?

Description is well-structured with clear sections: core purpose, calculation method, provider-specific behavior, and return value. Bullet points and efficient wording make it easy to parse.

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 an output schema (exists but not detailed here), the description provides all necessary context: what it returns, how it works, and when to use it. No gaps identified.

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 input schema has zero parameters, achieving 100% coverage. The description correctly adds no parameter information. Per guidelines, a baseline of 4 is appropriate for no-parameter tools.

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 explicitly states 'Show real-time budget pressure for all configured providers', specifying both the verb 'show' and the resource 'budget pressure'. It clearly distinguishes itself from sibling tools like llm_quota_status or llm_usage by focusing on aggregated budget pressure.

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 explains that this tool is used to view live budget state normalized into a pressure value. While it doesn't explicitly state when not to use it, the context of sibling tools and clear purpose provides adequate guidance. Could be improved by mentioning when to use alternatives like llm_quota_status.

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 fails to disclose behavioral traits such as whether the action is destructive, reversible, rate-limited, or requires special permissions. It merely states the action without context.

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 a single, efficient sentence with no extraneous words. It is front-loaded and instantly comprehensible.

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?

While the tool is simple and needs little context, the description omits any mention of output, side effects, or prerequisites. An output schema exists but is not referenced. Slightly insufficient for full context.

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 and schema coverage is 100%, so there is no need for the description to add parameter details. The baseline score of 4 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?

The description 'Clear the prompt classification cache' uses a specific verb ('Clear') and explicitly names the resource ('prompt classification cache'), making the tool's purpose immediately clear and 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?

No guidance is provided on when to use this tool versus alternatives like llm_cache_stats. The description does not mention prerequisites, effects, or situations where clearing is appropriate.

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, description adds value by explaining keying mechanism (SHA-256 of prompt, quality_mode, min_model) and validity condition (budget pressure applied fresh). This discloses behavioral traits beyond a simple read operation.

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: first states purpose and outputs, second explains caching behavior. No wasted words, front-loaded with key information.

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 an output schema, the description fully explains what statistics are shown and why cached classifications remain valid. No gaps given complexity.

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?

No parameters exist, so baseline is 4. Description adds no parameter info, which is appropriate since none are needed.

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 clearly states 'Show prompt classification cache statistics' with specific statistics listed (hit rate, entries, memory usage). Distinguishes from sibling tools like llm_cache_clear.

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 implies usage for viewing cache performance but provides no explicit guidance on when to use this tool versus alternatives or when not to use it.

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?

Despite no annotations, the description discloses caching behavior, the JS snippet fallback with no page navigation, and downstream impact on model routing. It could be more explicit about read-only nature, but overall transparency is good.

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-loading the main purpose and then adding details on caching and routing. No redundant information; every sentence adds value.

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 no parameters and an output schema (assumed complete), the description covers the tool's purpose, caching behavior, fallback mechanism, and downstream use. It is sufficient for an agent to understand when and how to invoke this 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?

With zero parameters, the baseline is 4. The description adds no parameter details because none exist, but the lack of parameters is clear from the schema. The description does not contradict or mislead.

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 checks real-time Claude subscription usage, mentioning specific limits like session and weekly limits. However, it does not explicitly differentiate from similar sibling tools like llm_usage or llm_quota_status, though the mention of real-time and JS snippet fallback provides implicit distinction.

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 explains when to use: for real-time usage check with caching and fallback to a JS snippet. It does not provide explicit guidance on when not to use or mention alternative tools, leaving the agent to infer context from the sibling list.

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?

The description fully discloses the decision algorithm for model selection based on complexity and budget, including specific thresholds. However, it does not mention any side effects or permissions, which would be expected given no annotations.

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 well-structured with bullet points, front-loaded purpose, and no redundant sentences. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity, the description provides sufficient context for correct invocation, covering logic, parameters, and constraints. The presence of an output schema means return values are documented elsewhere.

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?

With 0% schema coverage, the description adds significant value by explaining each parameter and providing example values for quality and min_model, though exact allowed values are not formally defined.

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 the tool classifies a prompt's complexity and recommends a model, which is specific and distinct from sibling tools like llm_analyze or llm_route.

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 explains when to use the tool and provides detailed logic for complexity and budget-based model selection, but does not explicitly mention when not to use it or compare to alternatives.

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 full burden. It explains model selection based on complexity, which is a key behavioral trait. It does not mention side effects, rate limits, or authentication, but for a simple LLM call, this is acceptable. No contradictions.

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 concise and well-structured: a one-liner, 'Best for' list, then parameter descriptions. Every sentence adds value, and it is front-loaded with the main purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema, the description does not need to detailed return values. It covers all parameters and usage context. Minor gaps: no mention of error handling or cost implications, but overall complete enough for a tool that sends prompts to a model.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate. It explains all 5 parameters in the 'Args' section, adding meaning beyond schema titles, especially for complexity which drives model selection. However, it lacks details like validation constraints or token limits for max_tokens.

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 routes to the best coding model for code generation, refactoring, and algorithm design. This differentiates it from sibling tools like llm_analyze or llm_edit, giving a specific verb and resource.

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 'Best for' list and complexity explanation provide clear when-to-use guidance. However, it does not explicitly state when not to use this tool or mention alternatives like llm_generate or llm_edit, so it's slightly incomplete.

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?

Discloses that the tool runs non-interactively and uses the user's OpenAI subscription (not Claude quota), which are important behavioral traits. Without annotations, this adds value, though it omits details on prerequisites, error handling, or state changes.

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 concise, with a clear first-line purpose, followed by essential details and a structured Args section. Every sentence contributes information 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?

Given the tool's simplicity (2 parameters, output schema exists), the description covers core functionality, usage guidelines, and parameter semantics. It is nearly complete, though it could mention prerequisites like local Codex installation.

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 description explains both parameters: 'prompt' as 'the task or question' and 'model' with a default and list of available models. This adds meaning beyond the schema's type-only definitions, compensating for the 0% schema description 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 clearly states it routes a task to the local Codex desktop agent (OpenAI) and runs non-interactively. It differentiates from other llm_* tools by specifying it uses the user's OpenAI subscription and lists available models, making the purpose specific and distinct.

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 'ideal as a fallback when Claude limits are tight, or for tasks that benefit from OpenAI's models,' providing clear when-to-use context. Also contrasts with Claude quota usage, helping an agent decide between this and other LLM 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 provided, the description carries the full burden. It discloses that a local HTTP server is started, the dashboard reads from the same SQLite DB, and it refreshes every 30 seconds. It also details the port argument. However, it does not mention lifecycle aspects like how to stop the server, which is a minor gap.

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 concise at 4 sentences, front-loaded with the core action. It uses clear structure with a main sentence, followed by bullet-like listing of dashboard features, a note on data source, and an Args/Returns section. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema (though not shown), the description appropriately includes a Returns clause stating it returns URL and instructions. It covers setup, refresh interval, data source, and port parameter. No critical gaps remain for an agent to invoke the tool 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 description coverage is 0%, so the description must compensate. It effectively documents the single 'port' parameter with its default value (7337) in the Args section, adding meaning beyond the schema's minimal definition. This provides sufficient guidance for the agent.

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 opens the LLM Router web dashboard in the background, specifying it starts a local HTTP server showing routing stats, cost trends, model distribution, and recent decisions. This specific verb-resource combination effectively distinguishes it from sibling tools like llm_analyze or llm_route, which serve different purposes.

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 on when to use the tool (for monitoring routing stats via a dashboard) and notes it requires no extra configuration, but it does not explicitly exclude use cases or mention alternatives. Since siblings cover many distinct functions, the implied usage is generally 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?

No annotations provided, so description carries full burden. It mentions the ability to send to a webhook and detect spikes, but doesn't disclose any side effects, permissions, or service dependencies (e.g., webhook URL must be set).

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?

Four sentences: first states main action, then bullet-like details. No fluff. Front-loaded with key verb and resource.

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?

Output schema exists, so return values are not needed. Description covers period and send behavior, but misses setup info (e.g., webhook URL must be configured). Still adequate for a simple 2-param 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 has 0% description coverage, but the description adds concrete values for 'period' (today, week, month, all time) and explains that 'send' posts to LLM_ROUTER_WEBHOOK_URL. This adds significant meaning beyond the schema's type/default.

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 generates a savings digest and optionally sends it to a webhook. It lists specific features (spend spike detection, simulation), making its purpose distinct from sibling tools like llm_savings or llm_budget.

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?

No guidance on when to use this tool versus alternatives (e.g., llm_savings). The description does not mention when not to use it or any prerequisites.

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 fully inform about behavior. It explains the tool routes to a cheap model, returns JSON pairs, and truncates large files. However, it does not explicitly state that the tool does not modify files (only returns instructions), nor does it mention any side effects, permissions, or limits. This is a minor gap.

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 fairly long but well-structured with sections and bullet points. It front-loads the key purpose. Some text (e.g., 'Instead of Opus reasoning...') adds context but could be trimmed. Overall, it earns its length.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (3 params, code editing), the description covers input, output format, usage, and best-fit scenarios. It mentions file size limits but lacks error handling or rate limits. The presence of an output schema (not shown) may further detail returns, but the description suffices.

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 input schema has 0% description coverage (only title fields), but the description adds substantial meaning: 'task' is a natural-language description, 'files' are paths with truncation note, and 'context' is optional conversation context. This compensates fully for the lack of schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Route code-edit reasoning to a cheap model and return exact edit instructions.' It identifies the verb (route/return) and resource (code-edit reasoning). However, it does not explicitly distinguish from sibling tools like llm_code or llm_fs_edit_many, though the mention of 'cheap model' and JSON output hints at differences.

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 use cases: 'Best for: refactoring, bug fixes, adding small features to existing files.' It also explains how to use the result: 'apply each edit instruction using the Edit tool.' No explicit when-not-to-use or alternatives, but the guidance is clear and actionable.

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?

Given no annotations, the description fully discloses the tool's behavior: it scans specific files, writes a summary to ~/.llm-router/context_summary.json, and that summary is used in later routing decisions. It also specifies the caching and automatic use, which gives a clear picture of side effects and lifecycle.

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 highly concise and well-structured: it starts with the core purpose, then details what it does, how it's used, when to call it, and ends with argument descriptions. Every sentence adds 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?

For a tool with moderate complexity, two parameters, and an output schema, the description covers all essential aspects: inputs, action, output location, and usage pattern. It explains the integration with other tools and the automatic subsequent use, making it fully self-contained.

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 parameter schema has 0% description coverage, but the tool's description compensates fully by explaining both parameters: 'path' as workspace root (default .) and 'max_files' as max files to read (default 20). This adds crucial meaning beyond the schema's type and default.

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: analyzing workspace files to build a routing context summary. It specifies the files (package.json, etc.), the output location, and how the summary is used by sibling tools (llm_route, llm_auto), effectively differentiating from other tools like llm_analyze.

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 guidance: 'Call this once at the start of a project session or after major refactors.' It also explains that the summary is automatically used, so no further action is needed. While it does not explicitly list alternatives or when not to use, the context makes it clear this is a setup tool.

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 explains the two-step process: the cheap model reads all target files and returns a JSON array of edit instructions, then Claude applies them mechanically. It discloses the default max_files cap and suggests batching. However, it does not mention error handling, permissions, or that edits are irreversible.

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 well-structured: a purpose sentence, a paragraph explaining the internal pattern, a usage sentence, and a clear parameter list. Every sentence adds value, with no redundancy or fluff. Front-loads key information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity and the presence of an output schema, the description covers the core behavior, parameter explanations, usage scenarios, and batching advice. No significant gaps remain for the agent to infer.

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?

Despite 0% schema description coverage, the description fully documents all four parameters in a docstring format, providing natural-language explanations, examples for `task`, and usage constraints for `files` and `glob_pattern`. This adds significant meaning 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?

The description starts with a clear verb-resource pair: 'Generate bulk edit instructions across multiple files.' It explicitly contrasts with llm_edit by noting it extends the pattern to many files, distinguishing it from the single-file sibling.

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 states 'Use this for cross-file refactors, bulk renames within files, or updating repeated patterns across a module,' giving clear usage context. It also advises on parameter selection (use files or glob_pattern) and batching for large refactors, though it does not explicitly tell the agent when to avoid this tool (e.g., for single-file edits).

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 full burden for behavioral disclosure. It reveals routing behavior (cheap model for pattern thinking) and execution responsibility (Claude executes commands). This adds valuable context beyond the name and distinguishes it from a simple search. However, it could explicitly state that no files are modified.

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 very concise: two short paragraphs and a brief Args section. The purpose is stated in the first sentence, followed by internal routing info, then parameter details. Every sentence adds value with no 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?

Given the tool's moderate complexity, lack of annotations, and presence of an output schema, the description adequately covers purpose, routing, and parameter details. It does not cover error cases or prerequisites, but for a read-style find tool, the completeness is sufficient. No major gaps.

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 0%, requiring the description to compensate. The description provides detailed explanations and concrete examples for both parameters: description ('What you’re looking for, e.g. ...') and root ('Optional root directory to search in. Defaults to current working directory.'). This adds significant meaning beyond the schema's bare titles and types.

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 generates glob/grep commands to find files matching a natural-language description. It uses a specific verb (generate) and resource (commands to find files), and naturally distinguishes from sibling file-system tools like llm_fs_analyze_context, llm_fs_edit_many, and llm_fs_rename which have different purposes.

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 tool when you want to find files based on a natural-language description. It does not explicitly mention when not to use it or alternatives, so it misses the top tier of explicit exclusions, but the context is clear and adequate for an AI agent.

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 mentions that dry_run=True prefixes commands with echo for safe review, but it does not disclose potential destructive behavior when dry_run=False, error handling, or required permissions. The behavioral transparency is minimal.

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 concise, well-structured, and front-loaded. It uses a clear Args section and every sentence adds value. No wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's low complexity (2 parameters) and the existence of an output schema, the description covers all necessary aspects: purpose, parameters, usage with examples. It is complete for an AI agent to use 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?

The schema has 0% description coverage, but the tool description provides detailed explanations for both parameters. The 'description' parameter is explained with examples, and 'dry_run' is clarified with its effect on output. This adds significant meaning 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?

The description clearly states that the tool generates shell commands for file rename/reorganisation operations. It distinguishes itself from sibling tools like llm_fs_find and llm_fs_edit_many by focusing specifically on rename and move operations.

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 guidance on how to use the tool: describe the rename operation and optionally set dry_run for safety. However, it does not explicitly state when not to use this tool or mention alternatives.

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 fully disclose behavior. It indicates a read-only dashboard function without side effects, but does not explicitly state that it is non-destructive or mention any authentication needs or rate limits. The description is adequate but not thorough.

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 well-structured with a brief intro, bullet-pointed features, and explicit Args/Returns sections. It is front-loaded with the core purpose. Minor redundancy (e.g., 'RTK-style' may not be universally understood) but overall 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?

Given the presence of an output schema, the description does not need to detail return values but does mention 'Formatted savings dashboard'. It covers the parameter and provides an overview of metrics. For a dashboard tool, it is fairly complete, though an example would enhance completeness.

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 input schema only specifies a default value for 'period', but the description adds the allowed values ('today', 'week', 'month', 'all') and clarifies the default is 'week'. This provides essential semantic meaning beyond the schema, compensating for the 0% schema description 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 clearly states 'Show token savings dashboard (RTK-style)' and lists specific metrics displayed. It distinguishes itself from sibling tools like llm_dashboard or llm_savings by specifying token savings across routing decisions, making its purpose unmistakable.

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 on when to use this tool (to view token savings metrics) but does not explicitly mention when not to use it or alternatives. However, the purpose is specific enough to infer appropriate usage scenarios.

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 provided, so the description bears full responsibility. It discloses non-interactive execution, subscription model, and available models. It could mention error handling or response format, but overall is sufficiently transparent for a simple routing tool.

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 concise: a header line, a paragraph, a list of models, and Args. Every sentence adds value, no fluff. Well-structured for quick parsing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (2 parameters, output schema exists), the description covers purpose, usage context, subscription, models, and parameter details. It lacks return value explanation, but output schema fills that gap.

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?

With 0% schema description coverage, the description documents both parameters in the Args section, adding meaning beyond the schema: prompt is 'The task or question to send', model has default and list of options. This fully compensates for missing schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool routes tasks to the local Gemini CLI agent, distinguishes it from siblings like llm_route (which likely uses other models), and lists available models. This provides specific verb and resource.

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 says this tool uses Google One AI Pro subscription (not Claude quota), ideal as a fallback when Claude limits are tight, or for tasks benefiting Gemini models. This provides when-to-use and when-not-to-use context.

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?

Discloses that complexity drives model selection (cheap vs premium). No annotations exist, so description carries burden; it could add more on side effects or idempotency but generation tool is inherently non-destructive.

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?

Reasonably concise with clear parameter descriptions. Slightly verbose in parameter list but still efficient. Could benefit from bullet-point structure.

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?

Output schema exists so return values aren't needed. Tool has 6 params with one required; complexity highlighted. Could mention output type (text) but not critical. Fairly complete for its complexity.

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?

With 0% schema coverage, description fully compensates by explaining each parameter: prompt, complexity (with examples), system_prompt, temperature, max_tokens, context. Adds meaning beyond raw 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 states 'Generate creative or long-form content' with examples (writing, summarization, brainstorming, content creation). This distinguishes it from siblings like llm_analyze or llm_code.

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?

Provides 'Best for' list indicating usage context. Does not explicitly state when not to use or name alternatives, but the guidance is clear enough for selection among many generation-related siblings.

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 exist, so the description carries the full burden. 'Check the health status' implies a read-only operation, but the description does not confirm idempotency, mention timeouts, or describe the response format. However, the operation is straightforward, and the output schema (present but not shown) likely handles return structure.

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 extremely concise (one sentence, 13 words). It could benefit from a brief sentence on use case or output, but it is not verbose. It loses a point for being too terse where more context might help.

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 parameters and the presence of an output schema (which likely documents return values), the description covers the core purpose. However, it could mention that the tool aggregates status across all providers or indicate typical response fields briefly.

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, and schema description coverage is 100% (trivially). Since there are no parameters to describe, the description adds nothing beyond what the schema provides. Baseline for 0 parameters is 4.

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 'Check the health status of all configured LLM providers.' It uses a specific verb ('check'), resource ('health status'), and scope ('all configured LLM providers'). This clearly distinguishes it from other llm_* tools like llm_providers (which likely lists providers) and llm_analyze (which performs analysis).

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?

No usage guidelines are provided. The description does not mention when to use this tool versus alternatives, nor does it explain prerequisites or context. For example, it could advise using this tool before making LLM calls to verify connectivity, but it does not.

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 exist, but the description clearly indicates a read-only health check with no side effects. It lists outputs, providing adequate behavioral context.

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?

Short, front-loaded sentence followed by a bullet list of specific outputs. No wasted words.

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 parameters and an output schema (not shown but indicated), the description sufficiently covers the tool's purpose and output structure.

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?

No parameters input, but the description adds value by explaining what the output contains (status, errors, timestamps).

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 'Check the health status of all routing hooks' and lists specific items shown (permission status, counts, errors, health status). It distinguishes from siblings like llm_health by being hook-specific.

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?

No explicit guidance on when to use this tool vs alternatives (e.g., llm_health). Usage context is implied but not stated.

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 bears the full burden. It discloses auto-routing behavior and parameter options, but does not mention output format, error handling, or rate limits. Adequate but not highly informative.

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?

Extremely concise: three sentences and a list. The main purpose is front-loaded. Every sentence adds value without repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the presence of an output schema (which explains return values), the description covers all parameters and usage hints. It is complete enough for an image generation 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 0%, so the description must compensate. It provides clear meanings for all four parameters, including examples for model and size, and notes that quality is DALL-E only. This goes 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?

The description clearly states the tool generates an image and lists the supported models (Gemini Imagen, DALL-E, Flux, Stable Diffusion), which immediately distinguishes it from sibling tools like llm_audio, llm_video, etc.

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?

No guidance on when to use this tool versus alternatives like llm_auto or llm_generate. The description simply lists parameters without contextual usage suggestions.

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 provided, so description carries full burden. It discloses merging, confidence validation, and optional URL defaulting. However, it does not clarify if merging is additive or overwriting, nor mention authentication 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?

Description is concise with three sentences and structured Args/Returns. Front-loaded main purpose. Minor repetition between first two sentences, but overall 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?

Given low complexity (1 param, no nested objects) and presence of output schema, description covers import purpose, source options, validation, and merging. Could mention idempotency or conflict resolution, but 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?

Only one parameter, url, with 0% schema coverage. Description explains it as a URL to a profile JSON file, optional, defaulting to community latest, adding meaningful context beyond the schema's default value.

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 states the tool imports a learned routing profile from community or URL and merges with existing routes. The verb 'import' and resource 'learned routing profile' are specific. Distinguishes from sibling llm_share_profile which exports.

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 explains when to import (community with confidence >=2) and that URL defaults to community latest. However, it does not explicitly contrast with exporting or other profile management siblings, though the context is 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 fully carries the burden. It discloses benchmark tasks, caching for 7 days, and return format. It could add more on resource usage or side effects, but is still transparent.

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 concise and well-structured: purpose first, then details on behavior, caching, usage, and return value. Every sentence adds 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?

Given no parameters and presence of an output schema, the description provides all necessary context: what models, what benchmarks, caching, manual/auto usage, and return format. It is complete for the tool's complexity.

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 adds meaning by explaining the tool's behavior and purpose beyond the empty schema. Baseline of 4 for zero params, but the description is excellent.

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 evaluates and benchmarks all available local and remote models, specifying verb (evaluate, benchmark) and resource (all models). It distinguishes itself from siblings by its scope and caching behavior.

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 mentions it can be called manually or runs automatically weekly, providing usage context. However, it does not explicitly state when not to use it or compare with the sibling 'llm_benchmark'.

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 must fully disclose behavior. It states the tool exports data to a file and returns a path and record count, but does not mention side effects, required permissions, or whether it is read-only. This is adequate but not thorough.

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 concise with two sentences for purpose and usage, plus structured Args/Returns sections. Every part serves a clear function, and the important information is front-loaded.

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 export tool with one optional parameter and an output schema, the description covers purpose, usage, parameters, and return value. Nothing obvious 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 input schema only shows 'format' as a string with default 'csv'. The description adds the enum values 'csv' and 'json' and explains the parameter's purpose (export format). This adds meaningful information 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?

The description clearly states the verb 'Export' and the resource 'model tracking data' (complete routing history). It is distinct from sibling tools (e.g., llm_analyze, llm_query) as it focuses on exporting for external analysis. No ambiguity.

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 that the tool is for exporting routing history to files for analysis in external tools like Excel, Python, R. It implies when to use but does not explicitly state when not to use or mention alternatives, though no direct alternative exists among siblings.

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; description specifies it analyzes and returns statistics, suggesting read-only behavior, but doesn't explicitly state idempotency or side effects. Lists output components, adding some 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?

Structured with bullet points for easy scanning; concise without excess. Redundancy in repeating default value from schema is minor.

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?

Output schema exists but description only says 'formatted usage statistics and analysis'; missing details on format or pagination. No behavioral context like permissions or latency, but adequate for a statistics 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 has 0% description coverage; description explains the 'hours' parameter as lookback time with default, providing full meaning beyond schema. Single parameter, well-documented.

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 states it analyzes model selection in routing and shows usage statistics including top models, task type distribution, etc. Distinct from siblings by focusing on model routing, but doesn't explicitly differentiate.

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?

Indicates it shows statistics for last N hours, implying monitoring use, but lacks explicit when-to-use or alternatives guidance. No exclusions or context for when not to use.

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 provided, but description discloses core behavior: automatic decomposition, chaining, routing to optimal model, and tier limitations. Does not cover failure handling or auth needs, but 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?

Front-loaded with purpose, then details, tier info, and parameters. Slightly verbose but each sentence adds value. Could be a bit more concise.

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 output schema existence and complexity, description covers main functionality, parameters, and tier limits. Lacks explanation of output interpretation, but adequate for agent use.

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 has no descriptions (0% coverage), but description adds clear meaning: 'task' is a description of the complex task, and 'template' lists specific enum-like values ('research_report', etc.). Fully compensates.

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 it does multi-step orchestration, decomposing complex tasks across multiple LLMs, and lists specific chaining steps. It distinguishes from single-step siblings like llm_analyze and llm_generate.

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?

Provides guidance on using templates vs auto-decomposition, and mentions tier limits. Lacks explicit when-not-to-use or alternative tools for simple tasks, but the context is 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 provided, the description must convey behavioral traits. The word 'list' indicates a read-only operation, which is sufficient for this simple tool. However, it could mention that it returns an array of templates or if pagination 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 description is a single sentence, eight words, and front-loaded with the action. Every word is necessary and effective.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (zero parameters, output schema exists), the description is complete. It provides enough context for the agent to understand what the tool does.

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 schema description coverage is 100% trivially. The description adds no parameter details, but none are needed. 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?

The description clearly states the tool lists pipeline templates for multi-step orchestration. The verb 'list' is specific, and the resource is well-defined. It distinguishes itself from siblings like 'llm_orchestrate' which likely executes orchestration.

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 the tool is for browsing templates, but lacks explicit guidance on when not to use it or comparisons to alternatives such as llm_orchestrate. No exclusions are provided.

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 bears the full burden. It accurately describes the tool as a read-only display of policy and audit events, but it does not disclose any behavioral traits such as caching, data freshness, or access permissions.

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: the first sentence gives the core purpose, and the next two provide details. It is front-loaded and contains no unnecessary words.

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 the tool has no parameters, no annotations, and an output schema exists, the description adequately covers what the tool does: displays the merged routing policy from three layers and the last 10 audit events. No further context is needed.

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, and the input schema is empty. Baseline for 0 parameters is 4, and the description adds no parameter information, which is acceptable since there is nothing to describe.

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: showing the active routing policy and recent policy audit events. It specifically lists the three policy layers (org, user, repo) and the number of audit events (last 10), distinguishing it from siblings like llm_route or llm_set_profile.

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 usage (when you want to view the active policy and audit events), but it does not explicitly state when to use this tool versus alternatives, nor does it mention when not to use it.

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. The description indicates a read-only operation (list), but lacks details on authentication needs, performance limits, or any side effects. For a simple listing tool, this is minimally 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 a single 8-word sentence, perfectly concise. Every word carries meaning, and the tool purpose is immediately clear.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema (not shown) and no parameters, the description is complete enough. It covers what the tool does without need for additional return-value details.

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 input schema has 0 parameters, so schema coverage is 100%. Per guidelines, baseline for zero parameters is 4; the description adds no parameter information, which is acceptable since none exist.

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 lists all supported providers and indicates which are configured. It uses a specific verb ('list') and resource ('providers'), distinguishing it from sibling tools that perform actions like classifying, analyzing, or generating.

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 usage for viewing provider status but provides no explicit guidance on when to use this tool versus alternatives (e.g., for configuration details). No exclusions or context are given.

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?

Since no annotations are provided, the description carries the full burden. It discloses the threshold (0.7), the condition ('sufficient samples'), the output format (table with trend arrows and alerts), and the display of rolling averages. This is comprehensive for a simple monitoring tool.

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 extremely concise: two sentences with clear args and returns, no fluff, and front-loaded with the core purpose. Every sentence 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 tool with one optional parameter and an output schema, the description is complete. It explains what the tool does, the input, the threshold, the output format, and the condition for alerts. There are no missing elements that would hinder 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?

The only parameter 'days' is described as 'Number of days of history to analyze (default 7),' which essentially restates the schema (default 7, integer). While the description adds the word 'history', it does not provide additional semantic context beyond the schema. Given the low schema description coverage (0%), the description compensates only marginally.

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 it shows quality scores per model with degradation alerts. It uses specific verbs and resources ('Show quality scores', 'displays rolling average judge scores'), making the purpose clear. However, it does not explicitly differentiate from similar sibling tools like llm_quality_report or llm_model_eval, so it loses a point.

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 usage for monitoring model quality over a specified number of days, with alerts for degradation below 0.7. It gives the default value for days, but it does not provide explicit when-not-to-use guidance or mention alternatives among the many llm_* 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?

No annotations are provided, so the description carries the full burden. It explains that the tool analyzes routing decisions over a period and shows specific metrics. However, it does not disclose if the report is read-only or if there are any side effects, but given it's a report, the transparency 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 concise, with a single introductory sentence and a clear Args section. Every sentence adds 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 description covers the tool's purpose and parameters. Since an output schema exists (as per context), the return values are likely defined externally. The description is sufficient given the tool's 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 only parameter, 'days', has a default of 7. The description explains its purpose: 'Number of days to include in the report.' Since schema description coverage is 0%, the description fully compensates by providing clear semantics.

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: 'Show routing quality metrics — classification accuracy, savings, model distribution.' This is a specific verb+resource combination, and it distinguishes from siblings like llm_analyze or llm_health.

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 usage for reviewing routing decisions but does not provide explicit guidance on when to use this tool versus alternatives like llm_route or llm_savings. No when-not-to-use or alternative tool suggestions.

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 full burden. It discloses the routing behavior, auto-detection of complexity from prompt length, and the model override. It does not mention rate limits or authorization, but as a query tool, it is likely read-only.

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 concise: a one-sentence overview followed by a clear bullet list of parameters. Every sentence adds 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?

With 7 parameters and an output schema, the description covers all parameters adequately. The behavior and routing are well explained. Slightly more detail on return values could be added, but the output schema likely covers that.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must add meaning. It explains all 7 parameters: prompt, complexity (with auto-detect logic), model (override), system_prompt, temperature, max_tokens, and context. This adds significant value beyond the bare 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?

The description clearly states 'Send a general query to the best available LLM' and explains the routing by complexity. It distinguishes itself from specialized siblings (e.g., llm_code, llm_image) by being the general-purpose query 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 explains when to use (general queries) and details the complexity parameter that drives model selection. It also notes the model override. However, it does not explicitly list when not to use or suggest alternatives among the many specialized llm_* 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 full burden. It discloses that the tool monitors three subscriptions and returns formatted quota status with usage percentages and route recommendations. It does not mention any side effects or authorization needs, but it provides sufficient behavioral context for a read-only status tool.

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 paragraphs, starting with a clear title-like sentence. It is reasonably concise, though the QUOTA_BALANCED profile explanation could be shortened. Overall, it is well-structured and front-loads the core purpose.

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 parameters and presence of an output schema (not shown but indicated), the description provides adequate context: it explains the providers, the return value format, and usage context. It is complete for a simple status-checking 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 input schema has zero parameters, and schema coverage is 100%. Per guidelines, baseline is 4. The description does not need to add parameter semantics, and it appropriately avoids mentioning non-existent parameters.

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: 'Show quota balance across Claude, Gemini CLI, and Codex subscriptions.' It uses a specific verb ('Show') and resource ('quota balance'), and distinguishes itself from sibling tools like 'llm_check_usage' by focusing on routing decisions across three 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?

The description mentions the QUOTA_BALANCED profile uses this data for routing decisions, implying when to use the tool. However, it does not explicitly exclude alternatives or provide when-not-to-use guidance, leaving some ambiguity compared to similar 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?

No annotations are provided, so the description carries full burden. It discloses storage in the 'routing_decisions' table, use for retraining the classifier, and return of confirmation or error. This is comprehensive for the tool's simple behavior.

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 well-structured with a brief summary, an args block, and a returns block. Every sentence adds value, and it is appropriately concise for the tool's simplicity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has only two parameters and no nested objects, the description covers all necessary information: parameter semantics, behavioral effects, and return value. Nothing is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description explains both parameters: good (boolean) and decision_id (integer or null, default null). It adds meaning beyond the schema's type 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?

The description clearly states the tool rates a routing decision as good or bad, storing thumbs-up/down feedback. It distinguishes from sibling tools like llm_reroute or llm_approve_route by focusing on post-hoc feedback collection.

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 explains how to use it: rate the last decision by omitting decision_id or a specific one by providing it. It doesn't explicitly mention when not to use it, but the context is clear for feedback after a routing decision.

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 full behavioral burden. It details the steps: reading token from keychain, calling API, updating cache. This is transparent for a simple tool, though it could explicitly state that it overwrites the local cache.

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 with no wasted words. The first sentence states the core purpose, followed by implementation details, and ends with a prerequisite. Perfectly front-loaded and concise.

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 parameters and the presence of an output schema (not shown but indicated), the description covers the tool's purpose, process, and prerequisites completely. It is fully adequate for agent understanding and 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?

There are no parameters, so schema coverage is 100%. The description adds value by explaining the tool's operation without needing parameters, earning the baseline 4.

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 verb 'Refresh' and the resource 'Claude subscription usage'. It distinguishes from sibling tools by specifying the OAuth API method, no browser requirement, and the keychain token reading process.

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 (refreshing usage without browser) and mentions prerequisites (Claude Code installed and authenticated on macOS). However, it does not explicitly exclude alternatives or compare to related tools like llm_check_usage or llm_update_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 provided, the description fully bears the burden. It discloses that the tool overrides the last decision, logs to the database for feedback learning, and lowers confidence for future decisions, providing behavioral context beyond the schema.

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 in a single sentence, followed by a concise bullet list of arguments. Every sentence adds value, and the structure is clean and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (4 parameters, corrective action with future impact), the description covers purpose, usage condition, parameter details, and behavioral effects. An output schema exists, so return values need not be explained.

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 0%, but the description includes an 'Args' section that explains each parameter (to_tool, reason, original_tool, original_model) with examples and purpose, adding significant meaning beyond the schema's titles.

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 action (override the last routing decision) and resource (routing decision), and distinguishes from siblings by naming specific tools (llm_route, llm_query, llm_code) that may have made the wrong decision.

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 states when to use the tool: when another tool 'chose the wrong model for your task'. It provides examples of siblings, but does not explicitly state when not to use it or list direct alternatives, though the context is 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?

No annotations are provided, so the description carries the full burden. It mentions routing to Perplexity, indicating web search behavior, but lacks details on output format, rate limits, authentication, or potential side effects. It adds some transparency but is minimal.

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 very concise: one sentence for purpose, one sentence for best uses, and a bullet list of arguments. Every sentence adds value, and the core purpose is front-loaded.

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 an output schema, so return values are covered. However, the description does not explain how the research process works (e.g., whether it uses conversation history, how Perplexity integration behaves). Feels somewhat incomplete for a tool that relies on an external service.

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 0%, so the description must add meaning. It provides brief explanations for each parameter (e.g., 'The research question' for prompt), but these are only slightly more informative than the schema titles. Does not fully compensate for the lack of parameter documentation.

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 performs a search-augmented research query routed to Perplexity for web-grounded answers, and lists specific use cases (fact-checking, current events, sources, market research). This differentiates it from other llm_ tools like llm_query or llm_analyze.

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 says 'Best for: fact-checking, current events, finding sources, market research,' providing clear context for when to use the tool. It does not mention when not to use it or name alternatives explicitly, but the guidance is strong enough.

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 full burden. It discloses the internal classification tiers and routing logic, plus auto-detection of task_type. However, it does not mention authentication, rate limits, or failure behavior. Output schema exists but is not described, which is acceptable.

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 splits into classification tiers and args. It is concise with a clear bullet list, no unnecessary words, and 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?

Given the 7 parameters and complexity, the description covers the main functionality, distinguishes from siblings, and provides an output schema. It could mention error handling or limitations, but overall it is reasonably 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 coverage is 0%, but the description adds meaning for all parameters, including temperature range and complexity_override options. It could be more detailed about allowed values for task_type and context usage, but it significantly compensates for the lack of schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool is a 'smart router' that classifies task complexity and routes to the optimal external LLM. It specifies the verb 'routes' and the resource 'external LLM', and distinguishes itself from siblings like llm_classify.

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?

Explicit usage guidelines are provided: it tells when to use this tool (for routing to external LLMs) and when not to (for Claude's own models, use llm_classify). It names an alternative tool, which is explicit 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 provided, so description carries full burden. It discloses using a cheap model, generating a compact summary, persisting to SQLite, and that future routed calls include the summary. It also mentions the skip condition for short sessions. Minor omission of cost or speed.

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 five sentences with no redundancy, front-loaded with main purpose, and each sentence adds unique information. 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?

Given no parameters and the existence of an output schema, the description covers purpose, method, persistence, future effects, and usage timing completely.

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?

No parameters exist, and schema coverage is 100%. Description adds no parameter info, but baseline for 0 params is 4.

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 summarizes and saves the current session for cross-session context, using a cheap model. It distinguishes itself by focusing on persisting session context, differentiating from siblings like llm_analyze or llm_query.

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 says to call before ending a session or switching tasks, and notes sessions with fewer than 3 exchanges are skipped. This provides clear guidance, though it does not compare with alternatives.

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 fully disclose behavior. It states the return format ('formatted savings table with efficiency multiplier') but does not mention authentication, rate limits, or side effects. The description is adequate but not rich, providing only basic behavior.

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 extremely concise: two short paragraphs. The first paragraph states the core output upfront, and the second gives usage context. Every sentence adds value; no waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has no parameters and an output schema exists, the description is complete. It explains what the tool shows, the periods, and the purpose. No additional details are needed for this 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, and schema coverage is 100% (empty). According to the guidelines, with 0 parameters, baseline is 4. The description adds no parameter info because none exist, so the score remains 4.

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 shows a time-bucketed savings dashboard with specific periods (today, this week, this month, all-time) and explains it displays actual spend vs Sonnet baseline and efficiency multiplier. This specific verb+resource combination distinguishes it from sibling tools like llm_dashboard or llm_budget.

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 to understand the real dollar value routing provides.' This tells when to use it. However, it does not explicitly state when not to use it or mention alternatives, which would be helpful given siblings like llm_dashboard.

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 carries the full burden. It describes the tool's behavior (classification, recommendation), provides decision tree details, and lists output fields. It does not disclose side effects, but the tool is clearly a read-only classifier. The description adds good behavioral context beyond what is expected.

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 well-structured with bullet points, a code block for the decision tree, and a clear return format. It is front-loaded with the core purpose. Every section adds value, and the length is justified by the complexity of the routing logic.

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 complete: it covers the purpose, decision logic, both parameters, and the full output schema (documented in text). Given that there is no output schema in the input (but described in text), the tool is fully specified. An AI agent can correctly invoke and interpret the results.

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 0%, so the description must compensate. It explains both parameters: 'prompt' (the task description) and 'profile' (routing profile with default 'balanced'). It adds meaning by linking them to the decision tree. This is sufficient for correct invocation.

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: 'Classify a task prompt and return the recommended agent CLI + model for session-level routing.' It uses specific verbs (classify, return) and a specific resource (task prompt). The decision tree and return JSON structure further clarify the function, distinguishing it from sibling tools that focus on other LLM operations.

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 starting a Claude Code / Codex / Gemini CLI session' for session-level routing. It provides detailed decision tree rules and parameter guidance. However, it does not explicitly specify when not to use it or list alternatives among siblings, though the context is 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?

Discloses key behaviors: reports session spend, fires anomaly warning with threshold and time condition, returns formatted summary. Without annotations, this sufficiently covers the tool's read-only nature and output.

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?

Four concise sentences, each adding distinct value: purpose, content breakdown, anomaly behavior, output format. Front-loaded and no redundant text.

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?

Description fully covers the tool's purpose, output details, and behavioral trait (anomaly warning), sufficient for a parameterless tool with an output schema.

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?

Tool has no parameters, so schema coverage is 100%. Description adds value by explaining output content, aligning with baseline 4 for zero-parameter tools.

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 states 'Show real-time session cost breakdown' with specific breakdown by model and tool, and mentions anomaly warning, distinguishing it from sibling cost/usage tools that may cover broader or historical data.

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?

Implies usage for current session cost monitoring but does not explicitly state when not to use or mention alternatives like llm_budget or llm_check_usage.

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