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

Annotations already cover safety (readOnly, idempotent, non-destructive), and the description adds substantial context beyond them: server-side checks gate successful results, summary mode truncates to five rows with marked truncation while preserving scalar lists, and verification references always describe the complete calculation. These are exactly the non-obvious behaviors an agent needs.

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 what the tool computes, then requirements, then verification workflow, then verbosity controls — a sensible order. Some slack exists: 'Server checks run before successful results are returned' is vague, and the closing line restates the schema's statement that references identify the full calculation.

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

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

With no output schema, the description still conveys the shape of each returned aspect (orb window, elapsed, remaining) and how summary mode alters it. That is sufficient for correct invocation, though it never mentions counts, ordering, or pagination limits beyond the five-row preview.

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 compensates precisely: moment is ISO 8601 with a timezone offset defaulting to now, location_id is required for a stated reason, and include/detail_level interactions are clarified. It supplies the semantics missing for the two undocumented parameters rather than repeating the well-documented ones.

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 computation ('Planet-to-planet aspects in orb at one moment') plus the distinctive payload: duration in orb, elapsed, and remaining time. That differentiates it from the many render/calculate siblings, though it never names scan_planetary_aspects, the closest potential source of confusion.

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 concrete usage rules: location_id is mandatory and why (Lot of Fortune/Spirit), moment defaults to now, and it prescribes the follow-up workflow with verify_calculation_claims before interpreting. It also explains when to use detail_level=summary/include versus omitting both. Missing only explicit routing away from sibling aspect 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?

Beyond the readOnly/idempotent annotations, the description discloses that results are data-only, that server checks run before successful results, and that verify_calculation_claims must be called before interpretation. The detail_level preview/truncation behavior is also explained. It does not describe error handling or input requirements in depth, but adds meaningful 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?

The description is front-loaded with the returned factor list and then moves to usage and detail-level behavior. It is somewhat dense but every sentence conveys relevant information, and the verification instruction is clearly stated without excessive repetition.

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

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

For a tool with 10 parameters, no output schema, and low schema coverage, the description covers the output contents and verification workflow but leaves invocation semantics incomplete. Missing input details for date/time, location, and house system mean an agent must rely on parameter names alone.

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 20%, so the description must compensate for undocumented parameters. It explains include and detail_level well, but says nothing about the date/time fields, location_id, house_system, or fold, leaving most of the 10 parameters without semantic guidance.

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 enumerates the specific Hellenistic factors returned: sect, dignity, triplicity lords, Lots, lunar phase, and Jones pattern. It establishes the scope as data from the same natal calculation, but does not explicitly differentiate this tool from sibling calculators such as calculate_lots or calculate_natal_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?

The description gives a clear verification workflow before interpreting results and explains how detail_level and include affect output. However, it does not state when to choose this tool over the many sibling calculation tools, nor does it list exclusions or prerequisites for the input parameters.

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, idempotent, non-destructive, and closed-world traits. The description adds valuable context beyond annotations: server checks before results, verification workflow requirements, the fact that psychological interpretations are unchecked, and detailed output truncation behavior for summary mode.

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

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

The description is front-loaded with purpose and follows a logical structure. It is somewhat long but every sentence adds useful information; no redundant fluff. Slight room for tightening, especially the final sentence about verification references.

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 calculation tool with no output schema and moderate annotation coverage, the description provides enough behavioral guidance, workflow steps, and output control details for an agent to use it correctly. Minor gaps exist around exact return format, but overall it is 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?

With only 33% schema description coverage, the description compensates by explaining optional parameters: orb_profile options (greene/tight), house_system (placidus/whole_sign), and the behavior of detail_level=summary and include. It does not detail the BirthInput fields, but core optional param semantics are well covered.

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 (calculates) and resource (Davison relationship chart, time-space midpoint) with scope details (real physical midpoint in time and geographic coordinates, independent chart). Clearly distinguishes from rendering siblings like render_davison_chart by focusing on calculation rather than rendering.

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

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

Implies usage for two people with exact birth data and includes a post-calculation workflow (call verify_calculation_claims). However, it does not explicitly state when to choose this tool over alternatives like calculate_relationship_charts or render_davison_chart, nor does it name any sibling tool.

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

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

Annotations already cover readOnly/idempotent/non-destructive, and the description adds real behavioral context: server-side checks gate successful results, psychological interpretations are not verified, summary mode truncates nested rows at five while preserving scalar lists, and verification references always point at the full calculation. The remaining gap is that it does not say what those 'server checks' validate or what a failed check looks like.

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 right statement of scope, but the detail_level sentence largely restates the schema's own description of the same parameter, and the verification-protocol sentences are dense run-ons that mix three separate instructions. It is not bloated, but a chunk of it does not earn its place against structured fields.

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 12-parameter tool with no output schema, 17% schema coverage, and zero required parameters, the description leaves an agent unable to tell how to supply birth data or whether omitting birth-moment params changes the result. The verification and summary behaviors are well covered, but the core input story is not.

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 17% across 12 parameters, so the description carries most of the burden — but it only explains planet, from_date/to_date, include, and detail_level. The seven birth-moment/location parameters (year, month, day, hour, minute, fold, location_id) are never mentioned, even though they are the inputs that make 'natal houses' computable, and the tool declares zero required parameters with no explanation of defaults.

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: transiting Saturn and Jupiter entering natal Placidus houses from birth to age 84, with retrograde re-entries. That is specific enough for an agent to distinguish it from generic transit tools, though it never names how it differs from close siblings such as calculate_saturn_jupiter_cycles or calculate_transits_to_natal.

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?

It gives a clear workflow rule (call verify_calculation_claims with the unchanged calculation_reference before interpreting, and reverify after correcting contradicted facts), plus filter semantics for planet and dates. However, it never says when to prefer this tool over the many adjacent transit/cycle calculators, so alternative selection 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?

Beyond the readOnly/idempotent annotations, the description discloses that both rulership tracks are returned regardless of house system, that output is data-only with no psychological interpretation, that server checks run before results, and that verify_calculation_claims must be called with the unchanged calculation_reference before interpreting. It also explains truncation behavior for detail_level=summary and that verification references always identify the complete calculation.

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?

Purpose and sibling routing are front-loaded, and every clause is actionable. There is mild redundancy — the psychological-interpretation exclusion and the detail_level mechanics are each effectively stated twice, once in prose and again in 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 no output schema, the description carries the burden of describing returns: houses content, both ruler tracks, chart ruler, cross classifications, the summary truncation contract, and the verification handoff. An agent has everything needed to call it correctly and to follow the required post-calculation verification step.

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

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

Schema coverage is 100%, so the baseline is 3; the description rises above it by clarifying that house_system selects cusps/placements rather than ruler tracks and that both tracks are always returned. It also explains that include selects top-level content fields and that omitted arguments yield the original full result. Much of the detail_level text restates the schema description, limiting the gain.

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 opening sentence names a specific verb (Calculate) and resource (house-ruler dispositor chains for all twelve houses) and enumerates its outputs: traditional and modern tracks, chart ruler, and angular/succedent/cadent crosses. It immediately differentiates itself from siblings by naming calculate_natal_structure_graph and calculate_classical_factors as the tools for adjacent concerns.

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?

It states the use case (house-based rulership paths) and explicitly routes two alternative needs to named sibling tools. It also gives concrete preconditions — exact local birth date/time, confirmed location_id, explicit house_system — and states that omitted prerequisites return needs_clarification rather than being inferred.

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, idempotent, closed-world and non-destructive, but the description adds genuinely new behavioral facts: roughly half a minute of runtime, server checks running before results are returned, and that verification references always identify the complete checked calculation even when summarizing. The one gap is that it doesn't say what happens with missing birth data or how location_id interacts with the date fields.

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 purpose and output shape, then alternatives, then the verification protocol. Dense but each sentence carries content; the verification paragraph is long but tied to a correctness requirement an agent could otherwise violate.

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?

