AstroWay Platform

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint. Description adds that it returns a 'plain-text human-readable summary' and clarifies the budget-checking purpose, providing useful context beyond 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?

Three efficient sentences: purpose, usage guidance, and return format. Front-loaded with key information, 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?

Despite lacking an output schema, the description specifies the return format (plain-text human-readable summary). For a simple status check tool, this is complete and sufficient.

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 schema coverage is 100%. Description does not need to explain parameters, and it adds value by hinting at the output format.

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 the verb 'Check' and the resource 'API key status' with specific attributes (tier, credit balance, rate limits, monthly cycle reset). It distinguishes itself from the many sibling astrology calculation tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly instructs to run this tool BEFORE invoking expensive endpoints, providing credit thresholds (Tier 4+ at 100+ credits, Tier 6/7 at 500-5000 credits) to confirm budget.

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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), yet the description adds genuine behavioral context beyond them: executors are kept out of the vendor objects because an unexpected key causes a 400 on the vendor side, and cost is flagged as not in the public credit manifest. That is real operational value.

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?

Roughly three sentences, front-loaded with the purpose before the format and executor caveats. It is dense but each sentence carries information, though the format explanation partially duplicates the schema's own enum description.

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

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

With an output schema present and full annotation coverage, the description need not explain return values, and it appropriately focuses on the vendor-shape contract and the executors/400 gotcha. It is nearly complete, with the only gap being sibling disambiguation rather than missing operational detail.

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

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

Schema description coverage is 100%, so the schema already documents every parameter in depth (limit ceiling rationale, select values, precision semantics). The description only restates format and its default, adding no parameter meaning the schema lacks. Baseline 3 is correct.

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 what the tool returns: tool definitions for an agent framework, generated from the live OpenAPI document. It is specific about the resource and the vendor-shape variants (openai vs anthropic objects). However, it never distinguishes this from the near-identical sibling astroway_mcp_tools_list, which an agent would plausibly confuse it with.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no explicit when-to-use, when-not-to-use, or alternative-naming guidance. The mention that openai objects 'spread straight into a chat completion' implies a use case, but the agent is left to infer when this endpoint is preferable to astroway_mcp_tools_list or the MCP tool-call streaming 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful operational context (cost of 100 credits, Tier 4, endpoint path), but says nothing about latency, auth, or what the AI interpretation actually consists of.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences, front-loaded with the purpose, followed by clearly delimited group/endpoint/cost metadata. Nothing is padded, though the one-line usage hint is thin relative to the space it occupies.

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?

An output schema exists, so return format need not be described, and cost/endpoint metadata is a nice addition. But for a tool whose whole premise is interpreting "a single chart element," the absence of any stated way to select that element (in description or schema) leaves a real completeness hole.

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

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

Schema description coverage is 100% and the nested birth-data object is documented in exhaustive detail, so the baseline is 3. The description adds nothing beyond the schema, and notably neither the description nor the schema exposes any parameter identifying WHICH planet/house/aspect is being interpreted, which is a semantic gap an agent would want addressed.

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

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

States a clear verb+resource: AI interpretation of a single chart element (planet/house/aspect) with context. However it does not distinguish itself from the close sibling astroway_ai_interpret_placement, which appears to cover similar single-element territory, so an agent cannot confidently choose between them from the text alone.

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?

"Useful for chart-detail pages" implies the intended context but gives no when-not guidance and never names an alternative among the many astroway_ai_interpret_* siblings. The usage signal is suggestive rather than directive.

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?

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), so the bar is lower. The description adds genuinely useful operational context: token caching for repeated calls, multi-language output, the POST endpoint, and the 100-credit Tier 4 cost. It does not state what the AI output format is, but the output schema exists.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One front-loaded sentence captures the purpose and output content, followed by short metadata lines for language, caching, group, endpoint, and cost. Efficient, though the bracket-tag lines are somewhat boilerplate rather than description prose.

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 a full output schema, return values need not be explained, and the cost/endpoint/caching details round out what an agent needs. The one real gap is sibling disambiguation among the interpret_* family, which the description never addresses.

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

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

Schema description coverage is 100% and the nested body object documents birth-data fields, timezone rules, and house-system letters in detail. The description adds nothing about body, fields, or precision, so the baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb (Generate AI interpretation) and resource (natal chart), and enumerates the output content (personality traits, life themes, strongest archetypes). It does not explicitly differentiate itself from the many sibling interpret_* tools (element, placement, synastry, transits), leaving the agent to infer 'natal' means the whole birth chart.

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 when-to-use guidance, no exclusions, and no routing to alternatives such as astroway_ai_interpret_transits or astroway_ai_interpret_synastry. The only contextual cue is the [Group: AI Interpretations] tag, which is not usage 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds genuinely useful context not in the schema: the cost (100 credits, Tier 4), the endpoint, and the group. It says nothing about latency, output format, or why idempotentHint is false, but the cost disclosure is meaningful added value.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence followed by compact bracketed metadata — nothing wasteful. The bracketed group/endpoint/cost lines are boilerplate but dense and useful rather than filler.

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

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

An output schema exists, so return-value explanation is not required, and the parameters are fully documented in the schema. However, with seven near-identical AI-interpretation siblings, the description omits the one thing most needed: which interpretation tool to pick. Adequate but with a clear routing 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?

Schema description coverage is 100%, so the schema already documents body, fields, precision, and the planet/language parameters. The description adds no parameter semantics beyond what the schema provides, which is the correct baseline of 3 when the schema does the heavy lifting.

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

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

States a specific verb+resource: 'AI interpretation of a specific planet+sign+house combination,' and the qualifier 'concise, focused on the placement only' signals scope. It somewhat differentiates from the natal/element/synastry siblings by narrowing to a single placement, but never names them.

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 when-to-use guidance, no exclusions, and no routing among the six other astroway_ai_interpret_* siblings. The agent must infer that 'placement only' contrasts with natal/element interpretations without any explicit instruction.

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?

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true and idempotentHint=false, so the safety profile is covered. The description adds one genuinely useful piece of behavioral context the annotations lack: the cost of 100 credits at Tier 4. It says nothing about latency, rate limits, or why repeated calls are not idempotent.

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 single sentence that enumerates the deliverable, followed by compact structured metadata lines for group, endpoint and cost. Nothing is padded, though the content list is a phrase fragment rather than a full sentence.

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

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

With an output schema present, the description need not explain return values, and it covers purpose plus cost. The remaining gap is routing context — an agent has no stated reason to pick this over comparison_coach or the composite/davison path referenced in the 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?

Schema description coverage is 100% and the chart objects carry very detailed field documentation (timezone, houseSystem, ayanamsa), so the schema does the heavy lifting. The description only implies the two-chart input via 'between two charts' and adds no format or constraint detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource ('AI interpretation of synastry between two charts') and enumerates the substance of the output: relationship dynamics, attractions, friction points, long-term outlook. It is distinguishable from the natal/transits/element siblings by the 'two charts' scope, though it never addresses how it differs from astroway_mcp_ai_comparison_coach or the composite/davison calculations the schema mentions.

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 gives no when-to-use guidance, no conditions or prerequisites, and no routing to alternatives such as astroway_ai_interpret_natal (single chart) or astroway_mcp_ai_comparison_coach. The bracket metadata names the group and endpoint but does not tell the agent when this tool is the right choice.

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?

Annotations already declare readOnlyHint/openWorldHint/destructiveHint, so the safety profile is covered. The description adds behavior those annotations cannot express: the cost (100 credits, Tier 4), the structure of what the AI returns, and multilingual output. It does not explain the non-idempotent nature of repeated AI readings, but the added cost and output detail is real value.

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 narrative is front-loaded in one dense sentence covering purpose, input flexibility and output shape, with the metadata block (group, endpoint, required, cost) compactly appended. No sentence is wasted; the only minor cost is that parameter detail is omitted rather than trimmed.

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?