There is no output schema, yet the description enumerates the result structure (chapters, total_events, totals_by_aspect/group/target), which is exactly what an agent needs. It also covers runtime and the mandatory verification loop. The missing piece is any explanation of the birth-date/location inputs, which leaves the call signature underspecified.

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 22%, so the description carries the burden for the seven undocumented birth-data parameters (day, month, year, hour, minute, fold, location_id) — and it says nothing about them. What it does elaborate (include, detail_level) is already fully documented in the schema, so the added value 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 plus the exact output shape: a lifetime transit count from birth to age 84, bucketed into twelve seven-year chapters and split by planet, slow/fast group, and axis/planet target. It names the sibling it is not ('Use calculate_transits_to_natal for the dated events'), so an agent can distinguish the aggregate scan from the dated-events tool without opening either schema.

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 routes between alternatives (calculate_transits_to_natal for dated events) and gives a mandatory downstream step: call verify_calculation_claims with the unchanged calculation_reference before interpreting, then correct and reverify. It also states when to use detail_level=summary vs include vs neither. Nothing 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?

Adds substantial information beyond the read-only/idempotent annotations: server-side checks run before results, verification references always identify the complete calculation, and psychological interpretations are explicitly not checked. It also discloses truncation behavior and preserved fields.

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 is front-loaded and the verification instructions are useful, but the middle of the description restates the schema descriptions for detail_level and include almost verbatim, which is wasted space in an already long paragraph.

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

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

For an 11-parameter tool with no output schema, the description explains the return fields and the verification loop well. However, it omits guidance on the date/time and location_id parameters and never mentions the house_system default, so an agent would have to infer whether these inputs are required.

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

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

With only 18% schema coverage, the description compensates for lots, include, and detail_level but leaves seven parameters (day, month, year, hour, minute, fold, location_id, house_system) entirely unexplained. The agent cannot tell from the description what these date/time inputs mean for a lots calculation or whether to pass them.

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 ("Calculate Hellenistic and Arabic lots") and spells out the return fields; the named lots (fortune, spirit, eros, marriage_male) make the astrological technique obvious.

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 usage guidance: filter with lots=[...], omit detail_level and include for the full result, and use summary only for a preview. It also prescribes the verification workflow after the call. It does not compare against sibling calculation tools such as calculate_classical_factors.

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 establish readOnly, idempotent, non-destructive, closed-world behavior. The description adds meaningful behavioral context beyond annotations: server checks run before successful results, verification references identify the complete checked calculation, psychological interpretations are not checked, and summary mode truncates nested rows while preserving scalar lists.

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 dense but front-loaded with the tool's purpose and result content. It is somewhat long but most sentences carry operational guidance; a small amount of repetition around verification and detail_level keeps it from a 5.

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 14-parameter tool with no output schema and low schema description coverage, the description covers the main output families and verification workflow well. It is still incomplete because multiple input parameters are undocumented and there is no explanation of the return structure beyond a high-level list.

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 14%, so the description must compensate, and it explains key parameters such as target_year, target_month, target_day, residence_location_id, house_system, detail_level, and include. However, it leaves several parameters unexplained, including day, fold, hour, year, month, minute, and location_id, and does not clarify how location_id differs from residence_location_id.

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/resource implicitly through its name and explicitly describes the output: a lunar return chart for target_year and target_month, including return moment, positions, angles, cusps, aspects, and natal overlay. It is clear what the tool produces, but it does not explicitly distinguish calculate_lunar_return from the sibling render_lunar_return_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?

It gives explicit prerequisites: residence_location_id must come from search_birthplace, house_system must be placidus or whole_sign, target_day resolves two returns in a month, and verify_calculation_claims must be called with the unchanged calculation_reference before interpreting results. It also explains when to use detail_level=summary, include, or neither.

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, idempotentHint=true, destructiveHint=false, and openWorldHint=false. Beyond that, the description adds meaningful behavioral context: it warns about ambiguous repeated civil times, forbids guessing an unknown birth time, and establishes a required verification workflow with verify_natal_claims before presenting interpretations.

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 long but front-loaded with the core purpose, then proceeds through ambiguity handling, required verification, and output-shaping options. Most sentences carry specific operational value, though the final verification-reference sentence is somewhat repetitive of the detail_level explanation.

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

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

Given 10 parameters, low schema description coverage, no output schema, and complex workflow requirements, the description supplies substantial context: how to source birth data, how to resolve fold ambiguity, required verification before interpretation, and detail_level/include behavior. It still omits full parameter formatting details, so it is strong but not exhaustive.

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

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

Schema description coverage is only 20%, so the description must compensate for undocumented parameters. It adds useful meaning for fold, house_system options, detail_level, and include, but several parameters such as day, month, year, hour, minute, and location_id still lack format/range/usage details. It partially compensates but not enough for a higher score.

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 (calculate), resource (tropical natal chart data table), and required inputs (exact local birth date/time, location_id), which distinguishes it from render-oriented siblings like render_natal_chart. It does not explicitly name sibling tools it should replace, 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?

The description provides some procedural guidance (do not guess an unknown birth time, ask about fold 0/1) and mandates a next step for natal interpretation. However, it does not explicitly state when to choose calculate_natal_chart versus render_natal_chart or other calculate tools, leaving the primary tool-selection guidance implied.

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 safety is covered. The description still adds real value beyond them: it discloses what the result does NOT contain (no global importance score, forced single core, psychological inference or remedy verdict), that partial availability is possible when house/axis layers are missing, and that server checks run before results return. It does not, however, describe rate limits, auth, or pagination 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?

Front-loaded with purpose and sibling routing, and nearly every sentence carries operational meaning (scope distinctions, broad-selection allowances, verification loop). It is dense and long, with several tightly packed caveat clauses that could be trimmed, but nothing is purely 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?

Despite no output schema, the description enumerates the returned fields (focus_selection, ten planet_profiles, relationship_views, state evidence, reading groups, source_graph, jones_view, view_comparison) and explains jones_view/view_comparison as a non-selecting perspective. For an 18-parameter analytical tool it gives an agent everything needed to call and interpret 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 description coverage is 100%, so the schema carries most parameter meaning and baseline is 3. The description adds top-level semantics the schema alone does not: it explains detail_level=summary row-truncation behavior and that verification references always identify the complete calculation, and points the reader to input fields for scope/rulers/orbs interpretation.

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 (extract) and resource (rule-based natal priorities / candidate focus groups) with source evidence. Explicitly distinguishes itself from calculate_natal_structure_graph ('complete unselected relationship graph') and calculate_natal_chart ('positions and houses'), so an agent can route correctly without opening schemas.

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?

Names the alternatives and the conditions that select them, states the prerequisites (exact local birth date/time, confirmed location_id from resolve_birth_coordinates/search_birthplace), and prescribes a downstream call to verify_calculation_claims before interpreting. Both when-to-use and when-not are covered.

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?

Beyond the readOnly/idempotent annotations, it discloses that there is no ranking, that partial graphs explicitly mark unavailable houses and axes, that server checks gate successful results, and that summary mode truncates with markers while verification references always identify the full calculation. These are substantive behavioral facts an agent could not infer from the schema; only the return shape remains implicit.

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

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

Front-loaded with the core action and scope, then progressively adds workflow and output-shape detail; every sentence carries information. It is dense and runs several ideas together (verification, preview, field selection) without visual structure, which costs a little 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?

For a complex, no-output-schema calculation tool it covers the workflow (verify then interpret), partial-result handling, and result-shaping options. Remaining gaps are the birth-time parameter conventions (fold, timezone) that an agent must guess from parameter names.

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 22% across 9 parameters, and the description compensates well for the two documented ones (summary previews up to five rows and marks truncation; include selects 1-30 top-level fields and omits everything else). The seven date/time and fold/location parameters get no semantics beyond 'exact civil birth time', leaving timezone/calendar conventions unaddressed.

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 ('Calculate a deterministic natal structure graph') plus the inputs that define it (exact civil birth time and location_id), and enumerates the contents (dispositor paths, cycles, receptions, aspects, motifs, both house systems). It explicitly differentiates itself from calculate_natal_salience and verify_calculation_claims, so an agent can route without opening sibling schemas.

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 routes: use calculate_natal_salience for configurable classical-seven attention candidates, and call verify_calculation_claims with the unchanged calculation_reference before interpreting. It also states what is out of scope (psychological interpretations are not checked) and when to use include/detail_level versus omitting both.

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 read-only, idempotent, closed-world safety, but the description adds operational behavior: exact birth data is required, missing birth inputs return needs_clarification, results are calculation data rather than life-event predictions, server checks precede results, and interpretation requires verify_calculation_claims. These are meaningful disclosures beyond the annotations and do not contradict them.

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 front-loads purpose and alternatives, then prerequisites and verification, which is the right ordering for an agent. It is dense and useful, but still long; several workflow sentences, especially around server checks and verification references, add helpful but nonessential detail.

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

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

With no output schema, the description supplies the essential return scope—calculation data, current/next phase, eight phases, and timeline—plus the prerequisites and verification workflow needed to use results correctly. Given the annotation coverage and 100% schema coverage, no critical agent-facing context is missing.

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

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

Schema coverage is 100%, so the schema already documents all 10 parameters and the description mostly echoes those entries. It adds some cross-parameter value by explaining how detail_level=summary and include interact and that omitting both yields the original full result, but it provides little additional syntax or per-parameter meaning beyond the schema.

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

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

The first sentence names a specific verb and resource—secondary progressed Sun-Moon lunation—and enumerates the outputs: current/next phase, eight 45-degree phases, and an age-100 timeline with progressed positions and Saturn house context. It also directly distinguishes the tool from calculate_secondary_progressions and get_current_sky, so an agent can select it without opening either schema.

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?

It gives an explicit when-to-use statement ('Use for progressed lunar phases') and names two alternatives with their scopes. It also states required inputs, the missing-input outcome, and a required verification follow-up, leaving little 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?

Beyond the readOnly/idempotent annotations, the description discloses that server checks gate successful results, that psychological interpretations are excluded from verification, and how detail_level truncates nested rows while preserving scalar lists. These are non-obvious behavioral traits an agent could not derive from annotations alone.

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?

Outputs are front-loaded in one dense sentence, followed by orb, verification workflow, and detail_level instructions. It is verbose in places and partially restates the include/detail_level schema descriptions, but most sentences carry actionable information.

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

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

With no output schema, the description does enumerate the returned chart components, which is helpful. Gaps remain: it does not say that both person_a and person_b must actually be supplied (schema marks them optional via defaults), nor does it describe the result container beyond field names.

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 40%, and notably orb_profile has no schema description at all; the description supplies its 'greene (default) or tight' values, which is valuable. It also clarifies detail_level and include interactions, but it never explains person_a/person_b structure or whether they are required, leaving part of the parameter surface underspecified.

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 exact resource being computed: synastry aspects, cross-house placements, midpoint composite chart, composite-to-natal aspects, and shared house patterns for two people. That is far more specific than a tautology, though it never explicitly distinguishes itself from sibling options such as calculate_davison_chart or render_composite_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?

It states a prerequisite ('two people with exact birth data') and a mandated follow-up (call verify_calculation_claims with the unchanged calculation_reference), which is real usage guidance. However, it gives no when-to-use/when-not-to-use comparison against the many sibling chart tools, so the agent must infer 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 readOnly/idempotent/non-destructive/closed-world, and the description adds substantial value beyond them: no scores or psychological flags, explicit missing-layer disclosure, truncation caveats, and a mandatory verify_calculation_claims flow. But much of the disclosure is in compressed, near-opaque clauses ("engineering conventions," "no pair-product expansion") that an agent cannot reliably translate into expectations, so it stops short of fully trustworthy behavioral clarity.

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 a single undifferentiated block of roughly 700 words; purpose, parameters, timing semantics, and verification boilerplate are interleaved with no headings or paragraphing. Sentences pack multiple unrelated constraints each, and the final verification instruction is stranded at the very end rather than surfaced, so the reader must re-scan repeatedly to extract operational facts.

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 17-parameter, annotation-light, output-schema-less calculation, the description covers modes, orb defaults, timing semantics, context typing, verification workflow, and explicit non-claims (no predictions, no scores) — enough for correct invocation. The remaining holes are a few uncovered parameters and no description of the top-level result shape, which would help at this complexity.

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

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

Schema coverage is only 12% across 17 parameters, and the description does compensate well for the highest-risk ones: the timing object's at/date/month/month_part/event keys, window_start/window_end limits, sextile_orb_degrees, minor_orbs_degrees keys, include_minor_aspects, and relationship_context sub-keys. Several parameters get no coverage anywhere (house_system, parental_house_mapping_profile, ruler_profile only obliquely, person_a/person_b birth requirements only stated for synastry), which is a real gap at this coverage level.

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 resource and operation concretely ("relationship observation," synastry vs natal modes, cross-contacts, observation paths, natal context) and distinguishes itself from prepare_relationship_observation_note, which handles human notes. However, the opening sentences talk about include/detail_level tactics rather than stating the tool's purpose, so the core purpose is buried mid-paragraph rather than front-loaded.

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?

It gives real gating conditions: use include for focused questions, omit include with detail_level=full for complete data, reuse an explicitly stated relationship context and ask the user if unknown, and use prepare_relationship_observation_note separately for human notes. It never contrasts itself with calculate_relationship_charts, so sibling selection among the chart-producing tools remains an 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 cover safety (readOnly, idempotent, non-destructive), so the added value here is real: it discloses that server checks run before results are returned, that verification references always identify the complete checked calculation, and that psychological interpretations are excluded from checking. It does not describe volume or cost of the full result, but the behavioral picture is otherwise clear.

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, which is good, but the description is a dense block that partly restates the schema's own detail_level and include text, and the verification paragraph (three sentences) competes with the actual tool purpose for attention.

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

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

With no output schema, the description does well to explain the two return shapes (full vs summary, plus include selection) and the verification contract. It is not complete for an 11-parameter tool, however, since the birth date/time inputs go entirely unexplained and the relationship to render_relocation_chart is unstated.

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 18% across 11 parameters. The description adds meaning for relocation_location_id, house_system, detail_level and include, but the seven date/time parameters (year, month, day, hour, minute, fold) and location_id are undocumented in both schema and description — an agent cannot tell that these are the alternative birth-moment inputs. The gap is too large for the description to compensate.

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 opening sentence names a specific verb and resource (recalculates ascendant, midheaven and house cusps) and states the defining constraint that the natal moment and planetary longitudes stay fixed. That distinguishes it from natal-chart siblings, but it never explicitly contrasts itself with the very similarly named render_relocation_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?

It states that relocation_location_id is required and where to get it (search_birthplace), gives the house_system options, and prescribes the downstream verify_calculation_claims step with the condition for reverting. No explicit when-not to use, and calculate_relocation_chart vs render_relocation_chart is left to the name alone.

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 establish read-only, idempotent, non-destructive behavior, and the description adds useful context: server checks run before successful results, verification references identify the full calculation, and detail_level/include affect truncation and field selection. It does not explain error modes in depth, but the key behavioral workflow is disclosed.

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 is front-loaded and most sentences carry useful operational information. The description is dense and could be more scannable, and it repeats some include/detail_level semantics already present in the schema, but it is not padded with irrelevant content.

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

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

For a complex tool with no output schema, the description usefully names output content fields, explains detail_level and include, and describes the verification workflow. However, the incomplete coverage of the birth date/time/location parameters leaves an important part of the invocation context underspecified.

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 18%, so the description must compensate. It explains as_of, max_age, detail_level, and include, but leaves day, month, year, hour, minute, fold, and location_id undocumented, which is a significant gap for an 11-parameter natal-calculation 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?

The description states a specific verb and resource: calculating Saturn and Jupiter cycles over natal angles, including conjunctions, aspects, quadrant phases, and current cycle position. It clearly distinguishes this from generic chart rendering and from the verification tool it references.

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?

It gives a clear usage context and an explicit post-calculation workflow: call verify_calculation_claims before interpreting the data, correct contradicted facts, and reverify. It also notes that psychological interpretations are not checked. It does not explicitly contrast this with render_saturn_jupiter_cycles or other calculation siblings, but the context is strong.

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, so the bar is lower. The description adds meaningful beyond-annotation context: server-side checks run before results, verification references always identify the complete calculation, and detail_level truncation semantics. It doesn't describe output shape, but that is a lesser gap given the read-only profile.

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 resource and its contents, then the method choice, then the verification workflow and detail_level rules. It is dense but nearly every clause carries actionable information; only the 'server checks run before successful results are returned' phrasing is somewhat vague 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?

There is no output schema and 13 parameters, so the description carries substantial burden. It covers the verification workflow and preview semantics well, but with half the parameters undocumented and no return-value shape, an agent still faces gaps before calling correctly.

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

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