An output schema exists, so return values needn't be described, and cost plus required input are stated. However, for an 8-parameter tool at 38% schema coverage, an agent still lacks guidance on spread, question, art, fields and precision, making the definition only minimally sufficient.

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 only 38%, so the description must carry more of the parameter burden. It covers the two most important ones implicitly (cards accepts slugs or a draw array; language = 'Multi-language'), but art, deck, spread, question, fields and precision get no mention at all, leaving six parameters explained only by terse or absent schema text.

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

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

Specific verb+resource with a clear scope: an AI reading of a spread across three deck systems, with the output shape (per-position reading, synthesis, one piece of advice) spelled out. It doesn't explicitly distinguish itself from the deck-specific siblings astroway_tarot_marseille_interpret or astroway_tarot_rider_waite_interpret, which is the remaining gap.

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?

'Takes card slugs or the drawn array of any draw response' implies the intended workflow (call this after a draw tool) but never states that directly, and gives no guidance on when to prefer the deck-specific interpret siblings over this cross-deck tool. Usage is inferable rather than 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?

Annotations already declare readOnlyHint, openWorldHint, destructiveHint=false, so the safety profile is covered. The description adds genuinely useful operating context the annotations cannot: a 100-credit Tier 4 cost, the endpoint, and group membership. It stops short of noting that idempotentHint is false (repeated calls may re-charge), which would have been valuable for a paid 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 core sentence is front-loaded and wastes nothing; the tagged metadata lines (group, endpoint, cost) are compact and each carries distinct information rather than padding. Nothing is redundant.

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

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

An output schema exists, so return values need not be explained, and the input schema is self-documenting. What remains missing for an agent choosing between many near-identical AI-interpretation siblings is disambiguation guidance, especially against astroway_mcp_ai_explain_transit.

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

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

Schema description coverage is 100% and the nested body, fields, and precision parameters are all thoroughly documented in the schema itself. The description adds no parameter meaning beyond that, which is the expected baseline when the schema does the heavy lifting.

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

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

The description states a specific verb and resource — AI interpretation of current/upcoming transits to a natal chart — with the added scope 'what each major transit means in life context'. This separates it from natal-, synastry-, placement-, and tarot-focused siblings reasonably well. It does not, however, differentiate itself from astroway_mcp_ai_explain_transit, which sounds like it operates in the same territory.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'current/upcoming transits to a natal chart' implies the usage context, but there is no explicit when-to-use statement, no prerequisites (e.g. that a natal chart is needed as input), and no routing to or away from the near-twin sibling astroway_mcp_ai_explain_transit. Usage is left to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the safety bar is low; the description still adds real value by clarifying that endpoints are NOT invoked and that results are cached with a 5-minute TTL. It also discloses the return shape (total + per-endpoint breakdown with tier annotations), which is meaningful since no output schema exists.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three tight sentences, front-loaded with the core capability and the non-invocation guarantee, followed by workflow guidance and the cache note. Nothing is wasted.

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?

Despite having no output schema, the description explains the return value, and the invocation-free and cache behaviors are covered. For a one-parameter, read-only estimator this is fully sufficient.

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

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

Schema description coverage is 100% and the single 'endpoints' parameter is fully documented with examples and the leading-slash rule in the schema. The description only restates 'one or more endpoints' without adding format or constraint detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Estimate the credit cost of one or more endpoints') and immediately pins the scope with 'WITHOUT invoking them', which no sibling tool does. An agent can distinguish this from the many invocation/report siblings at a glance.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit workflow guidance: 'estimate first, ask user confirmation, then invoke' for multi-step planning. This is clear when-to-use context, though it names no alternative tool or when-not-to-use condition.

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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds genuinely useful operational context — cost (100 credits, Tier 4), the required-parameter set, and the endpoint. It stays silent on runtime behavior an agent might care about, such as whether the multi-round debate is long-running, streamed, or bounded in output size. The POST endpoint is not a contradiction of readOnlyHint, but it is worth noting.

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?

Tight and well front-loaded: the core operation comes first, then compact bracketed metadata. Every line carries information (endpoint, required fields, cost) rather than filler. Its brevity is a virtue, though it edges into under-specification.

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?

An output schema exists, so return values need not be described. But for an 8-parameter tool with a nested chart object, aless-than-40% coverage, and a cost of 100 credits, the description leaves critical gaps — most importantly the semantics of agentA/agentB and the effect of rounds/language.

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 only 38%, so the description carries a heavier burden, and it does not meet it. It restates the three required parameters that the schema already marks as required, but never explains what agentA/agentB actually are (persona strings? model IDs?) or what topic expects. Optional params like rounds, language, and fields get no mention.

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?

Uses a specific verb-and-resource phrasing: '2 personas debate a topic, multi-round transcript.' An agent can grasp the operation immediately. However it does not differentiate itself from close siblings such as astroway_mcp_multi_agent_coordinate, astroway_mcp_ai_chat, or astroway_mcp_ai_comparison_coach, which plausibly overlap.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance and no named alternative. The bracketed metadata lists required fields and cost but never says when this debate tool is preferable to multi-agent coordination or AI chat. The [Group: MCP Advanced] tag is organizational, not decision-supporting.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint false, and openWorldHint false. The description adds useful behavioral context in the form of the cost (10 credits, Tier 1) and HTTP method (GET), but does not describe what the status output contains or any auth/rate-limit details.

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 text is short but poorly structured: a vague fragment followed by bracketed metadata lines. It is under-specified rather than concise, and the opening line does not front-load a clear 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?

Although an output schema exists and annotations cover the safety profile, the description still leaves the agent without a clear statement of what the tool does or when to call it. For a status endpoint in a large sibling set, this is a significant omission.

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

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

Schema description coverage is 100%, so the two optional parameters (fields, precision) are fully documented in the schema itself. The description adds no parameter meaning beyond the schema, so the baseline of 3 applies.

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

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

The description gives only a fragment, '8 personas with specialties,' which hints at pool composition but never states that this tool returns agent pool status or what that status contains. It lacks a clear verb and resource, and does not distinguish itself from siblings like astroway_mcp_multi_agent_coordinate or astroway_agent_tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool, when not to use it, or which sibling tool is the alternative. The description contains only metadata tags, not usage instructions.

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?

Annotations already declare read-only, non-destructive, open-world behavior, so the bar is lower; the description still adds real behavioral facts beyond them — a 10-turn history ceiling, 21 output languages, four selectable voices via persona, and a concrete pricing rule (5 credits with your own provider key vs. the endpoint price). It stops short of stating auth requirements or what happens when the history limit is exceeded. No contradiction with 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?

Three tight sentences: the differentiator first, capabilities second, pricing last, followed by a compact metadata block (group, endpoint, required param, tier cost). Every clause carries new information and nothing is repeated from the schema.

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 an output schema present the description needn't explain return values, and annotations cover the safety profile, so what remains — what the tool is for, its capability envelope, and its cost model — is covered. The main gap is that nothing tells an agent when this endpoint should be picked over the other AI/agent siblings.

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?

Top-level schema description coverage is only 43% (chart, fields and precision documented; message, persona, language and history not), so the description must compensate and partially does — it explains persona (four voices), history (~10 turns) and language (21 options). It says nothing about chart, fields compact-mode paths, or precision, though the nested chart schema does carry unusually rich self-documentation for those.

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

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