Schema coverage is low (15%) across 13 parameters, so the description must compensate. It meaningfully explains as_of/age, angle_progression_method options, and detail_level/include behavior, but leaves day/month/year/hour/minute/fold/location_id/house_system undocumented in either description or schema.

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

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

The description states a specific resource and enumerates its outputs (progressed planets, angles, natal aspects, lunation phase), which is concrete. It does not explicitly differentiate from calculate_progressed_lunation or render_secondary_progressions_chart, leaving some sibling disambiguation 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?

It gives explicit input guidance ('Specify as_of or age'), names the default and the alternative for angle_progression_method, and prescribes a workflow (call verify_calculation_claims before interpreting). It lacks a clear 'when not to use' versus the progressed-lunation or rendering siblings, so not a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds meaningful context beyond them: 'Server checks run before successful results are returned', the mandatory post-call verification loop, the caveat that psychological interpretations are not checked, and the precise effect of detail_level on rows and truncation marking. This is rich behavioral disclosure for a read-only 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?

Dense but front-loaded: the resource and returned content come first, then the verification constraint, then parameter behavior. Each sentence carries information, though the verification instructions are somewhat verbose and could be tightened.

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

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

With no output schema, the description compensates by enumerating returned content and explaining detail_level/truncation semantics, plus the verification protocol. The main gap is location_id/place handling, which an agent must call correctly but receives no guidance on.

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?

moment gets format detail absent from the schema ('ISO 8601 with a timezone offset; defaults to now'), and detail_level/include are explained thoroughly. However, location_id is left entirely undocumented in both schema and description, and 'place' is only alluded to, so coverage of the 4 params is incomplete.

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 ('full chart cast for any moment and place') and enumerates the returned content (planets, Placidus houses, axes, aspects, aspect patterns, lunar phase, planetary motion). It explicitly distinguishes from birth-chart tools ('rather than for a birth'), but does not name the close siblings get_current_sky or render_sky_chart, leaving differentiation 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?

Gives concrete guidance on the verification workflow ('before interpreting this data, call verify_calculation_claims with its unchanged calculation_reference...') and on when to use detail_level=summary vs omit both. However, it never states when to prefer this over get_current_sky or render_sky_chart, which are the most likely alternatives an agent would weigh.

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?

Goes well beyond the readOnly/idempotent/non-destructive annotations: default five-year window clipped to ages 0-80, 'returns calculation data, not event predictions', server-side checks running before results are returned, needs_clarification on missing prerequisites, and the mandatory verification loop with unchanged calculation_reference. These are call-shaping behaviors not derivable from structured fields.

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

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

Front-loaded with purpose, then alternatives, then prerequisites, then output semantics and verification — a sensible order with no filler sentences. It is on the long side, and the verification-workflow paragraph is dense boilerplate that slightly dilutes the core description.

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

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

For a 13-parameter, zero-required, no-output-schema tool, it covers purpose, prerequisites, default bounds, truncation/preview semantics, error modes, and the mandatory verification step. An agent has enough to call it correctly and to know what to do with the result.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns extra by explaining cross-parameter interaction the schema can't — 'omit both for the original full result', and that summary/truncation never affects what verification references identify. Most individual parameter meaning is still delegated to 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?

Specific verb + resource + scope: 'Calculate true solar-arc directions over an age interval', naming the exact outputs (directed-point/axis contacts, hard-aspect matrix with dates, directed positions at wheel_age). It also explicitly distinguishes itself from calculate_secondary_progressions, calculate_transits_to_natal, and render_solar_arc_biwheel so an agent can route without opening sibling schemas.

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?

States when to use it ('for solar-arc timing') and names three alternatives with the conditions that select them. Prerequisites are spelled out (exact local birth date/time, confirmed location_id) along with the consequence of omitting them (needs_clarification), and it prescribes the follow-up verify_calculation_claims step.

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?

Goes well past the readOnly/idempotent annotations: server checks gate successful results, a mandatory verification loop with correction and reverification is spelled out, and psychological interpretations are explicitly out of verification scope. It also discloses how summary truncation works and states that verification references always cover the complete calculation, so an agent knows the references are trustworthy even on truncated payloads.

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 purpose and the returned artifacts, then moves to requirements and workflow in a logical order, and every clause about verification is load-bearing. It loses a point for restating the detail_level and include semantics almost verbatim from the schema descriptions, which is redundant text.

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

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

For a 12-parameter tool with no output schema, the description does well to enumerate the return payload and the verification contract. The gap is the date-time input block: with zero required parameters, an agent cannot tell from the description which temporal fields are needed or how they interact with target_year and the return moment.

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

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

With only 17% schema coverage across 12 parameters, the description carries real weight and does clarify residence_location_id vs the birthplace ID, the placidus/whole_sign house_system values, and include/detail_level behavior. However, the six date-time parameters (year, month, day, hour, minute, fold) and their relationship to target_year are never explained in either the schema or the description, leaving the most ambiguous part undocumented.

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 ("Solar return chart for target_year") and enumerates the returned content: exact return moment, positions, angles, cusps, aspects, natal overlay, and monthly progressed Moon contacts. It implicitly separates the calculation from render_solar_return_chart by describing data rather than a rendered image, though it never names that sibling or calculate_lunar_return 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?

Gives clear pre-conditions: residence_location_id is required and comes from search_birthplace, with a rule for when the birthplace ID is acceptable. It also mandates the verify_calculation_claims follow-up before interpretation and explains summary vs full selection, but offers no guidance on when this tool is preferred over calculate_lunar_return or the render counterpart.

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 read-only/idempotent/non-destructive/closed-world, and the description adds real context beyond that: no predictive interpretations, server-side checks run before results, resonances only group points matching across ≥2 techniques within 30 days, summary truncation is marked, and verification references always identify the complete calculation. It does not describe rate limits or failure modes beyond invalid_input.

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 resource and technique list, then workflow, then output-shaping options — a sensible ordering. It is long and repeats the 'references identify the complete calculation' idea twice, but nearly every sentence carries information.

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

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

With 11 parameters, zero required params, no output schema, and low schema coverage, the description should explain the date/time input contract. It instead spends words on verification workflow and detail_level while leaving the core temporal inputs undefined, so the definition is only partially complete for a tool of this complexity.

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

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

Schema coverage is only 18% across 11 params, so the description carries more burden than usual. It does clarify target_year, the 1–3 year birthplace span (span_years), include's field-selection behavior, and detail_level's two modes, but the seven datetime/location parameters (day, month, hour, minute, fold, location_id) get no explanation of format, timezone, or null semantics.

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

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

States a specific resource (multi-technique timeline) and enumerates exactly which techniques are bundled (Firdaria, Zodiacal Releasing L1/L2, progressed Moon, Jupiter–Pluto conjunctions) plus the target_year/birthplace-year scope. An agent can tell this is a composite time-lord/transit timeline rather than a single-technique tool, though it never names which sibling to prefer for a single technique.

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 downstream workflow: call verify_calculation_claims with the unchanged calculation_reference before interpreting, correct contradicted facts, reverify. Also tells when to use detail_level=summary vs. omitting both selectors for the full result. It lacks any when-to-use-this-instead-of-a-sibling-calculation guidance, which keeps it from a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds real context beyond them: precondition failures yield needs_clarification, server checks run before results are returned, output is timing tables and lords rather than event predictions, and detail_level/include truncation behavior is disclosed. However, it does not describe pagination, size limits, or error surface beyond the one clarification path, and the verification paragraph is more workflow instruction than behavior of this 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?

Purpose and scope are front-loaded in the first clause, and each subsequent sentence carries distinct content about routing, prerequisites, output type, and verification. It is dense and runs long, with the verification/detail_level material packed into a single block that could be split or trimmed, but nothing is purely redundant.

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

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

With 12 parameters and no output schema, the description carries the burden of describing returns and does so ('timing tables and lords, not event predictions'), covers the prerequisite/clarification path, the verification loop, and the detail_level/include output shaping. An agent has everything needed to call it correctly and to know what it will and will not get back.

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

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