States a specific verb and resource — an AI chat answered from computed natal-chart positions rather than the model's prior knowledge of a sun sign — and quantifies scope (10 turns, 21 languages, 4 personas). It clearly implies a different product from sibling AI utilities such as astroway_mcp_ai_explain_aspect or astroway_mcp_ai_comparison_coach, but never names them, so the differentiation is by tone rather than explicit contrast.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage context is implied rather than stated: the credit-price note ('send your own provider key and the turn costs 5 credits instead of the endpoint price') hints this is a paid, higher-tier call, and 'chart-grounded' hints the input needs birth data. There is no explicit when-to-use-it, when-not-to, or routing rule against the other chat/agent endpoints in 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true and idempotentHint=false, so the safety profile is covered. The description adds genuinely useful operational context (the 100-credit Tier 4 cost and the POST endpoint), but says nothing about the fact that an LLM-backed coach may return non-deterministic prose, what latency to expect, or what deprecates the idempotentHint=false signal.

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 four lines are tight and the purpose sentence is front-loaded ahead of the bracketed metadata block. Nothing is padded, though the metadata lines are boilerplate rather than definitional 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?

An output schema exists, so return values need not be explained, and the cost/endpoint block is present. But for a six-parameter AI tool embedded among dozens of similar compatibility siblings, the description lacks any hint of what the coaching output contains or what makes a good 'question', leaving the agent to guess at scope.

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 67% and the nested chart objects carry extensive inline documentation (formats, rejected short names, timezone semantics, houseSystem letters), so the schema does the heavy lifting. The description only restates the required parameters (chart1, chart2, question), adding no meaning for question, language, fields or precision. 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 names a specific verb (coach), the resources (two charts) and the domain (relationship dynamics), so the agent knows this produces interpretive guidance rather than raw chart data. It does not, however, distinguish itself from the many sibling compatibility tools (ashtakoot, dashakoota, compatibility_full) or from astroway_mcp_ai_chat, so sibling differentiation is left to inference.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use or when-not-to-use guidance, and no alternative is named. A reader cannot tell whether to reach for this AI coach versus the deterministic Vedic compatibility endpoints or multi_chart_context. The only constraints given are required parameters and cost, which are not usage 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true and idempotentHint=false, so the safety profile is covered without the description. The description does add genuinely useful operational context not present in the annotations: the credit cost (100 credits, Tier 4) and the endpoint. However it never explains why a read-only operation is flagged non-idempotent (repeated calls likely yield differently worded narrative), which is the one behavioral trait an agent would most want here.

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 purpose sentence is front-loaded and the payload is small. The '[Required: planet1, planet2, aspectType]' line duplicates the schema's required array, but the cost and endpoint lines justify their space.

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?

An output schema exists, so return values need not be described. But for a 7-parameter tool with a nested chart object and LLM-backed generation, the description omits the valid domain for planet1/planet2, any usage guidance versus explain_transit, and any hint about generation latency or variable output.

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 lists the three required parameters, but schema coverage is only 43% and planet1/planet2 carry no description, no enum and no example anywhere in the schema, so the agent must guess the accepted form (planet names such as 'Mars'?). The description does not compensate for that gap, which is the weakest part of the definition.

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?

Names a specific verb and resource: 'explanation of an aspect between two planets.' An agent can tell it apart from the sibling astroway_mcp_ai_explain_transit by the resource alone, but the description never makes that contrast explicit nor states what kind of explanation is produced.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance, no prerequisites, and no mention of the sibling explain_transit as an alternative. The only contextual cues are bracketed metadata (endpoint, required fields, credit cost), which tell the agent what it costs but not when it should be chosen.

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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description usefully adds the cost (100 credits, Tier 4) and the endpoint, which annotations do not provide. It does not explain why idempotentHint is false for a read-only call, nor what the AI explanation entails.

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 short and front-loads the purpose before the bracketed metadata. The bracketed group/endpoint/required/cost lines are slightly noisy but each carries compact information, so there is little 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?

An output schema exists, so return values need not be described. But for a 5-required-parameter tool with a near-twin sibling, the description omits the disambiguation, parameter usage, and cost implications an agent needs before committing. It is minimally adequate rather than complete.

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

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

Schema description coverage is only 38%, so the description should compensate, but it merely restates the five required parameter names that the schema already marks required and says nothing about what transitPlanet, natalPlanet, aspectType accept or how the optional fields/precision/language parameters behave. It adds no 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?

States a specific verb and resource: 'Explain a current transit hitting your natal chart.' An agent can grasp the purpose immediately. However, it never distinguishes itself from the close sibling astroway_mcp_ai_explain_aspect, leaving the borderline case ambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance, no exclusions, and no comparison to the near-identical sibling astroway_mcp_ai_explain_aspect. The '[Required: ...]' and '[Cost: ...]' lines are metadata, not routing guidance. The agent gets no help deciding between this and other AI 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered structurally. The description usefully adds the cost (100 credits, Tier 4) and the endpoint/group, but says nothing about latency, response shape of the synthesis, or how many personas are permitted (schema caps at 4).

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the operative sentence, followed by compact bracketed metadata; there is no filler prose. The brevity is close to under-specification rather than pure conciseness, keeping it out of the top band.

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?

An output schema exists so return values need not be described, and cost is disclosed. However, for a tool whose whole contract is choosing personas and a question, the description never explains what the agents array should contain, leaving the most decision-relevant input undocumented across both description and 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?

Schema coverage is only 50% and the description adds no meaning beyond listing the two required names. Critically, the 'agents' array is the defining parameter and neither the schema nor the description explains what identifiers it accepts, and 'question' semantics are equally unexplained.

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

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

States a specific verb (Run), resource (N personas) and mechanism (parallel + LLM synthesis), which is more informative than a tautology. It does not name or distinguish itself from the obvious sibling astroway_mcp_agent_debate, so the agent must infer the difference between coordinated parallel personas and a debate.

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 when-to-use guidance, no prerequisites, and no alternatives are named despite several closely related siblings (agent_debate, multi_chart_context, ai_chat). The '[Required: question, agents]' line just restates the schema's required array rather than telling the agent when this tool is the right choice.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds genuinely useful non-annotation behavior: a 10-credit (Tier 1) cost and the POST endpoint. It says nothing about what the operation returns or how it behaves across the 1-6 chart array, so it earns only partial credit.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

It is short and front-loads the one-sentence purpose, with well-organized bracketed metadata. But that metadata is machine-oriented boilerplate (group/endpoint/required) and the prose line is largely redundant with the title, so the brevity reflects under-specification as much as discipline.

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?

An output schema exists, so return values need not be explained, but for a tool taking up to six nested chart objects with four intent modes and compact-mode fields/precision, the description is far too thin. It gives an agent no way to know what a "compatibility" vs "forecast" run produces or why to pick it over the many neighbouring multi-chart tools.

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 content is "[Required: charts]", which merely repeats the schema's required array, adding zero meaning. The description says nothing about `fields`, `precision`, or the four `intent` modes — the latter has no schema description at all despite being the main selector. At 50% schema coverage this is a real gap it fails to fill.

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?

"Compact context for MCP agents working across multiple charts" largely restates the name/title (multi-chart context) without naming an action or an output. The word "context" is undefined — it never says whether this computes cross-chart aspects, comparison summaries, or group forecasts. Only the bare notion "multiple charts" distinguishes it from the many single-chart siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance at all: no trigger conditions, no prerequisites, and no routing against the large sibling set (e.g. astroway_mcp_multi_agent_coordinate or astroway_mcp_ai_comparison_coach). The `intent` enum (compatibility/family/group/forecast) suggests several distinct use cases, but the description never explains when to choose which.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered structurally. The description adds genuinely useful context the annotations do not: the endpoint, the 10-credit Tier 1 cost, and the group. It does not disclose result ordering, chunk granularity, or hit limits, so it stops short of rich 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?

Four short, front-loaded lines with no prose padding; the core purpose statement leads. The "Required" line is redundant with the schema, which is the only real 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?

For a tool taking a deeply nested chart object plus three tuning parameters, the description is thin: no sense of ranking/scoring semantics, no indication of what the chunks are drawn from, and no guidance on choosing topK. An output schema exists so return format need not be explained, but the retrieval behavior itself is left entirely to inference.

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 a middling 60%. The description adds no parameter meaning at all — it only echoes the two required names already enforced by the schema — and says nothing about topK's default/range, the fields compact projection, or precision, the parameter most likely to be misused.

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?