Schema coverage is 100%, so baseline is 3; the description still adds value by explaining the interaction between detail_level and include ('Omit both for the original full result') and that summary mode preserves scalar membership lists while marking truncation. It also clarifies that the tradition alias is not a claim of historical equivalence and that profection house_system is chosen independently, which the schema does not say.

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 two named resources (Firdaria and annual profections) plus the scope of each output (major periods to age-100, sub-periods in the active major, profection years -1/+3 clipped to the report). It explicitly distinguishes itself from the nearest sibling, calculate_zodiacal_releasing, so an agent can select without opening schemas.

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?

Names the alternative tool and the condition selecting it ('releasing from Fortune/Spirit'), lists prerequisites (exact local birth date/time, confirmed location_id, explicit house_system) and the failure mode (needs_clarification), and prescribes a follow-up step (call verify_calculation_claims with unchanged calculation_reference before interpreting). When-to-use, when-not, and downstream sequencing are all explicit.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), so the description rightly spends its budget elsewhere: server-side checks before results are returned, times in UTC plus birthplace local time, the axes-conjunction-only limitation, and that empty axis events do not imply no other axis aspects. The truncation semantics of detail_level and the guarantee that verification references always cover the full calculation are useful non-obvious behaviors.

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?

Core purpose and the date range are front-loaded, which is correct. The remainder is dense run-on prose mixing domain rules, output-shaping flags and a downstream workflow obligation, with no structure to separate them; some sentences (the detail_level explanation) are duplicated by 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?

For a 13-parameter, annotation-covered, output-schema-less tool this covers the domain caveats and the verification loop well. It is still incomplete on how the natal chart itself is specified – the birth date/time components and location_id are never connected to the request, leaving an agent guessing whether they are required for a meaningful result.

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 15%, so the description must carry the load. It does explain from_date/to_date format, the planet enum values, target_scope options and detail_level/include behavior. But seven parameters (year, month, day, hour, minute, fold, location_id) – evidently the natal birth moment and place – are left entirely unexplained in both schema and description, which is a material 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?

States a specific verb and resource: exact transits of five named planets to the natal chart within a bounded date range. It also defines the target scope (all/axes/points), which separates it from generic aspect-scanning tools. It never names a sibling it competes with, so the differentiation is implied rather than explicit.

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

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

Provides real contextual guidance – the 3-year maximum window, when to use summary vs include vs neither, and a mandatory follow-up call to verify_calculation_claims. However, it never says when to choose this over calculate_aspect_windows, get_transit_snapshot or calculate_lifetime_transit_summary, which is the biggest selection ambiguity in this sibling set.

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

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

Annotations already cover the read-only/idempotent/non-destructive profile, and the description adds meaningful beyond-schema behavior: server checks run before results are returned, the mandatory verification round-trip, truncation marking in summary mode, and that verification references always identify the complete checked calculation. It stops short of describing error modes or pagination limits beyond the 'up to five rows' rule.

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?

Purpose and scope are front-loaded and most sentences carry real information. However, the detail_level/include sentences largely restate schema descriptions, and the closing sentence about verification references repeats an earlier point, adding length without new guidance.

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

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

With no output schema and 10 parameters, the description does a reasonable job of describing the returned structure (nested level-1/2/3 periods, markers, level-2/3 anchored to as_of). But the omission of any explanation for the datetime and location inputs leaves a real gap for correct invocation.

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

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

Schema coverage is only 20%, so the description must compensate, but it explains only as_of (defaults to today), include, and detail_level. The six datetime parameters (year, month, day, hour, minute, fold) and location_id are completely unaddressed — an agent cannot tell whether they are a birth datetime, a required set, or timezone-bearing.

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 technique (zodiacal releasing, Valens 360-day years), its sources (Lot of Fortune and Lot of Spirit), and exactly what is returned at each level with peak/loosing-of-the-bond markers. The level-1/2/3 scope implicitly separates it from the sibling calculate_zodiacal_releasing_l4, but it never names or contrasts that sibling 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?

Gives a clear conditional workflow: call verify_calculation_claims with the unchanged calculation_reference before interpreting, correct contradicted facts and reverify, and notes psychological interpretations are not checked. It also states when to use detail_level=summary versus omitting both for the full result. No guidance on when to prefer this over calculate_zodiacal_releasing_l4 or calculate_time_lords.

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, so the bar is lower, yet the description adds real context: server-side validation runs before results return, summary mode truncation is marked, and verification references always point at the complete calculation. The wording 'server checks run' is left vague (which checks, what failures look like), keeping it below a 5.

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

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

Purpose is front-loaded, followed by prerequisite, workflow validation, and optional-parameter behavior in a logical order. Some space is spent restating the detail_level and include semantics that already appear verbatim in the schema descriptions, which is minor redundancy 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?

With 13 parameters, no output schema, and a multi-step verification workflow, the description supplies the prerequisite chain, verification protocol, and truncation semantics an agent needs. It is only incomplete on the unexplained date/time/location inputs, whose role in producing a level-4 release is never stated.

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 15%, so the description must carry the load. It does well for lot, parent_start, parent_sign, detail_level and include (including a worked date/sign example), but the eight date/time/place parameters (year, month, day, hour, minute, fold, as_of, location_id) get no explanation at all, leaving a substantial 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 opening sentence names the exact resource and scope: level-4 zodiacal releasing periods nested inside a single level-3 period, which readily separates it from the sibling calculate_zodiacal_releasing (level-3). The verb 'calculate' is only implied via the name rather than stated, so it falls just short of a full 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?

It gives an explicit prerequisite ordering ('Call calculate_zodiacal_releasing first'), specifies what to pass in (lot fortune or spirit, parent_start, parent_sign with a concrete example), and prescribes the follow-up verification step. An agent knows exactly when to reach for this tool and what to do before and after.

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, closed-world, and non-destructive behavior. The description adds useful context beyond annotations: the content scope of the protocol and the fact that the same text is available via resource and prompt. It does not describe the return format explicitly, but for a zero-parameter static read that gap is minor.

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

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

Two sentences, front-loaded with the action and content scope, followed by the alternative-access note. Every sentence earns its place with no redundancy.

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

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

For a zero-parameter, read-only protocol tool with full annotations, the description is nearly complete: it says what protocol areas are covered and where else the text lives. It could be slightly richer by stating the return format (plain text) or whether the protocol is versioned, but no critical information is missing for correct invocation.

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

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

The tool has zero parameters, so there is no parameter semantics to document. The baseline for zero params is 4, and nothing in the description creates ambiguity.

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

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

The description uses a specific verb ("Read") and resource ("the current HellenicStar agent protocol") and enumerates the protocol's subject matter, making the tool's purpose clear. It does not explicitly differentiate itself from meta-siblings like get_capabilities or recommend_workflow, which keeps it from 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?

The description mentions that the same text is available as an MCP resource and prompt, which signals alternatives, but it gives no condition for choosing this tool over those alternatives or over sibling meta-tools. Usage is implied rather than guided.

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. The description adds value beyond them by specifying the data source ('live registry') and that provenance/versions are returned, plus the optional/advisory nature of the call.

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

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

Three short sentences, front-loaded with the discovery purpose and followed by usage guidance. No filler, though the closing 'this lookup is optional' slightly restates the preceding clause.

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?

There is no output schema, so the description carries the burden of explaining returns; it does so by naming tools, schemas, provenance and versions. Adequate for a zero-parameter read-only meta tool, though it could hint at response shape more concretely.

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

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

The tool takes zero parameters, so there is nothing for the schema to obscure and no parameter semantics to compensate for. Baseline 4 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 ('Discover') and enumerates the resources it returns: tools, input schemas, registered algorithm provenance and versions from the live registry. This clearly separates it from the domain calculation/render siblings, though it does not distinguish itself from the other meta tools (get_agent_protocol, recommend_workflow).

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 an explicit trigger ('Use when available tools or parameters are unclear') and an explicit exclusion ('If the needed tool and its current schema are already available, call it directly; this lookup is optional'). It does not, however, say when to prefer this over get_agent_protocol or recommend_workflow.

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), and the description still adds real behavioral context: server-side checks run before successful results are returned, detail_level=summary truncates object/nested rows to five while preserving scalar lists and marking omissions, and verification references always point at the full checked calculation. The main gap is that it doesn't describe the shape/density of the full payload beyond field names.

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?