Names the mechanism (keyword-tag scoring) and the corpus (chart chunks), which goes beyond simply restating the tool name. However, it never says what the tool returns or what a "chunk" is, so an agent cannot tell whether this is a document retriever over interpretive text or a query over computed chart 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?

The only usage-adjacent line is "[Required: query, chart]", which merely restates the schema's required list. There is no statement of when to reach for this tool rather than a direct retrieval sibling (e.g. astroway_mcp_multi_chart_context), and no prerequisites or 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, so the safety profile is covered. The description adds genuinely non-derivable behavior: the response is delivered as an SSE stream rather than one payload, crediting at 100 credits (Tier 4), and the concrete endpoint. It omits auth requirements and why idempotentHint=false, which keeps it out of 5 territory.

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 and front-loaded: the core capability leads, with bracketed metadata (group, endpoint, required param, cost) following compactly. Every line carries information, though the template-style [Group:]/[Endpoint:] format is more machine header than prose.

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 streaming tool with no output schema and a nested chart parameter, the definition covers the essential facts (SSE transport, required message, optional chart, cost). It does not describe what the stream emits or how chart context influences the completion, leaving gaps an agent would notice mid-invocation.

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

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

Schema description coverage is 60%, with the nested chart object heavily documented in the schema itself (timezone, houseSystem letters, lat/lon full names, ayanamsa). The description adds only 'optional chart context', which restates the schema's required list. Baseline 3 is appropriate when the schema does most of the work.

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

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

States a specific verb+resource+mechanism: 'Server-Sent Events streaming chat completion with optional chart context.' An agent can tell this is a streaming chat tool rather than a static computation. It does not explicitly name or contrast with the closest sibling astroway_mcp_ai_chat, so it stops short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use or when-not-to-use guidance. Nothing tells the agent to prefer this over astroway_mcp_ai_chat (non-streaming chat) or astroway_mcp_tool_call_stream; the streaming qualifier implies a context but the choice is left entirely to inference.

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?

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the safety profile is covered. The description adds two genuinely useful behavioral facts annotations cannot express: delivery is server-sent events rather than a single response, and the call costs 10 credits (Tier 1). It still omits stream termination, error-over-stream behavior, and whether partial results can be replayed.

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?

Very short and front-loaded: one sentence of purpose followed by structured metadata brackets. Nothing is wasted, though the single sentence is so compressed that the core mechanics of the tool are never actually spelled out.

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 5-parameter tool with a nested free-form args object, a free-text tool selector, compact-mode options, and no output schema, this is under-specified. An agent cannot tell what the stream emits, how to consume it, or what valid values for tool are (presumably must match astroway_mcp_tools_list entries), all of which are load-bearing here.

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 only 40% across 5 parameters, and the description adds nothing beyond confirming that tool is required. args (arbitrary nested object forwarded to the target tool), language, and the compact-mode interplay of fields/precision are left entirely to the schema; the description should explain that args are passed through verbatim to the named tool.

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

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

"SSE-stream of a tool call envelope" names a delivery mechanism and an artifact, so the agent knows this is a streaming wrapper that executes a named tool. However, "tool call envelope" is opaque jargon and the definition never states the key fact that this proxies/executes another MCP tool by name, nor how it differs from the sibling astroway_mcp_streaming or astroway_mcp_tools_list.

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 only usage cue is the bracketed "[Required: tool]" — there is no when-to-use, no when-not-to-use, and no routing to an alternative despite multiple plausible siblings (astroway_mcp_streaming, astroway_mcp_tools_list, astroway_agent_tools). The agent must guess whether streaming is preferred over a plain call.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful behavioral context the annotations do not: the concrete GET endpoint and a cost caveat that this scope is not in the public credit manifest. It does not explain response size or pagination for a manifest that presumably enumerates all tools.

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 single purpose sentence is front-loaded and the metadata tags are compact, but the bracketed group/endpoint/cost lines are boilerplate scaffolding rather than description content. Nothing is wasted, yet very little informational payload is delivered.

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?

An output schema exists so return-value documentation is not required, but for a meta-tool that enumerates the entire tool surface, the description never explains the scenario in which an agent would reach for it instead of directly invoking a domain tool. Given the enormous sibling set, this leaves a real 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?

Schema description coverage is 100%, so both `fields` and `precision` are already documented in the schema with examples and constraints. The description contributes no additional parameter meaning; the 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?

"Auto-generated tool manifest for MCP clients" largely restates the name 'MCP Tools List' without a distinct verb or an explanation of what the response actually contains. It gives an endpoint and spec version but no functional description that would distinguish its purpose from any other listing endpoint.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no statement of when an agent should call this tool, what problem it solves, or how it relates to the ~190 sibling tools. The only contextual cues are the bracketed [Group]/[Endpoint]/[Cost] metadata tags, which are not usage 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?

Annotations declare openWorldHint=true, idempotentHint=false, and readOnlyHint=false, but the description adds nothing about what streaming actually means here (connection lifetime, chunk cadence, termination). It does add genuinely useful operational context the annotations lack: the endpoint and a 10-credit Tier 1 cost. No contradiction with the 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?

A single front-loaded sentence plus three bracketed metadata lines; nothing is padded or redundant. It is terse to the point of under-specification rather than verbose.

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?

An output schema exists, so return-value explanation is not required, and cost/endpoint are covered. What is missing is the streaming-specific behavior an agent needs to call this correctly: delivery mechanism, whether it terminates after the countdown, and how it differs from the eclipse_totality and eclipse webhook siblings.

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

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

Schema description coverage is 100% and both optional parameters (fields, precision) are fully documented in the schema, so the baseline is 3. The description adds no meaning about compact mode or precision beyond what the schema already states.

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

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

States a specific resource and scope: a countdown to the next 5 eclipses. An agent can tell it produces upcoming-eclipse timing data, though it never contrasts itself with the very similar sibling astroway_stream_eclipse_totality, so sibling differentiation is missing.

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 offers no when-to-use guidance, no prerequisites, and no named alternatives despite a dense sibling set (eclipse_totality, webhooks_eclipse_alert, stream_transit_alerts). Usage is only implied by the name and the '[Group: Real-time Streaming]' label.

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?

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true, idempotentHint=false), so the bar is lower. The description adds genuinely useful operational data not in the annotations: the POST endpoint, the streaming group, and the 10-credit cost. However, it says nothing about how the stream delivers results (one-shot vs long-lived, cadence), which is the core behavioral question for a stream 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?

A single front-loaded sentence followed by compact bracketed metadata. Nothing is wasted, and the resource and scope land first. Slightly terse given the ten sibling stream tools, but structurally clean.

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?

An output schema exists, so return values need not be explained, and annotations cover safety. But the description leaves the streaming mechanics unstated and the latitude/longitude parameters undocumented, which is a gap for a tool whose entire value proposition is a stream rather than a single response.

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 only 50%: fields and precision are documented in the schema, but latitude and longitude have no descriptions anywhere. The tool description adds zero parameter meaning, so the undocumented coordinates are left entirely ambiguous for a tool that clearly needs an observer location.

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

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

States a specific resource (next solar+lunar eclipses) and scope (with totality info). An agent understands what it returns, but the description never names or contrasts with its closest sibling, astroway_stream_eclipse_incoming, so differentiation is left to inference.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance and no mention of alternatives. The [Group: Real-time Streaming] tag hints at the streaming context but does not tell the agent when to pick this over eclipse_incoming or webhooks_eclipse_alert.

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?