Purpose and scope are front-loaded, but the paragraph then piles on verification workflow, sibling-redirect rules, and a full restatement of detail_level semantics already present in the schema. For a three-parameter read tool this is over-long, and several sentences (e.g. the 'do not ask for a city' admonition) would be better placed in the agent protocol.

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

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

With no output schema, the description does the necessary work: it lists the returned content categories, explains the summary/full truncation tradeoff, and states the default moment. It stops short of describing the structural shape of nested results (e.g. aspect or station records), which leaves a modest gap for an agent planning to consume the 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?

Schema coverage is 67% and the description compensates for the undocumented `moment` parameter by specifying ISO 8601 with an offset and a 'now' default. It also adds behavior for `include` (retrograde_planets returns only retrograde planets plus their next direct station) beyond the schema's field list, though it references `stations_today`, which is not among the schema's enumerated selectable fields — a small inconsistency.

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 computation ('Sky at one moment') and enumerates exactly what the result contains: lunar phase, Moon sign, void-of-course window, lunations/eclipses, retrograde planets, stations and aspects. It also carves out its scope against siblings ('no birthplace or geographic location required', 'not a complete annual retrograde calendar'), letting an agent separate it from the natal/house-chart and render_* tools without opening any schema.

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 routing rules: defaults to now, use include=retrograde_planets for retrograde-only output, stations_today is limited to the Beijing calendar day, and for yearly requests to explain the limit rather than switching to a house chart or asking for a city. It also mandates calling verify_calculation_claims before interpreting results, which is a concrete when-to-use instruction with a named sibling.

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, but the description adds meaningful behavioral context beyond them: server checks run before successful results, missing birth inputs return needs_clarification, detail_level=summary truncates nested rows and marks truncation, and verification references identify the complete calculation. It also explains the required verify_calculation_claims follow-up before interpretation.

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

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

The description is front-loaded with purpose and alternatives, then moves into prerequisites and workflow. It is somewhat long and contains a few redundant phrases, such as repeated references to the complete checked calculation, but most sentences carry useful information for this complex tool.

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

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

Given ten parameters, no required parameters, no output schema, and a multi-step verification workflow, the description covers the essential context: birth inputs, location_id, moment, detail_level/include behavior, needs_clarification handling, and post-calculation verification. Nothing critical for correct invocation appears missing.

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

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

Schema description coverage is 100%, so the schema already documents all ten parameters thoroughly. The description echoes some detail_level and include behavior, but it does not add substantial parameter semantics beyond what is already in the schema, making the baseline 3 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 states a specific verb and resource: getting calculation data for transiting planets and their active aspects to one natal chart at a single moment, including orb and applying status. It also explicitly distinguishes this snapshot from calculate_transits_to_natal, render_transit_biwheel, and calculate_sky_chart, so an agent can select it without opening sibling schemas.

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?

It gives explicit when-to-use guidance against named alternatives and clarifies that this is a snapshot within configured orbs, not an exact-event search or prediction. It also states prerequisites (exact local birth date/time and confirmed birthplace location_id) and the needs_clarification behavior when inputs are missing.

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?

Goes well past the readOnly/idempotent annotations: it discloses that only the source anchor is recomputed, that the statement is not verified and answers are not inferred, and that nothing is persisted or changes calculation facts/counts. The 'Never invent client reports' guardrail is exactly the kind of behavioral constraint an agent cannot get from structured fields.

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 what is produced and where it goes, then prerequisites, then exclusions. The exclusion list is long but each clause carries real constraint; a slightly tightened phrasing would remove some density without loss.

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

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

Covers prerequisites, optional links, and behavioral limits well for a 6-parameter tool, and annotations plus hints cover the safety profile. However, with no output schema and no statement of what the returned note/anchor looks like, an agent cannot predict the response shape or how to pass it on.

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

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

With 0% schema coverage, the description does heavy lifting: it explains reference must be an unchanged calculation reference, person is a/b, statement must be explicitly supplied and human, and point/question_id are optional links. It never mentions author_role or its client_report/practitioner_note distinction, which is the one required parameter left undocumented anywhere.

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 artifact ('Prepare a human observation note') plus its destination ('caller-owned storage'), which no sibling tool does. Naming 'calculate_relationship_observation' as the required upstream step cleanly separates it from 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?

Gives a hard precondition (an unchanged calculate_relationship_observation calculation_reference) and marks point/question_id as optional links, so an agent knows the entry conditions. It never frames exclusions as 'use X instead', so routing to alternatives is inferred 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 mark this read-only, idempotent and non-destructive, but the description adds real behavioral context: unknown goals return the whole directory rather than an error, status=ok means route selection not input readiness, required_information must be checked against confirmed data, and the tool explicitly does not calculate, understand arbitrary language, or manage dialogue. These are non-obvious traits an agent would otherwise get wrong.

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 and the skip condition are front-loaded, which is good, but the middle is a dense run of terse clauses ('status=ok selects a route, not input readiness') that read like internal shorthand. Several sentences (image-only routes, dialogue management) are useful but packed without structure, making it heavier than needed for a one-parameter tool.

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

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

With no output schema, the description does supply return-shape cues (whole directory on unknown goals, status, required_information), which is what an agent needs to interpret results. What is missing is any description of the route record itself (fields, renderer vs calculation distinction beyond a passing mention).

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

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

Schema coverage is 0%, so the description must carry the single 'goal' parameter, and it does provide useful guidance (a goal key like relationship_observation, or an unambiguous technique phrase, after interpreting language and negations). However, it never enumerates valid keys or the phrase format, so the agent still lacks a reliable way to construct a valid value.

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

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

The description calls this an 'optional keyword-based directory of supported calculation workflows', which hints at a goal-to-route lookup but never states plainly that it recommends/selects a workflow, so the name and description do not quite line up. It also does not explicitly differentiate itself from the many calculate_* siblings, leaving the agent to infer that this is a meta/routing tool rather than a calculation 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?

Gives an explicit exclusion rule ('Skip when the requested tool is clear or the question is conceptual') and a procedure for multi-technique requests ('obtain each route separately') and for ambiguity ('ask only if ambiguity remains'). It stops short of naming concrete sibling tools to call instead, which keeps it from a 5.

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

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

Annotations only declare it as a safe, idempotent read; the description adds substantial context beyond that: no prior calculation call is required, stdio yields no public image URL, the client must support image content, and the three outcome paths (needs_clarification without image, error without image, inline PNG on success) are each spelled out.

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

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

Front-loaded with the core action, then alternatives, then requirements, then return/error behavior — a sensible ordering. It is a dense paragraph with some stacking of caveats, but nearly every clause carries actionable information.

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

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

For a two-parameter rendering tool with no output schema, the description covers everything an agent needs: input prerequisites, whether a prior calculation call is needed, the return medium, transport limitations, and both failure modes.

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

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

Schema coverage is already 100%, so the baseline is 3; the description goes further by insisting on complete BirthInput objects with exact local civil times and separately confirmed birthplace IDs, and explicitly warns not to copy person A's location to person B. The only minor gap is that the required/optional status is not restated (all fields default to null 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?

Opens with a specific verb and resource: 'Render the midpoint composite chart of two people as a 720px PNG wheel.' It immediately distinguishes itself from the two nearest siblings (calculate_relationship_charts for structured data, render_davison_chart for the time-space midpoint), so an agent can pick it without opening a schema.

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

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

Explicit positive trigger ('use for geometric midpoint positions') plus two named alternatives with their selection conditions. It also sets a negative boundary ('does not score compatibility or predict relationship outcomes'), which prevents a plausible misuse.

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 genuinely non-redundant behavior: the output is a 720px PNG wheel displayed directly to the user — key information for a render tool. It does not say what happens if person_a or person_b is omitted, which matters since all parameters are optional.

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 tight sentences with zero waste; the artifact and its dimensions are front-loaded, and the input-contract note follows. Nothing could be removed without losing information.

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

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

With no output schema, the description correctly states the return form (720px PNG shown to the user), which is the main thing an agent needs. Remaining gaps — prerequisite ordering relative to calculate_davison_chart and the undocumented house_system — are modest for a straightforward render tool with annotations covering safety.

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

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