Annotations already declare the safety profile (destructiveHint=false, openWorldHint=true, idempotentHint=false, readOnlyHint=false), so the description does not need to restate it. The description does add real context the annotations lack: the cost (10 credits, Tier 1) and the endpoint. It stops short of explaining what 'streaming' means here — one-shot list versus a live subscription — and never explains why a query-like tool is flagged non-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 core sentence is front-loaded and free of padding, and the metadata block (group, endpoint, cost) is scannable rather than prose bloat. It loses a point only because the lead sentence is a verbless fragment rather than a complete statement of the operation.

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?

An output schema exists, so return-value description is not required, and complexity is low with only 3 optional params. What is missing is the streaming semantics and the distinction from the webhook-based sign-ingress sibling — the two things an agent most needs to call this correctly instead of its twin.

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 67%: 'fields' and 'precision' carry their own descriptions, but 'days' is undocumented in the schema. The phrase 'for N days' partially compensates by implying a forward window, though it gives no default, bounds, or unit guidance. Baseline 3 for a mid-coverage schema where the description closes only part of the 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 fragment 'Next planet sign-ingresses for N days' names a specific resource (planet sign ingresses) and a scope (N-day forward window), which is enough for an agent to distinguish it from siblings like stream_positions or stream_lunar_phase. It does not, however, differentiate itself from the near-twin sibling astroway_webhooks_sign_ingress, and the verbless phrasing leaves the operation type implicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance, no conditions, and no named alternative. The agent is not told why it should pick this over astroway_webhooks_sign_ingress or astroway_stream_transit_alerts, nor what preconditions (if any) apply.

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?

Annotations already declare the safety profile (readOnlyHint=false, idempotentHint=false, destructiveHint=false, openWorldHint=true). The description usefully adds the endpoint and a concrete cost of 10 credits (Tier 1), which annotations do not cover, but it says nothing about what 'stream' means in practice (one-shot snapshot vs. continuous/long-lived connection).

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 terse and front-loaded: the output summary leads, followed by structured endpoint/group/cost metadata. No filler, though the body is almost too short to be self-sufficient.

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?

An output schema exists, so return-value explanation is not needed, and cost/endpoint are supplied. However, combining a streaming endpoint with readOnlyHint=false, the agent still lacks a clear statement of the connection's nature and duration, which is material for a stream 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 description coverage is 100%: both 'fields' and 'precision' are fully documented in the schema, including format and defaults. The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

Names a specific resource (lunar phase) and states exactly what it yields: the current 8-phase plus a countdown to the next major phase. It is distinct from stream siblings like eclipse/ingress, but it never explicitly contrasts itself with them or with non-streaming alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to call this versus other streaming endpoints (eclipse, ingress, void-of-course) or versus webhook subscriptions. The [Group: Real-time Streaming] tag implies a family but gives no selection criteria.

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?

Annotations already declare the safety/profile (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false). The description adds genuinely useful non-annotation context: the pricing tier (10 credits), the streaming group, and the POST endpoint. It does not disclose whether this is a persistent stream or a one-shot fetch, nor stream duration/termination behavior, so it stops short of rich 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?