Schema description coverage is 0%, so the description carries the burden, yet it only delegates via "same inputs as calculate_davison_chart" and "two people" — a useful pointer but not a substitute for explaining person_a/person_b. The house_system parameter (default placidus) is never mentioned, nor is the consequence of the null-defaulted birth fields, so nearly all parameter meaning remains unstated.

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 (render) plus the exact resource (Davison relationship / time-space midpoint chart of two people) and the concrete artifact produced (720px PNG wheel). It also names the sibling calculate_davison_chart, so an agent can immediately tell the drawing tool from the computational one in the crowded chart family.

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?

"Same inputs as calculate_davison_chart" establishes context and implicitly contrasts this rendering tool with its calculation sibling, making the use case (produce a visual for the user) clear. It stops short of stating when not to use it or whether calculate_davison_chart should be called first, so it is clear context without explicit 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 a safe read-only, idempotent, closed-world operation, and the description adds substantial context beyond them: it calculates and validates its own source with no prior call needed, returns an inline MCP PNG, has no public URL over stdio and requires image-content client support. It also specifies failure behavior precisely (needs_clarification on missing inputs, error without an image on invalid input).

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 render output and contents before routing and caveats, and every clause carries information. It is dense and long for a single paragraph, but no sentence is 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 no output schema, the description still covers the return value (inline PNG), the transport constraint, the no-precalculation shortcut, and both failure modes. Nothing an agent needs to invoke and interpret this tool is missing.

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

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

Schema coverage is 100%, so field-level meaning is already documented; the description's contribution is elevating the requirement level ('requires exact local birth date/time and confirmed birthplace location_id') even though the schema marks all seven params optional. It adds no further syntax detail, which is fine given the schema's completeness.

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 ('Render a 720px PNG Jones distribution ring') and enumerates the visual contents (glyphs, fans, longitude dots, gap, angles, focus points). It explicitly contrasts itself with render_natal_chart and calculate_classical_factors, so an agent can separate it from siblings without opening the schema.

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 an explicit when-to-use ('whole-chart distribution visual') and names two alternatives with the conditions that select them. It also states prerequisites (exact local birth date/time plus confirmed birthplace location_id) and warns that boundary cases are not a diagnosis.

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, idempotent, non-destructive, closed-world. The description adds the output format and size (720px PNG wheel) and the fact that it is surfaced to the user, which matters because there is no output schema. It does not mention whether the chart is cached or how it is returned (URL, base64, attachment), which is a remaining gap.

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

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

Two short sentences, front-loaded with the verb and artifact, second sentence carrying the parameter pointer. 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?

With no output schema and 12 undocumented nullable parameters, the description leans entirely on a sibling reference for input semantics and says nothing about the return value shape. For a rendering tool whose whole product is a binary artifact, that leaves an agent guessing how the PNG comes back.

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?

All 12 parameters have 0% schema description coverage, so the schema itself explains nothing. 'Same inputs as calculate_lunar_return' is meaningful compensation — it tells the agent where the semantics live — but it forces a cross-tool lookup and gives no hint about the day/hour/fold vs target_day/target_year/target_month split.

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 (render), a specific resource (lunar return chart), and the artifact form (720px PNG wheel shown to the user). This cleanly distinguishes it from calculate_lunar_return and from render_solar_return_chart/render_natal_chart in the sibling 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?

'shown to the user' implies this is the display step that follows computation, and the explicit reference to calculate_lunar_return gives the agent a routing rule between compute and render. No explicit exclusion or prerequisite (e.g., must compute first) is stated, so it stops short of a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds real context: output is a 720px PNG surfaced to the user, and it renders an already-existing chart. It does not say what happens if no chart exists yet or how errors surface, so not a 5.

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

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

Two sentences, no filler. The output form and size come first, then the input requirements and the one genuinely non-obvious rule (fold handling).

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 read-only render tool with no output schema, the description supplies the output artifact (PNG, 720px, shown to user), the required inputs, and the house-system choice. That is enough for an agent 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 0% across 8 params, so the description has to compensate. It covers location_id, the date/time inputs collectively, house_system options (placidus or whole_sign), and explains fold via the DST ambiguity warning. The y/m/d/h/min split is left to obvious naming.

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: 'Render the existing natal chart wheel as a 720px PNG'. Makes clear it produces an image shown to the user, which distinguishes it from the calculate_* siblings in the 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?

Gives prerequisites (exact birth date, local time, selected location_id) and a decision rule for ambiguous civil time ('ask ... instead of guessing fold'). It does not explicitly route to a sibling such as calculate_natal_chart, which keeps it short of a 5.

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

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

The annotations already cover read-only, idempotent, non-destructive, and closed-world behavior. The description adds important output context: a 720px PNG wheel shown to the user, and input parity with calculate_relocation_chart. It does not detail error behavior or whether rendering is always successful, but the key behavioral traits are present.

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 two sentences with no wasted words. The primary purpose and output format are front-loaded, followed by the sibling input reference.

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

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

For a tool with rich annotations but no output schema, the description adequately explains the return format as a 720px PNG wheel and ties inputs to calculate_relocation_chart. It is not fully self-contained on parameter semantics, but it gives the agent a clear path to find them via the sibling 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?

There are 9 parameters with 0% schema description coverage, so the description carries a heavy burden. 'Same inputs as calculate_relocation_chart' provides a useful cross-reference to another tool's parameter semantics, but it does not directly explain any parameter's meaning, format, or constraints. This is a minimum-viable compensation rather than full parameter documentation.

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

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

The description states a specific verb and resource: 'Render the relocation chart as a 720px PNG wheel shown to the user.' The second sentence distinguishes it from the sibling calculation tool by noting it shares inputs with calculate_relocation_chart, making clear this is the visual-output counterpart.

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?

'Shown to the user' gives clear context that this is for visual presentation, and 'Same inputs as calculate_relocation_chart' names the related sibling. However, it does not explicitly say when not to use this tool or state that calculate_relocation_chart is the alternative for non-visual results.

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?

Goes well beyond the annotations: describes return of an inline MCP PNG plus cycle summary, the stdio limitation (no public image URL, client image support needed), error behaviors (input error without image, render_failed), the birth-to-max_age window, and warns wave height is geometry not prediction. Annotations already cover safety; this adds rich operational 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?

Front-loads the purpose and routing guidance before behavioral details; most sentences carry unique information. It is dense and long, but each clause (errors, stdio limitation, window semantics) earns its place for a rendering tool with no output 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?

Given no output schema and 10 parameters, the description supplies return format, error modes, client constraints, and window semantics, so an agent has everything needed to invoke and interpret it correctly.

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

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

Schema coverage is 100%, so the schema documents all 10 params; the baseline would be 3. The description adds value by clarifying as_of sets the age indicator rather than the chart start/end, that person_name is display-only, and max_age window behavior, though most param detail duplicates 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?

States a specific verb and resource: renders a 1200x660 PNG panorama of lifetime Saturn/Jupiter angle crossings with labels and a reference-age indicator. It explicitly contrasts with calculate_saturn_jupiter_cycles (exact tables) and calculate_house_ingresses, so an agent can distinguish it from 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?

Explicitly says to use this for a visual overview and names the two alternatives for exact data and house ingresses. It also states the required inputs (exact local birth date/time, confirmed location_id), leaving nothing 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 the operation as read-only, idempotent, non-destructive, and closed-world. The description adds meaningful output behavior beyond that: the image is a 760px bi-wheel PNG with natal on the inside and progressed on the outside, which tells the agent what visually gets produced.

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 compact sentences, front-loaded with the core action and output format. No wasted language, and the visual layout detail is immediately useful.

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 render tool with no output schema, the description does explain the output medium and visual structure well. However, it leaves significant gaps around how the PNG is delivered, and with 11 undocumented parameters it relies almost entirely on the sibling tool for correct invocation.

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

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

Schema description coverage is 0% for 11 parameters, so the description carries the full semantic burden. It only says 'Same inputs as calculate_secondary_progressions,' which is a cross-reference rather than an explanation, and it clarifies none of the individual fields such as age, as_of, fold, location_id, house_system, or angle_progression_method.

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 (render), resource (secondary progressions), output format (760px bi-wheel PNG), and visual layout (natal inside, progressed outside). It also distinguishes itself from calculate_secondary_progressions by emphasizing that the result is shown to the user.

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 'Same inputs as calculate_secondary_progressions' implies this is the display counterpart to the calculation tool, and 'shown to the user' hints at usage context. However, it never explicitly says when to call this versus calculate_secondary_progressions or what alternatives exist.

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?

Goes well beyond the readOnly/idempotent annotations: it discloses that the return is an inline MCP PNG, that stdio has no public image URL, that the client must support image content, and how failure modes behave (needs_clarification without an image for missing inputs; error without an image for invalid inputs or unavailable rendering). This is unusually rich behavioral context for a rendering 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 capability is front-loaded in the first sentence, and the remaining sentences each carry distinct information (alternatives, prerequisites, return channel, failure modes). It is a dense single paragraph rather than a structured list, which slightly hurts scanability, but no sentence is 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?

There is no output schema, and the description compensates fully by describing the returned inline PNG and the stdio limitation. Combined with alternatives, prerequisites, and error semantics, an agent has everything needed to call this correctly on the first attempt.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds meaning on top by stating that location_id must be 'confirmed' even though the schema marks it optional (required parameters: 0), and by noting the moment default. The ISO/millisecond truncation detail lives in the schema, so no further credit is warranted.

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 plus concrete output attributes: 'Render a 720px PNG tropical Placidus wheel for one moment and selected place, with chart positions calculated to minute precision.' That level of specificity (format, size, zodiac, house system, precision) lets an agent distinguish it from calculate_sky_chart and render_transit_biwheel immediately.

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

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

Explicitly routes the agent: calculate_sky_chart for structured data, get_current_sky for sky positions without local houses, render_transit_biwheel to compare against a natal chart. It also states prerequisites ('Requires confirmed location_id; moment defaults to now') and that no prior calculation call is needed, which is exactly the guidance an agent needs before invoking.

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?

Adds substantial behavior beyond annotations: it returns an inline MCP PNG after calculating and validating its source, requires no prior calculation call, has no public image URL under stdio, requires image-capable clients, and returns clarification or error outcomes without an image. No behavior contradicts the read-only, idempotent annotations.

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

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

The purpose and sibling alternatives are front-loaded, followed by prerequisites, precedence rules, return behavior, client requirements, and error modes. Every sentence adds operational value for a complex rendering tool, 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?

Given nine parameters, complete schema coverage, no output schema, and read-only annotations, the description supplies the missing behavioral context: output format, calculation behavior, client requirements, and failure modes. An agent has enough information to call it correctly or route to an alternative.

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

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

Schema coverage is 100%, so the schema already documents all nine parameters in detail. The description reinforces exact birth data and age precedence, but those points are already covered by the schema's parameter descriptions, so it does not add significant new parameter-level semantics.

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

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

States a specific verb and resource: renders a PNG biwheel with natal positions inside and true solar-arc directed positions outside. It also distinguishes itself from siblings by naming calculate_solar_arc and render_transit_biwheel as alternatives for different use cases.

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

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

Explicitly says to use it for a visual at one age, then names alternatives for event tables and actual transits. It also covers prerequisites, age precedence, return behavior, client image support, and error outcomes, leaving little 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, and the description still adds substantial behavior beyond them: an inline MCP PNG is returned, no public image URL over stdio, the client must support image content, and missing inputs yield needs_clarification without an image while invalid/unavailable rendering yields an error without an image. Those failure-mode semantics are exactly what an agent needs before calling.

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?

Purpose and the sibling routing are front-loaded in the first sentence, and each subsequent sentence carries distinct information (prerequisites, return format, failure modes). It is dense and slightly run-on, but there is no filler sentence.

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

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

For a 10-parameter rendering tool with no output schema, the description covers prerequisites, the critical residence-vs-birthplace rule, the return artifact type, and clarification/error behavior. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, so baseline is 3; the description still adds a genuine decision rule not merely restated — the residence must be user-chosen and the birthplace must never be silently reused, plus the emphasis that target_year differs from birth year. It is redundant with the schema on house_system and the individual date fields, keeping it below 5.

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, output format and scope: "Render a 720px PNG solar-return wheel for target_year." It also names the two nearest siblings (calculate_solar_return, render_lunar_return_chart) so the agent can separate this from both the data-calculation tool and the lunar equivalent without opening a schema.

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 routes between alternatives: use calculate_solar_return for the moment/data/natal overlay, this tool for the image, render_lunar_return_chart for lunar. It also states prerequisites (exact birth date/time, birthplace, target_year, residence_location_id, house_system) and the rule that prior calculation is not required.

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 only cover read-only/idempotent/no-destruction; the description adds the parts an agent cannot infer: an inline PNG is returned without a prior calculation call, stdio yields no public image URL so the client must render image content, and missing versus invalid inputs produce different non-image outcomes.

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 artifact, then routing, then prerequisites, then return behavior. Dense but nearly every clause carries distinct information; a slightly lighter touch on the repeated 'do not guess' emphasis would tighten it without losing 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?

For a rendering tool with no output schema, it covers what comes back (inline PNG), what prevents a result (missing/invalid inputs, unsupported client), and what is needed to start (exact birth date/time, confirmed birthplace, transit moment). Nothing an agent needs is absent.

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

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

Schema coverage is 100%, so field-level docs are already strong, but the description adds a genuinely non-obvious disambiguation: 'moment' is the transit instant, not a second birth date. It also flags that the birth time must be exact and the location must be a confirmed location_id rather than a city name.

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 artifact: a PNG biwheel with natal positions inside, transiting planets outside, and cross-chart aspects at one moment. It immediately separates itself from the structured-data siblings and from render_sky_chart's standalone wheel.

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?

Names three alternatives (get_transit_snapshot, calculate_transits_to_natal, render_sky_chart) and the exact condition each one serves, plus the prerequisite chain (search_birthplace / resolve_birth_coordinates) and the clarification path when inputs are missing.

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?

Adds substantial context beyond the readOnly/idempotent annotations: the server first runs checks, results must be verified with verify_calculation_claims and reverified after correcting contradicted facts, and psychological interpretations are out of scope. The description also discloses that timezone handling is deferred rather than resolved 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 is front-loaded in the first sentence, and the later sentences carry real value (workflow ordering, truncation semantics). Some of the detail_level/include prose duplicates the schema descriptions instead of adding to them.

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?

There is no output schema, but the description names the key returned fields (location_id, timezone) and the schema's include list enumerates the selectable fields, so an agent knows what the response contains and how to continue. Nothing needed to call it correctly is missing.

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

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

Schema coverage is 50%, and the free-text description compensates by explaining that detail_level=summary previews object/nested rows (up to five), keeps complete scalar lists, marks truncation, and that include selects top-level content fields. That adds some meaning beyond the schema, though it largely restates the property descriptions and says little about latitude/longitude ranges or validation.

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: converts WGS84 decimal latitude/longitude into a reusable location_id and IANA timezone. This clearly separates it from the city-based sibling search_birthplace.

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

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

Explicitly says to use it 'when the user gives coordinates instead of a city' (implying the city-based alternative), and says to pass the resulting location_id to natal, timing, relationship, or chart tools. It also notes that DST offset is resolved later from the birth date and local time, not here.

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 safety (readOnly, idempotent, non-destructive, closed-world), yet the description adds real substance: Swiss Ephemeris tropical geocentric apparent basis, mean nodes as default, bracketed-root solving with relative-speed station splits, server-side checks before results return, and query-local (non-universal) cycle IDs. This is well beyond annotation coverage; only the response shape/pagination remains implicit.

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 scope and semantics, which is good, but the prose is dense run-on text mixing mechanics, cycle-ID caveats, verification workflow, and result-shaping options. Roughly a third of the words are the verify_calculation_claims protocol, which crowds out parameter detail the schema doesn't supply.

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

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

For an 11-parameter, multi-mode tool with no output schema and 18% schema coverage, the description covers mechanics, precision options, and result shaping, but not output field names (only 'windows', 'year_summary' appear in the include schema), body-name vocabulary, or date string formats. An agent could call it but would be guessing on inputs and re-reading results.

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

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

Schema coverage is only 18%, so the description must carry the load, and it explains mode, orb_deg ('separate from exact'), output_precision values, timezone_name as an optional IANA zone, detail_level=summary vs include, and the [0,180] aspect angle bound. But the four required parameters are essentially untouched: planet_a/planet_b naming is only 'arbitrary supported body pair' with no enumerations, and start_date/end_date format is never stated. That leaves the most critical inputs underspecified.

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