Extremely tight and front-loaded: the return content leads, followed by bracketed metadata for group, endpoint, required params, and cost. Every line carries information with no filler, though the telegraphic style sacrifices some readability.

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 an output schema present, return-value documentation is rightly omitted, and annotations plus the cost/endpoint metadata cover the operational basics. However, for a streaming POST endpoint the description never clarifies consumption model (persistent stream vs single response) or why readOnlyHint is false, leaving a meaningful gap for an agent deciding how to invoke it.

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 60%, so a baseline of 3 applies. The description only restates that latitude/longitude are required (already in the schema's required list) and adds no semantics for timezoneOffset, precision, or fields, whose meaning comes entirely from the 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?

"Current planetary hour + next 24" names the concrete resource and scope (planetary hour, 24h horizon), which cleanly distinguishes it from siblings like astroway_stream_lunar_phase or astroway_stream_ingress. It lacks an explicit verb, so an agent must infer that this returns/fetches the data, but the noun is specific enough to identify the 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 states prerequisites (latitude, longitude) and cost, but gives no when-to-use guidance, no conditions for choosing it over alternative stream endpoints, and no mention of the closely related astroway_webhooks_planetary_hour_tick sibling. The agent must infer the use case entirely.

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?

Annotations already declare the safety profile (destructiveHint=false, openWorldHint=true), and the description adds two genuinely useful facts not in the structured data: the 30-second tick cadence and the 10-credit Tier 1 cost. However it does not explain the streaming lifecycle (how updates are delivered, when the stream ends, why a 'snapshot' is flagged readOnlyHint=false and non-idempotent), leaving the non-readonly flag unexplained.

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 one-line purpose followed by compact bracketed metadata; nothing is padded. The bracketed lines are boilerplate but carry real cost/endpoint information, so they earn their 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?

An output schema exists, so return-value detail is not required. Still, for a non-readonly streaming tool the description omits lifecycle semantics (duration, termination, billing per tick vs per call), which an agent needs to call it correctly.

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

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

Schema description coverage is 100% and both parameters (fields, precision) carry detailed descriptions with examples, so the schema does the heavy lifting. The description adds no additional parameter meaning, so the baseline 3 applies.

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

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

States a concrete resource and verb-equivalent: a snapshot of current planetary positions, with the tick cadence. It is distinguishable from sibling streams (ingress, retrograde alerts, void-of-course) by being the general positions feed, though it never explicitly names what separates it from astroway_mcp_streaming or astroway_stream_transit_alerts.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance at all: no condition selecting this stream over the other stream_* siblings or over astroway_mcp_streaming, and no stated prerequisite. Only endpoint, group and credit cost are given, which is operational metadata rather than usage routing.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, openWorldHint=true, destructiveHint=false, so the safety/idempotency profile is covered. The description adds genuinely useful context the annotations lack: cost (10 credits, Tier 1), group, and endpoint. However, it says nothing about streaming mechanics (persistent connection, event cadence, what 'next stations' returns) which is the core behavioral question for a stream 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?

Extremely short and front-loaded: the payload summary comes first, followed by compact metadata lines. Nothing is padded. The trade-off is that the opening line is a telegraphic fragment rather than a sentence, which slightly hurts readability without wasting space.

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?

An output schema exists, so return values need not be explained, and the cost/endpoint metadata is present. What is missing for a real-time streaming tool is any statement of how the stream behaves or when it terminates, and there is no routing against the many retrograde/webhook siblings. Adequate but with clear 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 100%, so both optional parameters (fields, precision) are already fully documented with examples and defaults. The description adds no parameter meaning beyond that, which is the correct baseline of 3 when the schema does the heavy lifting.

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 fragment 'All planets retro state + next stations' conveys the resource and payload (retrograde states plus upcoming station dates), but there is no verb and no differentiation from the retrograde-related siblings such as astroway_webhooks_retrograde_start/end or astroway_stream_transit_alerts. An agent can guess the payload but cannot tell why this differs from the webhook retrograde tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use guidance and no mention of alternatives. The sibling list contains at least four closely related retrograde/webhook tools, yet the description never says when to choose this stream over a webhook subscription or a transit-alert stream. Usage must be fully inferred from the name.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false. The description adds genuinely useful non-schema context: it is a real-time streaming endpoint, it is a POST, and it costs 10 credits (Tier 1). It does not, however, explain what streaming implies (connection handling, delivery cadence, how to consume the stream), which is the key behavioral unknown for this tool class.

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?

Very compact and front-loaded: the payload sentence comes first, followed by bracketed metadata that is easy to scan. Nothing is wasted, though the terse style leaves behavioral gaps rather than being merely economical.

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?

An output schema exists, so return values need not be described here. The essentials (required coords, cost, streaming group) are present, but for a real-time streaming tool with readOnlyHint=false there is no explanation of the streaming lifecycle or connection behavior, leaving the definition minimally adequate.

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

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

Schema coverage is 60%: fields, precision, and timezoneOffset are documented in the schema, while latitude and longitude carry no descriptions. The description only restates that latitude and longitude are required, which the schema already marks as required, so it adds little parameter-level value. Baseline 3 fits given the moderate coverage and the self-evident nature of lat/long.

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

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

States a specific resource (sun events) with a scope qualifier (today + tomorrow), and the tool name plus endpoint make the sunrise/sunset purpose unmistakable. It does not explicitly differentiate from sibling stream tools like lunar_phase or ingress, but the resource is distinct enough that an agent can tell them apart.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use vs alternative guidance. The bracket notes list group, endpoint, requirements, and cost, but never say when an agent should pick this stream over another stream tool or a webhook equivalent. Usage is only implied by the name.

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

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

Annotations already declare non-read-only, non-idempotent, open-world behavior; the description adds nothing behavioral beyond a credit cost and endpoint. Critically, it never explains what 'stream' means here (SSE, long-poll, chunked response) or how repeated calls behave, despite idempotentHint=false.

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 short and front-loaded: the purpose sentence leads, with group, endpoint and cost as compact metadata tags. Nothing is padded, though the terseness is achieved partly by omitting load-bearing 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?

An output schema exists, so return values need no explanation, and cost/endpoint metadata is present. However, for a streaming tool requiring a full birth-data body, the description says nothing about delivery mechanics or how the 'next N hours' window interacts with the required natal data — a real 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?

Schema coverage is 100% and the nested body description already documents date/time/coordinates/timezone rules in depth, so the schema carries the load. The description's 'N hours' hints at the hours field but adds no syntax or semantics beyond that, matching the baseline 3.

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

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

States a specific resource and condition — 'natal-transit hits within next N hours' — which is clearly distinguishable from stream_positions or stream_ingress. It does not name a sibling or scope boundary, so it falls short of 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use guidance is given. With siblings like astroway_webhooks_transit_trigger and astroway_stream_retrograde_alerts in the same family, the agent must guess whether streaming vs. webhook delivery is the right choice; the [Group] tag is metadata, not guidance.

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

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

Annotations already declare the safety profile (readOnlyHint false, openWorldHint true, not idempotent). The description adds genuinely useful context beyond them: it is a POST streaming endpoint and costs 10 credits (Tier 1). It still says nothing about auth requirements, connection lifetime, or stream termination 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 core purpose is front-loaded in one line, followed by compact bracketed metadata for group, endpoint, and cost. No filler, though the abbreviation 'VOC' is never expanded for agents unfamiliar with the domain term.

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?

An output schema exists, so return values need not be described, and annotations cover safety. However, for a paid real-time stream with numerous closely related siblings, the description lacks the when-to-use and streaming-behavior context an agent needs to call it correctly.

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

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

Schema description coverage is 100%, so both optional parameters (fields, precision) are fully documented in the schema itself. The description adds no parameter detail, so the baseline 3 applies when the schema does the heavy lifting.

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 names a specific resource and action: current Moon void-of-course status plus the next ingress. An agent can tell it produces VOC timing data, not raw positions or phases. It does not differentiate itself from the nearby astroway_stream_ingress or astroway_webhooks_void_of_course_start, which is the main gap.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no statement of when to use this stream versus the sibling streams (ingress, transit_alerts) or the webhook variant void_of_course_start. The '[Group: Real-time Streaming]' tag hints at the mode but gives no selection criteria or 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?

Annotations already declare the safety profile (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false), and the description adds genuinely useful context: the event that triggers firing and a cost of 10 credits (Tier 1). It does not explain what happens on duplicate registration, retries, or failure handling, which matters for a non-idempotent write.

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 compact and front-loaded: the trigger event leads, followed by bracketed metadata tags for group, endpoint, required param, and cost. Every element carries information with no filler.

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

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

An output schema exists, so return values need no explanation, and annotations cover the safety profile. However, for a webhook-registration tool sitting among a dozen similar siblings, the absence of any disambiguation or registration-semantics detail leaves a real 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?

Schema coverage is 67%: fields and precision are self-documented in the schema, while url has no schema description and is only echoed as '[Required: url]'. The description adds no syntax or format detail beyond what the schema already provides, so the 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 first line states the trigger event ('Vedic Vimshottari dasha period transitions') and the endpoint (POST /v1/webhooks/dasha-change) plus title make the action (registering a webhook) clear. It does not explicitly differentiate from the many sibling webhook tools (e.g. mahadasha_end), but the resource and event are specific enough to identify the 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?

No when-to-use guidance, no prerequisites, and no routing among the ~13 sibling webhook tools. An agent cannot tell from the description when dasha_change should be preferred over mahadasha_end or retrograde_start.

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?

Annotations declare it is a non-read-only, open-world, non-idempotent mutation, so the safety profile is covered. The description usefully adds the cost (10 credits, Tier 1) and the default timing, which are not in structured fields, but says nothing about auth requirements, delivery semantics, or what happens on re-subscription.

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-loads the core action in one sentence, then uses bracketed metadata for group, endpoint, requirement, and cost. Efficient and scannable with no filler.

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

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

With an output schema present, return values need not be explained, and the description covers endpoint, required param, cost, and default behavior. The main omission is usage routing against the streaming eclipse siblings, which is a guidance gap rather than a completeness one.

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 67%: `fields` and `precision` are well documented in the schema, while `url` has no schema description. The description only echoes '[Required: url]' and adds no syntax or format detail beyond the schema, so baseline 3 is appropriate.

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

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

States a specific verb ('Subscribe') and resource ('upcoming eclipse alerts') with the default lead time (7 days before). Combined with the [Group: Webhooks] tag, an agent can place it against streaming siblings, though it never explicitly contrasts itself with astroway_stream_eclipse_incoming.

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 when-to-use or when-not-to-use guidance and no named alternatives. The 'default 7 days before' hints at behavior but the description never tells the agent when a webhook subscription is preferable to the eclipse streaming 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?

The description presents a read operation ('Fetch', GET endpoint), yet annotations declare readOnlyHint=false and idempotentHint=false, which implies possible state change and non-repeatable behavior not explained anywhere. The added cost note ('see your plan — endpoint not in the public credit manifest') is genuinely useful behavioral context beyond the annotations, but the read/write mismatch undermines trust.

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 opening sentence is front-loaded and every bracketed metadata line (group, endpoint, required, cost) is compact and earns its place. Slightly mechanical, but no wasted prose.

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?

An output schema exists, so return values need not be described, and the ownership scope is stated. However, the definition leaves the read-only-versus-mutating question unresolved despite the contradictory annotation, and gives no error/auth context for a 3-parameter tool.

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

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

Schema description coverage is 100%, so the schema itself already documents id, fields, and precision in detail, making 3 the baseline. The description only repeats '[Required: id]' and adds no format or syntax meaning beyond what the schema provides.

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

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

States a specific verb and resource ('Fetch a single webhook subscription') plus an ownership scope ('owned by the authenticated user'), which distinguishes it from the sibling list tool astroway_webhooks_webhooks and from astroway_webhooks_subscribe. It stops short of naming those alternatives explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use or when-not-to-use guidance; the definition never says to prefer this over the listing endpoint or the subscribe/test siblings. The '[Required: id]' note only restates schema requirements rather than indicating when the call 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?

Annotations declare the safety profile (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false), so the bar is lower. The description still adds non-obvious behaviour: the delivery is synthetic, the payload is fixed, and the attempt is recorded in failure_count / last_status_code — i.e. the call mutates webhook health state, not just the remote endpoint.

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 prose is two tight sentences with the action first and the side effect second, no repetition of the title. The bracketed group/endpoint/cost metadata is terse framing rather than padding.

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

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

With an output schema, full schema coverage, and annotations present, the description only needs to add the intent and side effects, which it does. The one material omission is whether a failed test increments failure_count enough to affect the webhook's own health/disablement — relevant given it explicitly mentions failure_count.

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

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

Schema description coverage is 100%, so `id`, `fields` and `precision` are already fully documented and the baseline is 3. The description adds nothing about parameter syntax or formats; its only extra semantic is that no user-supplied payload parameter exists, which is marginal.

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

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

States a specific verb and resource: it fires a synthetic delivery to the webhook registered at the given id, and even names the payload used ({ "test": true }). That is enough to tell it apart from the other webhook siblings, which are event subscriptions and CRUD rather than diagnostic test firing.

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?

"Useful when validating endpoint signature handling" gives an explicit context for reaching for this tool, which is more than most siblings offer. It stops short of naming when not to use it (e.g. to verify real production deliveries or to check endpoint health without mutating counters), so it is clear context without 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?

Annotations already declare readOnly=false, idempotent=false, destructive=false and openWorld=true, so the safety profile is covered. The description usefully adds the cost (10 credits, Tier 1) and the endpoint, but omits behavior an agent would want: that repeated calls create duplicate registrations (idempotentHint=false), that url must presumably be publicly reachable/HTTPS, and what registration returns. With annotations carrying the main load, a 3 is appropriate.

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 definition is short and front-loads the event trigger, followed by compact bracketed metadata (group, endpoint, required, cost). No sentence is wasted, though the bracket block is somewhat skeletal rather than explanatory.

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?

An output schema exists, so return values need not be described, and endpoint/cost/required are present. Gaps remain for a webhook-registration tool: the undefined 'N days' is never explained or tied to a configurable parameter, and the relationship to astroway_webhooks_subscribe (does it need to be called first?) is unstated. Adequate but with clear holes.

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 a middling 67%: fields and precision are documented in the schema, while url carries only type/format with no description. The description's '[Required: url]' merely restates what the schema already marks as required and adds no constraint details (scheme, reachability, retry expectations). Baseline 3 is right since the schema does most of the parameter work.

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 trigger event ('Fires N days before a Vimshottari mahadasha ends') but never names the actual action of the tool, which is registering/subscribing a webhook. Grouping it under [Group: Webhooks] and the endpoint tag help the agent infer intent, but the wording describes an event rather than a create/subscribe operation. It also does not differentiate from the closely related sibling astroway_webhooks_dasha_change.

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 trigger condition ('N days before a mahadasha ends') implicitly signals when this webhook is relevant, which is a form of usage context. However, there is no explicit when-to-use, no when-not-to-use, and no routing to alternatives such as astroway_webhooks_dasha_change or astroway_webhooks_subscribe. Whether a generic subscribe call is a prerequisite is left entirely to inference.

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?

Annotations already declare readOnlyHint=false, idempotentHint=false and openWorldHint=true, so the mutation and idempotency profile is covered. The description adds genuine context the annotations lack – a recurring 24/day firing cadence and a cost of 10 credits (Tier 1) – but says nothing about auth requirements, duplicate-registration behavior, or delivery semantics.

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 compact and front-loaded: the firing semantics come first, followed by bracketed Group/Endpoint/Required/Cost metadata. Every line carries distinct information with no filler.

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

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

For a simple webhook-registration tool, the description covers the event, cadence, endpoint, cost, and required parameter, and an output schema exists so return values need no explanation. It omits setup/auth and lifecycle details (e.g., how to unregister), which keeps it short of 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 67%, and 'fields'/'precision' are already well documented in the schema, so the schema does the heavy lifting. The description only restates '[Required: url]' and adds no meaning for the undocumented url parameter or for how fields/precision interact with the payload.

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 trigger event precisely – 'Fires at every planetary hour boundary (24/day)' – and the bracketed endpoint plus title make the register-a-webhook action clear, distinguishing it from the streaming sibling astroway_stream_planetary_hour_changes. It never names that sibling, but the event resource and cadence are 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 when-to-use, when-not-to-use, or alternative is given. Nothing routes the agent between this webhook and astroway_stream_planetary_hour_changes (the streaming equivalent) or astroway_webhooks_subscribe, so the agent must infer the choice entirely on its own.

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?

Annotations already cover the safety profile (write, non-idempotent, open-world, non-destructive), and the description adds real value by disclosing cost (10 credits, Tier 1) and the concrete endpoint. It does not say whether repeated registrations for the same URL create duplicates (relevant given idempotentHint=false) or what auth/permissions are required.

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 compact and front-loaded: the trigger condition comes first, followed by tight bracketed metadata. Nothing is wasted, though the bracketed metadata style reads more like reference data than explanatory prose.

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 an output schema present, return values need not be explained, and the essential call facts (endpoint, required param, cost, trigger) are covered. Still missing is routing guidance against the many sibling webhook registration tools and any note on auth or duplicate-URL handling for a non-idempotent write.

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 67%, with 'fields' and 'precision' fully documented in the schema and the description only flagging '[Required: url]'. The description adds no syntax, format, or validation meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The trigger condition is stated precisely ('fires when any of Mercury–Pluto stations direct') and the bracketed endpoint plus title 'Register Retrograde-End Webhook' make the action unambiguous. It is clearly distinguishable from astroway_webhooks_retrograde_start by the 'stations direct' event, though the description itself never names that 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 definition of the firing event implies when this webhook is relevant, which is genuine selection context. However, it gives no explicit guidance on when to prefer this over the sibling astroway_webhooks_retrograde_start or the other webhook registration tools, and no prerequisites or exclusions are 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?

Annotations already disclose the write profile (readOnlyHint=false, idempotentHint=false, openWorldHint=true), so the description need not repeat safety. It does add useful behavioral context in the form of cost (10 credits, Tier 1) and the endpoint path, but it does not explain delivery semantics, whether re-registering duplicates a subscription, or what the call returns.

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 trigger condition is front-loaded and the bracketed metadata (group, endpoint, required, cost) is compact and scannable. Every element carries information, though the metadata block is somewhat list-like rather than prose.

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?

An output schema exists, so return values need not be described, and annotations cover the mutation profile. Still, for a tool that registers a persistent subscription, the description leaves open whether repeat calls create duplicate webhooks and how this differs from the retrograde_end sibling, leaving a meaningful 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?

Schema description coverage is 67%, above the baseline threshold, and the two non-required params (fields, precision) are well documented in the schema itself. The description only restates that url is required, adding no syntax or format detail beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description names the specific trigger event ("Mercury–Pluto stations retrograde") and the endpoint, and the sibling set makes it clearly distinguishable from retrograde_end. However, the verb describes the webhook's firing behavior rather than the tool's action of registering it, so the actual operation ("register") is only conveyed by the title, not the description text.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance: nothing tells the agent when to register this webhook versus retrograde_end, subscribe, or the streaming alternatives like stream_retrograde_alerts. Only the required parameter is noted, leaving selection entirely to inference.

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?

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the agent knows this is a non-destructive, non-idempotent creation. The description usefully adds cost (10 credits, Tier 1) and the endpoint, but it never explains how the 'N days' lead time is configured — no such parameter exists in the schema — which is a meaningful behavioral gap for a registration 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 definition is a single front-loaded sentence plus compact bracketed metadata for endpoint, required param, and cost. Efficient, though the bare bracketed tags carry detail that could be more integrated.

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?

An output schema exists, so return-value explanation is not needed. The main incompleteness is that the description names an 'N days' lead time with no corresponding parameter or configuration note, and gives no differentiation from the surrounding webhook tools — leaving the agent to infer setup mechanics.

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 67%: 'fields' and 'precision' are documented in the schema, and the description only adds '[Required: url]' for the undescribed parameter. With the schema doing most of the lifting, the description adds little parameter-level meaning beyond restating requiredness.

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

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

The description states a specific event trigger ('fires N days before a solar/lunar/planetary return is exact'), which combined with the name 'return_due' and the webhooks group tells an agent this sets up a return-anticipation subscription. However, it never explicitly says it 'registers' or 'creates a webhook', relying on the title and endpoint metadata to convey the action; it also doesn't differentiate from the many sibling webhook tools (ingress, retrograde, transit_trigger) beyond the event name.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance, no prerequisites, and no routing to alternative webhook siblings. The metadata supplies the endpoint, required parameter, and cost, but not the conditions under which this webhook is the right choice versus the other subscribe-style 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?

Annotations already declare the safety profile (not read-only, open-world, non-idempotent, non-destructive). The description adds material context beyond them: the endpoint (POST /v1/webhooks/sign-ingress) and a cost of 10 credits (Tier 1), which is a genuinely useful operational trait. It does not explain lifecycle details such as what happens on re-registration, but the cost and endpoint additions are real value.

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 event trigger is front-loaded and the bracketed metadata lines are compact, scannable, and each carries useful facts (group, endpoint, required param, cost). No filler prose, though the lines are somewhat mechanical.

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?

An output schema exists so return values need no explanation, but the definition never clarifies what 'tracked planet' means or how the subscription relates to the surrounding webhook-management tools. For a costed, non-idempotent registration call in a crowded sibling set, this is minimally adequate.

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

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

Schema coverage is 67%: `fields` and `precision` are well documented with examples in the schema, but `url` is undescribed. The description's only parameter contribution is '[Required: url]', which merely restates the schema's required array and adds no meaning such as callback format or expected payload delivery behavior.

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?

Together with the title, the description states a specific event trigger (planet sign ingress) and the implicit action (register a webhook). It distinguishes itself from other webhook siblings by event type rather than by a generic 'webhook' label. It does not explicitly restate the verb 'register' in the description body, but the event scope is 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?

There is no when-to-use guidance and no comparison to alternatives, despite many overlapping siblings (astroway_stream_ingress, astroway_webhooks_subscribe, astroway_webhooks_transit_trigger). The agent is left to infer that this is the webhook version of an ingress event versus a streaming variant.

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?

Annotations declare the write/idempotency/openWorld profile, so the bar is lower, and the description still adds real value: it names the signing_secret return and the X-AstroWay-Signature HMAC-SHA256 verification mechanism, plus the 10-credit cost. It does not cover delivery retry behavior or what happens on a duplicate subscription (relevant given idempotentHint=false).

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 and tight: the core action, the security detail, and the metadata block all earn their place. The only weak point is the truncated event list, which spends a sentence on information that is both incomplete and inconsistent with the schema.

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?

An output schema exists, yet the description helpfully notes the signing_secret, so return values are adequately covered. The gap is the event enumeration mismatch (3 listed vs 12 in the enum) and the absence of any subscription-management context (e.g., how this relates to astroway_webhooks_id or the per-event siblings) for a tool with 43 siblings.

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 50% and the schema already documents `fields` and `precision` in detail, so the description contributes little beyond the required-parameter line. The event list it does provide ('report-ready, transit-alert, eclipse-alert') is a partial and potentially misleading subset of the 12-value enum in 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?

States a specific verb+resource ('Subscribe to outbound webhook deliveries') with the effect (returns a signing_secret) clearly named. However, it does not distinguish itself from the many sibling per-event webhook tools (astroway_webhooks_dasha_change, astroway_webhooks_eclipse_alert, etc.), leaving the agent to infer whether this is the generic subscription entry point or a duplicate.

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 versus the sibling per-event webhook tools or the stream_* alternatives. The only contextual cue is '[Required: event, url]', which restates the schema rather than advising usage. An agent gets no when/when-not framing.

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?

Annotations already declare write (readOnlyHint=false), openWorld, non-idempotent, non-destructive, so the safety profile is covered. The description usefully adds the 10-credit cost and the precise endpoint, but says nothing about duplicate-subscription behavior (relevant given idempotentHint=false), auth, or delivery mechanics.

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?

Lead sentence is front-loaded and the bracketed metadata is compact and scannable. The Group/Endpoint lines are arguably redundant with the tool name, but nothing is bloated and the whole thing is short.

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?

An output schema exists so return values need not be described, and annotations carry the safety profile. However, for a stateful webhook registration the description omits operational essentials such as how notifications are delivered, where to manage/unsubscribe, and duplicate handling, leaving it adequate but not fully complete.

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

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

Schema coverage is 67%; 'fields' and 'precision' are already well described in the schema, while 'url' has format/limit but no prose. The description reinforces that url is required and signals the cost, but adds no meaning (validation rules, target semantics) beyond what structured fields already convey.

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

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

States a specific verb and resource: 'Subscribe to natal-transit aspect threshold-crossings.' This distinguishes it from the many sibling webhook events (sign_ingress, retrograde_start, void_of_course_start, etc.) by the event category. It stops short of naming any sibling explicitly, so sibling disambiguation still depends on the agent parsing the event concept.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied by 'Subscribe to...' – an agent can infer you call this when you want notifications for transit aspect threshold-crossings. No when-not conditions, prerequisites, or alternatives (e.g., the pollable stream_transit_alerts or generic webhooks_subscribe) are named. The cost and required-param brackets are metadata, not routing guidance.

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

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

Annotations already disclose the safety profile (readOnlyHint=false, idempotentHint=false, openWorldHint=true, destructiveHint=false), so the bar is lower. The description usefully adds the cost (10 credits, Tier 1) and endpoint, which annotations do not carry. It does not, however, explain lifecycle consequences of idempotentHint=false — e.g. what happens on duplicate registration or how a webhook is later removed.

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 event statement is front-loaded, followed by compact bracketed metadata (group, endpoint, required, cost) with no filler sentences. Every line carries information, though the format is terse rather than explanatory.

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 an output schema present, return values need not be explained, and annotations cover the safety profile. Still, for a 3-parameter webhook registration tool the description omits practical necessities: duplicate-registration behavior, auth requirements, and how the webhook interacts with the streaming sibling. Adequate but with clear 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 coverage is 67%; `fields` and `precision` are already well-documented in the schema, and `url` carries only a format constraint. The description adds only '[Required: url]', which duplicates the schema's required array. It does not compensate for the undocumented `url` semantics (callback expectations, verification).

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 trigger event precisely ('start of every VOC Moon period'), and combined with the title 'Register VOC-Start Webhook' an agent can distinguish this from sibling webhook tools like astroway_webhooks_retrograde_start or astroway_webhooks_sign_ingress. However, the body text describes the webhook's firing behavior rather than the tool's registering action, so the core verb ('registers a webhook') is only implied.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use guidance and no reference to alternatives such as astroway_stream_void_of_course (streaming) or astroway_webhooks_subscribe. The agent is left to infer that this registers a persistent webhook rather than an ephemeral stream.

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 describes an inherently read-only operation ('List all active webhook subscriptions', GET /v1/webhooks), but the annotations declare readOnlyHint=false and idempotentHint=false. This is a direct contradiction that would mislead an agent about the operation's safety profile. The cost-tier and endpoint metadata are useful, but the read/write mismatch dominates.

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?

One clear sentence front-loads the purpose, followed by compact structured metadata (group, endpoint, cost). Nothing is wasted, though the metadata tags are boilerplate rather than description prose.

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?

An output schema exists, so return values need not be explained, and the purpose is stated. But there is no usage context, no pagination/filtering note (only 'active' is implied), and the annotation contradiction leaves the agent's mental model incomplete.

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

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

Schema description coverage is 100%, with both 'fields' (compact mode) and 'precision' fully documented in the schema, so the baseline is 3. The description adds no parameter detail of its own and never mentions the compact-mode projection controls, so it neither compensates nor detracts.

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

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

States a specific verb and resource ('List all active webhook subscriptions') plus the scope ('for the authenticated user'), so the agent knows exactly what it retrieves. However, it does not distinguish itself from the many sibling webhook tools (subscribe, id, id_test, event-specific triggers), so an agent can't rule out alternatives from the text alone.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use or when-not-to-use guidance and no named alternatives. The agent is left to infer that this is the read side of the webhook family from the verb 'List' alone.

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