Asterwise

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

Annotations cover only the safety profile (read-only, idempotent, non-destructive, closed-world); the description adds the actual behavioral contract: only digits count, the calling code is never summed, '+'/'00' prefixes drop a country code only for valid numbers, and invalid prefixed numbers are summed as written. It also discloses the output shape and that there is no follow-up 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?

Front-loads the purpose, then organizes the rest under labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH), so the density is navigable. The input contract is lengthy with several worked examples, which is justified by genuinely ambiguous edge cases but is heavier than strictly necessary.

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

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

An output schema exists, so return values need not be re-explained; the description instead covers everything else an agent needs — input normalization rules, country handling, workflow ordering, sibling disambiguation, and a link to the full output and error contract. Nothing required for a correct call 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 baseline is 3, but the description goes further by showing the country parameter's concrete effect on the computation (14155552671 = 42 without country vs 41 with country=US) and explaining how local dialling prefixes (AU 0011, US 011) are handled. The unused date/name parameters are explained consistently with 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?

Names a precise operation (sum the digits of the national number, reduce to a single number) and the exact artifact returned (harmonic scoring plus interpretive copy). The DO NOT CONFUSE WITH section distinguishes it from the nearest siblings, asterwise_check_vehicle_number and asterwise_get_business_name_analysis, so an agent can select 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?

Gives an explicit workflow precondition (RECOMMENDED asterwise_get_numerology_profile before judging the line) and names two alternatives with the reason each is different. It also states the conditions under which the country parameter must be supplied versus when the number is read as written.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds value beyond that by disclosing that the API pins to the current day (no query date), that a BirthData global contract applies, and what the output contains (intensity, upcoming cycles, historical rows). It doesn't cover latency or error behavior beyond the external doc link.

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

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

Front-loaded one-sentence summary, then clearly labeled WORKFLOW / INPUT CONTRACT / DO NOT CONFUSE WITH sections. Every line carries routing or contract information; nothing 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 an output schema present, return values needn't be explained, yet the description still summarizes them. Workflow prerequisites, exclusions, input contract, and a link to the full output/error contract together leave no gap an agent needs to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents birth fields and response_format. The description's 'INPUT CONTRACT' adds only the meta-point that no explicit query date exists and that a BirthData contract governs the birth object, which is contextual rather than per-parameter syntax. Baseline 3 is appropriate.

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

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

States a specific verb (evaluates) and resource (Saturn's 7.5-year Sade Sati cycle) with scope (against natal Moon sign, for the current day) and return contents. It also names the exact siblings it differs from, so the agent can distinguish it from get_gochar and get_transits 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?

Provides an explicit BEFORE/AFTER workflow naming asterwise_get_natal_chart and asterwise_get_gochar, plus a DO NOT CONFUSE WITH section that spells out how it differs from two overlapping siblings. This is as close to unambiguous when-to-use guidance as it gets.

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 carry the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds real behavioral detail beyond them: the digit-stripping/reduction algorithm and the input contract that letters and separators are ignored. It does not address failure modes, but points to the docs for the error contract.

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 behavior and then cleanly sectioned into WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH, which is easy to scan. The closing documentation URL is useful but slightly padding, keeping it short of 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?

An output schema exists, so return values need not be explained, and the description only needs to state the shape (same harmony schema as mobile analysis). Combined with the named prerequisite, the disambiguation rules, and the error-contract link, 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 description coverage is 100%, so the schema already documents vehicle_number, date, name, and response_format. The description's INPUT CONTRACT reiterates that name/date are optional and unused, which matches the schema text rather than adding new meaning, so baseline 3 applies.

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

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

The description states a precise verb chain (strips non-digits, reduces numeric run, returns harmony schema) against a specific resource (vehicle registration token). It explicitly distinguishes itself from asterwise_check_mobile_number and asterwise_get_business_name_analysis, so an agent can route 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?

The WORKFLOW block names a recommended prerequisite (asterwise_get_numerology_profile) and explicitly states AFTER: None, and the DO NOT CONFUSE WITH section names two concrete alternatives with the distinguishing rule for each. Both when-to-use and when-not are covered explicitly.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description is consistent with them. It adds significant context beyond annotations: cryptographic randomness via Python secrets.SystemRandom, per-call independence with no session state, local rejection of out-of-range counts with MCP INVALID_PARAMS, and a 50% per-card reversal chance that is explicitly 'not seeded.'

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

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

The description is front-loaded with the core behavior in the first sentence, then organized into labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) that make it scannable. There is no filler; examples, validation notes, and the docs link all earn their place, and the length is proportionate to the three near-sibling tools it must disambiguate.

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?

Between the annotations (safe read operation), the output schema, and the docs link for the full output/error contract, nothing an agent needs to invoke this tool correctly is missing. The reminder to interpret drawn cards via active_meaning and active_keywords fields also closes the loop on how results should be consumed.

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 100% schema description coverage, the schema already documents all three parameters; the description adds strong value with concrete examples (1 daily pull, 3 simple reading, 10 Celtic Cross, 78 full deck), the 1–78 boundary with local validation behavior, and probability mechanics for allow_reversed (50% per card, independent, not seeded). Minor gap: response_format is absent from the INPUT CONTRACT section, though its schema description is thorough.

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 opens with a specific verb and resource — 'Draws N unique random cards from the 78-card deck' — and adds scope-defining traits (unique, cryptographic randomness, no session state). The 'DO NOT CONFUSE WITH' block names the three closest tarot siblings and their distinguishing behavior, so an agent can select this tool without opening their 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 states the tool is standalone with no prerequisites or follow-up ('BEFORE: None', 'AFTER: None'). The 'DO NOT CONFUSE WITH' section names asterwise_get_tarot_card_of_the_day, asterwise_get_tarot_three_card_spread, and asterwise_get_tarot_celtic_cross with the precise differences (deterministic vs positional vs random), leaving no ambiguity about when this tool is the right choice.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral context beyond that: the output is a lat/lon/timezone tuple that other tools require, establishing it as a prerequisite step. It stops short of describing match ambiguity or failure modes, deferring those to an external docs URL.

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?

Labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) make it scannable and front-loaded, and it avoids prose padding. The INPUT CONTRACT does duplicate schema details already stated in the parameters, a minor redundancy.

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

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

With an output schema present, annotations covering safety, and all params documented, the description only needed to add positioning and workflow. It does exactly that, so an agent has everything required to call it correctly and chain its 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 description coverage is 100%, so the schema already documents all four parameters including defaults, range and enum. The INPUT CONTRACT section restates query length, limit bounds and the country code without adding syntax or format guidance beyond the schema, so baseline 3 applies.

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

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

Opens with a specific verb and resource: turns a place name into latitude, longitude and IANA timezone. It also states the output's role for downstream tools, which no sibling can claim, and explicitly notes it is the only place-lookup tool in the set.

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 WORKFLOW block gives explicit BEFORE (none) and AFTER (named consumers such as asterwise_get_natal_chart, asterwise_get_panchanga, asterwise_get_muhurta) plus a DO NOT CONFUSE WITH line. An agent knows exactly when to call this and what to do with the result.

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, non-destructive, and closed-world, so the safety profile is covered. The description adds genuine behavioral context beyond that: the enumeration of valid sequence inputs and the standalone (no side-effect, no chaining) nature. It does not describe the failure mode for unsupported input, deferring that to an external URL, which keeps it short of a 5.

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

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

Front-loaded one-sentence purpose followed by clearly labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH). Every line carries information, and the only external pointer is a single trailing URL rather than inlined boilerplate.

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, output-schema-backed lookup tool, nothing an agent needs is missing: valid inputs, sibling disambiguation, workflow context, and format selection. Return values are left to the output schema, correctly avoiding duplication.

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% (both parameters documented, response_format has an enum), so the baseline is 3. The description goes beyond the schema by adding a validation contract - the explicit supported-value range - that the schema's brief property description omits, which materially helps an agent avoid invalid calls.

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 (lookup) and resource (angel number meaning) plus the exact supported sequence set, which lets an agent know the valid domain immediately. It then explicitly blocks confusion with three named sibling tools, each with a one-line distinction, so the tool is unambiguous against alternatives.

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

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

Provides explicit BEFORE/AFTER workflow (standalone, no prerequisites or follow-ups) and a dedicated 'DO NOT CONFUSE WITH' section that routes the agent to get_angel_number_today, get_angel_number_personal, or get_number_meaning with the condition that selects each. This is textbook when/when-not/alternatives guidance.

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

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

Annotations already declare readOnly/idempotent/non-destructive. The description adds concrete behavioral detail: the LP-to-sequence mapping rules, master number handling, and scope ('extracts only the Life Path → angel sequence mapping'), plus a docs link for the full output/error contract. This goes beyond the annotations without contradicting 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?

Front-loaded with a clear first sentence, then organized into labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE, docs link). Each section earns its place; no filler.

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

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

With an output schema present, the description doesn't need to explain return values. It covers purpose, mapping, workflow, param semantics, exclusions, and points to a full contract. Nothing essential 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?

Schema covers 100% of parameters with descriptions, so baseline is 3. The description adds an explicit example ('1994-03-31'), marks name as optional, and clarifies that date means 'birth date' (not today's date), which disambiguates from the sibling tool. That extra practical context justifies a 4.

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

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

States a specific operation — 'Computes a personal angel number from a birth date using the Pythagorean Life Path as the base' — and gives the exact mapping logic. The 'DO NOT CONFUSE WITH' section explicitly separates it from asterwise_get_angel_number_today and asterwise_get_numerology_profile.

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

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

Provides explicit when-to-use guidance: recommends calling asterwise_get_numerology_profile first to confirm Life Path, and lists two confusable siblings with conditions (daily vs birth date; full profile vs only Life Path mapping). This leaves no ambiguity about alternative selection.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description still adds real behavioral context: the deterministic digit-sum-to-triple algorithm, the date-overrides-timezone precedence rule, and the UTC default. It does not cover rate limits or error behavior, but it defers those to the linked docs, which is acceptable.

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

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

Front-loaded with the core purpose, then cleanly sectioned into WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH. The section labels are somewhat verbose and the algorithm sentence is dense, but every section carries information an agent needs to route and call the 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 an output schema present, the description need not explain return values, and it covers everything else: purpose, algorithm, input precedence, default behavior, sibling routing, and a link to the full output/error contract. Nothing an agent needs 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 description coverage is 100%, so the schema already documents date, timezone, and response_format including the 'overrides timezone' precedence. The description's INPUT CONTRACT largely restates this (date overrides timezone; UTC default), adding only the format example (Asia/Kolkata). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Returns the angel number for today ... or for a given date') and even spells out the reduction algorithm so the agent knows exactly what the output represents. The 'DO NOT CONFUSE WITH' block distinguishes it from asterwise_get_angel_number and asterwise_get_angel_number_personal, so the 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?

Explicit routing is provided: WORKFLOW AFTER points to asterwise_get_angel_number_personal, and the DO NOT CONFUSE WITH section names the two nearest alternatives with the exact condition that separates them (today's date vs. specific sequence vs. birth-date personalisation). When-to-use is fully 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?

Annotations already cover readOnly/idempotent/non-destructive behavior, so the description's job is lighter. It adds value by stating the exact computed outputs, clarifying that raw matrices are exposed here rather than applied to transits, and linking to the full output/error contract. Minor operational details like rate limits or auth are absent but not critical for a read-only compute tool.

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

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

The description is well-structured with labeled sections—WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH—and the core function is front-loaded in the first sentence. It is longer than minimal, but the length is justified by the complexity of the tool and the need to disambiguate among a large sibling list.

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 Vedic tool with a nested birth object and an output schema, the description provides the essential workflow, input restriction, sibling disambiguation, and a link to the full contract. Return-value details are not duplicated because an output schema exists, so nothing necessary for correct selection and invocation is missing.

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

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

The input schema provides 100% parameter coverage with detailed descriptions for date, lat, lon, time, ayanamsa, timezone, person_name, and response_format, so the baseline is 3. The description adds only the high-level contract 'BirthData only,' which is useful but does not deepen per-parameter semantics 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?

Description opens with a precise verb phrase—'Computes full Ashtakavarga bindu matrices, trikona and ekadhipatya reductions, and sarva totals'—clearly identifying both the resource and the computation. The 'DO NOT CONFUSE WITH' sections explicitly distinguish it from asterwise_get_chart_strength and asterwise_get_gochar, so an agent can disambiguate 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?

The WORKFLOW section names a recommended predecessor (asterwise_get_natal_chart), a natural successor (asterwise_get_gochar), and why the successor uses this tool's output. It also identifies the tools most likely to be confused with this one and explains the selection difference, making when-to-use unambiguous.

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/openWorld=false, so safety is covered. The description adds real behavioral context beyond that: the 108-year cycle continues into the next cycle until age ~120, yields 9-11 mahadashas, and stores periods under data.periods.root with DD/MM/YYYY dates. It does not cover rate limits or error behavior, but it is well above the annotation baseline.

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

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

Front-loads the core computation, then organizes workflow, input contract, and sibling disambiguation into labeled blocks. Every line is purposeful and skimmable; the trailing docs URL is an appropriate escape hatch rather than padding.

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

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

For a read-only computation tool with a full output schema, the description covers purpose, sequencing, alternatives, and even output-path structure. An agent has everything needed to select and invoke it correctly, with a docs link for the exhaustive contract.

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 baseline is 3. The description restates the levels enum (1-5, default 2) already in the schema and adds only a minor note that levels are 'enforced locally before the API call' and matches get_dasha; it adds little meaning beyond the structured fields.

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 ('Computes') and resource ('Ashtottari Dasha tree, 108-year cycle') with scope details (levels 1-5, timeline to age 120). It explicitly distinguishes itself from sibling dasha tools (Vimshottari, Yogini), so an agent can pick it 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?

Provides an explicit BEFORE/AFTER workflow (natal chart first, optional Vimshottari comparison after) and a dedicated 'DO NOT CONFUSE WITH' section naming the two most likely sibling confusions. This is textbook when-to-use vs alternatives guidance.

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

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

Annotations already provide strong safety cues: readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds useful behavioral context beyond those: it is a standalone reference with no BEFORE/AFTER workflow dependencies, and it defaults the date to today. It also links to the full output and error contract, which covers any remaining behavioral details.

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

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

The description is well structured and front-loaded: the core behavior appears in the first sentence, followed by compact WORKFLOW, INPUT CONTRACT, and confusion-avoidance sections. Every section earns its place and the whole thing is easy for an agent to scan.

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

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

For a simple two-parameter read-only tool with full schema coverage, an output schema, and rich annotations, the description is complete. It covers date format, default behavior, supported systems, sibling alternatives, and points to the full output/error contract.

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 input schema already documents both date and response_format fully. The description reiterates the date default but does not add meaningfully beyond the schema. Baseline 3 is appropriate because the schema carries the parameter semantics burden.

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 with a resource: 'Returns ayanamsha values for all four supported systems (Lahiri, Raman, KP, Tropical) for a given date.' It is clearly distinct from sibling tools, and it even names the two most likely confusable alternatives and what they do differently.

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

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

The description explicitly provides a 'DO NOT CONFUSE WITH' section, naming asterwise_get_natal_chart and asterwise_get_westen_natal and explaining when each should be used instead. This gives concrete routing guidance beyond simply defining the 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 carry the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false), so the description is not obligated to restate it. It does add genuine behavioral context beyond the annotations: the deterministic reduction algorithm, the meaning of the returned number, and a pointer to the full output/error contract. It stops short of disclosing failure modes inline (e.g., what happens with a single-part or empty name), so a 4 rather than 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?

Labelled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE) front-load the essential constraint and the examples are concrete. There is minor redundancy between the prose sentence 'A three-part name yields three initials summed and reduced' and the three-part example that follows it, and the 'BEFORE: None / AFTER: None' block is slightly padded, but nothing is wasted enough to drop below 4.

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

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

An output schema exists, so return values need not be described here. For a two-parameter, read-only calculation tool, the description supplies the computation method, the input contract with examples, sibling disambiguation, and an external contract link — everything an agent needs to select and invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The INPUT CONTRACT exceeds the schema by adding a worked semantic example for the name parameter ('Arjun Mehta' → A(1) + M(4) = 5, and a three-part case), which disambiguates which letters are actually used. It adds little for response_format beyond what the schema enum already documents, keeping it from a 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 and resource ('Calculates the Balance number from the first letter of each name part') and then adds the method (Pythagorean values, initials summed and reduced) so the agent knows exactly what computation is performed. The explicit DO NOT CONFUSE section names the two nearest siblings and the rule that separates them (all letters vs. initials; absent digits), which no other sibling could claim.

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 WORKFLOW block declares 'BEFORE: None — standalone' and 'AFTER: None', removing any sequencing ambiguity. It then explicitly excludes asterwise_get_expression_number and asterwise_get_karmic_lessons with the distinguishing condition for each, so the agent has both when-to-use and when-not-to-use guidance.

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

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

The description adds some behavioral context beyond the annotations by stating it is 'standalone' and has a specific workflow after it, which is not covered by the readOnly or idempotent hints. However, it does not explicitly mention side effects or permissions, though the annotations already cover these (readOnlyHint true, destructiveHint false). Overall, it adds moderate context without contradicting the annotations.

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

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

The description is structured into clear sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) and is not overly long. However, the INPUT CONTRACT section repeats information already present in the schema, introducing slight redundancy. The front-loaded first sentence is effective, and the overall structure is easy to follow.

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

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

Given the moderate complexity (4 parameters, 1 enum, output schema exists), the description covers the core purpose, usage, and differentiators. It points to a URL for the full output and error contract, which addresses potential omissions. It does not describe the output structure in detail, but the link compensates. Overall, it is sufficiently complete for an agent to decide and invoke the tool correctly.

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

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

The schema already covers 100% of the parameter descriptions, giving a baseline of 3. The description adds the range constraint for 'days' (1-90) and clarifies the default behavior for 'target_date' ('Defaults to today'), which is not fully specified in the schema. This additional context improves understanding beyond the schema alone.

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

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

The description clearly states that the tool computes physical, emotional, and intellectual biorhythm cycles for a birth date. It also explicitly distinguishes itself from related tools via the 'DO NOT CONFUSE WITH' section, naming asterwise_get_nakshatra_prediction and asterwise_get_panchanga. This provides both a specific verb and resource, and clear differentiation.

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

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

The description provides explicit workflow guidance: 'BEFORE: None' and 'AFTER: asterwise_get_nakshatra_prediction', indicating where this tool fits in a sequence. It also tells the agent when not to use this tool (i.e., for Vedic daily predictions or panchanga elements), making the selection criteria very clear.

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

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

Annotations already declare readOnlyHint/idempotentHint/destructiveHint=false, so the safety profile is covered. The description adds real behavioral context beyond that: the computation uses the name only and no birth date, the date param is inert, and reduction strips non-letters per upstream rules. It stops short of discussing determinism guarantees or output shape, but the output schema covers the latter.

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

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

Front-loaded one-line summary followed by labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH, doc link). Every sentence carries routing or contract information; nothing is padding.

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

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

An output schema exists, so return values needn't be restated. Given the tool is a standalone, single-input computation, the description covers purpose, disambiguation, input handling, and workflow transitions, leaving no gap an agent would need filled before calling it.

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

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

Schema coverage is 100%, which sets a baseline of 3, but the description adds meaning the schema lacks — that special characters and digits are acceptable in business_name and that non-letters are stripped during reduction. The date parameter's inert status is clarified in both places.

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 ('Reduces a business name to Expression and root digits') and names the actual outputs (thematic suitability lists, harmony score). The DO NOT CONFUSE WITH block explicitly separates it from asterwise_get_name_correction and asterwise_check_mobile_number, so an agent can route 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?

The WORKFLOW block gives explicit before/after conditions ('BEFORE: None — standalone', 'AFTER: get_name_correction — if the entity is a person, not a brand') and the DO NOT CONFUSE WITH block names the two most confusable siblings with the discriminating condition for each.

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 non-open-world, so the safety profile is covered. The description adds genuine behavioral context beyond that: the INPUT CONTRACT states name/date are forwarded as-is with no local validation, and it points to the output/error contract URL. It stops short of describing return shape, but the output schema covers that.

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 one-line purpose, then uses labeled blocks (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) that each carry routing or contract value rather than filler. Slightly more scaffolding than strictly necessary for a 3-parameter tool, but 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?

An output schema exists, so return values need no prose. Between the purpose line, the explicit sibling routing, and the input contract, an agent has everything required to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents date format, name handling, and the response_format enum. The description adds nothing parameter-specific beyond restating that name and date are the inputs, so the baseline 3 applies.

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

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

States a specific verb (reduces), the resources (a name and birth date), the method (Chaldean letter-value system), and the return content (name, birth, combined compound analyses with themes and keywords). It explicitly names the siblings it must not be confused with, so an agent can distinguish it 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?

The WORKFLOW and DO NOT CONFUSE WITH blocks give explicit when-to-use routing: standalone before-hook, an AFTER handoff to asterwise_get_numerology_profile, and two named alternatives with the exact distinguishing factor for each (Pythagorean stack vs Chaldean compounds, magic-square digit placement vs name reduction).

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, closed-world behaviour, so the safety profile is covered. The description adds value beyond that: it warns that the birth time is mandatory with no sunrise fallback, documents the ISO date convention that differs from the sibling tool, and explains cycle repetition. It does not discuss cost, rate limits, or failure modes beyond the docs link.

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

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

Front-loaded one-sentence summary, then clearly labelled WORKFLOW, INPUT CONTRACT and DO NOT CONFUSE WITH sections, so a skimming agent still gets the routing information. Slightly padded by restating the cycles semantics already present in the schema, which 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 single-purpose computation tool with a full output schema, the description covers everything the agent needs: inputs, output shape, temporal format, prerequisite tools, disambiguation from siblings, and a link to the full output/error contract. Nothing required 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 description coverage is 100% and the cycles parameter's schema text already contains the K.N. Rao repetition rule, so the description largely repeats rather than extends it. The one genuinely additive note is the ISO vs DD/MM/YYYY contrast with get_dasha, which is output-contract rather than parameter guidance. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb (computes), a specific resource (Char Dasha from birth data), and names the exact output artefacts (sign lords as period rulers, ISO-dated Maha/Antar sequences, karaka mappings). It explicitly differentiates itself from the two nearest siblings, get_dasha and get_yogini_dasha, by naming their rulers and period formats.

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 an explicit BEFORE/AFTER workflow (natal chart first, Vimshottari cross-check after) plus a DO NOT CONFUSE WITH block naming two alternatives and the distinguishing features of each. An agent has no inference left to do about when to pick this 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 declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so safety and repeatability are covered without prose. The description adds useful non-annotation context: the INPUT CONTRACT states 'BirthData only; no extra toggles', capping the surface an agent must reason about. It stops short of stating auth needs or rate limits, so it is strong but not exhaustive.

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

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

Front-loaded one-sentence purpose followed by clearly labelled WORKFLOW, INPUT CONTRACT and DO NOT CONFUSE WITH blocks. No filler; every section carries information an agent needs to route correctly.

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 aggregation tool with full annotation coverage, a 100%-documented nested input schema and an output schema that carries the return contract, the description covers everything needed to select and invoke it. The external docs link for 'full output and error contract' is a bonus, not a gap.

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

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

Schema description coverage is 100%, so both the nested birth object and response_format are fully documented in the schema; baseline 3 applies. The description only restates the input contract ('BirthData only') and does not add semantics beyond what the schema already provides.

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

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

States a specific verb ('Aggregates') and resource ('the chart's strength measures from BirthData'), then enumerates the concrete outputs: Shadbala, Bhavbala, Vimshopaka, plus vargas, Ashtakavarga, karaka maps and graha yuddha pairs. The 'DO NOT CONFUSE WITH' block contrasts it explicitly against get_yogas ('boolean yoga catalogue, not numeric bala') and get_ashtakavarga, so it is cleanly separable 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?

Gives explicit ordering guidance (BEFORE: get_natal_chart to contextualise houses; AFTER: get_yogas as an optional configuration pass) and names alternatives with the condition that selects each ('standalone AVK when strength bundle is not needed'). This is textbook when/when-not/alternatives guidance.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, providing the core safety profile. The description adds no side-effect information but does describe the output (quality, ruler, local clock bounds) and the input basis (sunrise/sunset at a location), which gives some behavioral context beyond the annotations. Since annotations cover the main safety aspects and the description adds modest context, a score of 4 is appropriate.

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

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

The main description is a single, dense sentence that conveys the core function without fluff. The additional sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) are each short and purposeful, adding necessary guidance without redundancy. The structure is well-organized and every sentence contributes value.

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

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

The description covers the tool's purpose, input constraints (via INPUT CONTRACT and schema), output expectations (quality, ruler, clock bounds), workflow (before/after), and alternatives to avoid. It also provides a link to the full output/error contract. For a tool with a nested location parameter, this is comprehensive and leaves little ambiguity for an agent to invoke it correctly.

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

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

Schema description coverage is 100% with all fields having descriptions (e.g., lat/lon ranges, date pattern, timezone default, response_format enum). The description text adds context by explaining that the location is used for 'sunrise/sunset' and that output includes 'local clock bounds,' which clarifies the role of timezone and lat/lon. The INPUT CONTRACT section also states that LocationInput enforces date format and lat/lon ranges, reinforcing schema details. This extra context justifies a 4 rather than the baseline 3.

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

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

The description states exactly what the tool does: 'Splits a solar day into sixteen Choghadiya segments from sunrise/sunset at a location and labels each slot's quality, ruler, and local clock bounds.' It clearly identifies the resource (solar day segments) and the action (splits and labels). The 'DO NOT CONFUSE WITH' section explicitly differentiates it from asterwise_get_hora and asterwise_get_muhurta, making it distinct among the many sibling tools.

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

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

The description provides explicit workflow guidance: 'BEFORE: None — this tool is standalone. AFTER: asterwise_get_rahu_kaal — optional inauspicious band overlay for the same date.' It also includes 'DO NOT CONFUSE WITH' warnings that clarify when not to use this tool compared to related ones (hora, muhurta). This gives the agent clear conditions for selecting this tool over alternatives.

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

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

Annotations already declare readOnlyHint/idempotentHint/non-destructive, so the safety profile is covered. The description adds real context beyond that: the unknown-birth-time path (sunrise chart, birth_time_provided=false), the meaning of passing '00:00', and the fact that all scoring is computed upstream from the payloads. It stops short of describing pagination, cost, or latency, so it is strong but not exhaustive.

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 one-line purpose, then organized into labeled WORKFLOW, INPUT CONTRACT and DO NOT CONFUSE WITH blocks. Every line carries decision-relevant information; the closing docs link is a pointer rather than padding.

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

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

An output schema exists so return values need not be specified, and the description nonetheless summarizes the payload shape. Prerequisites, alternative tools, and the birth-time edge case are all covered, leaving nothing an agent needs to invoke it correctly unaddressed.

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 baseline is 3. The description's input-contract notes about omitting time and the '00:00' semantics largely restate what the schema already says about the time field, adding little the agent could not read in the schema itself.

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 (Scores), a named resource (North Indian Ashtakoota / 36-point Guna Milan) and its scope (two charts), then enumerates what is returned: koota breakdown, dosha flags, classical vetoes, Mangal cross-check, narrative guidance. It also names the exact siblings it is not (dashakoot, porutham), so an agent can disambiguate 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?

The WORKFLOW block gives an explicit BEFORE (asterwise_get_natal_chart, marked RECOMMENDED) and AFTER (asterwise_get_papasamyam, marked optional), and the DO NOT CONFUSE WITH block routes the agent away from two near-name-collision tools with the distinguishing criterion for each. This is a full when/when-not/alternatives contract.

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 closed-world, covering the safety profile. The description adds case-insensitive matching and flags that the payload carries dual planetary assignments, healing properties, and safety cautions, but a docs link is deferred to for the error contract rather than stating it inline.

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 purpose followed by clearly labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) that make scanning easy. The 'BEFORE: None — AFTER: None' line is somewhat formulaic filler, slightly diluting efficiency.

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

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

An output schema exists, so return values need not be enumerated, yet the description still summarizes the payload and links an error contract, leaving few gaps. Given a 2-parameter read-only tool, this is complete enough 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 100%, so both parameters (name, response_format) are already documented, and the description's name examples ('amethyst', 'blue-sapphire', "Cat's Eye Chrysoberyl") merely duplicate the schema. Baseline 3 applies since the schema does the heavy lifting and the description adds no new parameter meaning.

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 ('Lookup a specific crystal') with matching rules (slug or name, case-insensitive) and the depth of detail returned. The 'DO NOT CONFUSE WITH' block explicitly separates it from get_crystals (catalogue), get_crystal_by_planet, and get_gemstone_recommendations, so an agent can disambiguate 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?

Gives a workflow slot ('standalone or after asterwise_get_gemstone_recommendations') and names three alternatives with their distinct scopes. It stops short of full when-not guidance (e.g., no explicit trigger distinguishing name lookup from the catalogue, only the scope distinction).

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/closed-world safety, so the description adds non-obvious behavior: results are sorted Navaratna-first then Uparatna, and crystals with no Vedic correspondence are excluded. That result-set composition and ordering context is genuinely useful and 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 the core behavior, then cleanly sectioned into WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH. Slightly verbose with the docs link, but every block carries routing or behavioral value.

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

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

An output schema exists, so return-value explanation is unnecessary. Between the purpose, workflow, input contract, and sibling disambiguation, nothing an agent needs to select or call this tool 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% (baseline 3), but the INPUT CONTRACT enumerates the exact allowed planet values (Sun through Ketu), adding precision beyond the schema's loose 'e.g. Venus or Saturn' example. It also implicitly constrains the parameter to the nine Vedic planets.

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 ('Returns all crystals associated with a specific Vedic planet') and immediately scopes the result set (Navaratna/Uparatna only). The DO NOT CONFUSE WITH section explicitly differentiates it from get_crystals and get_gemstone_recommendations, so an agent can route correctly 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?

Provides an explicit BEFORE/AFTER workflow (get_natal_chart to identify the planet, then get_gemstone_recommendations for safety assessment) plus named alternatives with the condition that selects each. When-to-use and when-to-use-something-else are both 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 cover readOnly and idempotent hints, so the description does not need to repeat those. It adds behavioral context by stating the sorting logic and offering a response_format parameter, which clarifies output behavior beyond the schema. The output/error contract link provides additional transparency, though no direct side-effect details are needed given the annotations.

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

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

The description is well-structured with clear sections (workflow, input contract, do-not-confuse, output contract). Though somewhat lengthy, every sentence contributes useful information—no fluff. The main recommendation statement is concise, and the additional sections are organized logically.

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?

Provides sufficient context for correct invocation: required filters, output format options, and a link to the full output/error contract. Although the actual output schema is not embedded, the description's mention of markdown/json and the contract URL mitigate the gap. It also clarifies relationships with sibling tools, making the tool's role well-defined.

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 baseline is 3. The description enhances this by listing allowed chakra values (Root, Sacral, Solar Plexus, etc.) which are not in the schema enum, and providing concrete examples for intention (protection, abundance, love) and zodiac_sign. It also clarifies the limit default/max, aligning with schema but adding context.

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

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

Clearly states the verb 'Recommends' and the resource 'crystals', with specific criteria (zodiac sign, chakra, intention). The 'DO NOT CONFUSE WITH' section explicitly differentiates from sibling tools like asterwise_get_crystal_by_planet and asterwise_get_gemstone_recommendations, making its purpose unambiguous.

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

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

Explicitly states the requirement 'At least one filter is required' and describes the ordering behavior ('matches the most criteria first'). The workflow mentions 'AFTER: asterwise_get_crystal' for subsequent detail retrieval, and the 'DO NOT CONFUSE WITH' lines provide clear when-to-use guidance against alternatives.

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

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

Annotations already declare readOnlyHint/idempotentHint, so the safety profile is covered. Description adds meaningful behavioral context beyond annotations: internal chart computation (no prerequisite call), the Lahiri default, the time-sensitivity mechanism (Lagna → house lords → full recommendation change), and a caution against guessing time. Slight gap: it defers output/error details to an external docs URL rather than describing them inline.

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 purpose statement, then clearly labeled WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE sections. The DO NOT CONFUSE block is dense but each entry earns its place by preventing a distinct misselection. Slightly verbose for the payload size.

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

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

Output schema exists, so return-value explanation is not required. For a read-only chart tool with an output schema, the description covers prerequisites (none internal), timezone/ayanamsa defaults, time-sensitivity risk, and sibling routing — everything an agent needs to call it correctly.

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

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

Schema coverage is 100% and already documents birth fields, timezone defaults, and the time value's no-fallback rule. The description adds the time-sensitivity rationale (why an accurate time matters) which is useful, but does not add new syntax or constraints beyond the schema. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

States a specific verb+resource ('Recommends crystals from a Vedic natal chart') and immediately differentiates from the sibling asterwise_get_crystal_recommendations by noting it derives from a computed chart rather than sign/chakra. The DO NOT CONFUSE section further disambiguates from three distinct 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?

Explicit workflow (BEFORE/AFTER), names specific follow-up siblings, and includes a 'DO NOT CONFUSE WITH' section covering asterwise_get_gemstone_recommendations, asterwise_get_crystal_recommendations, and asterwise_get_crystal_by_planet with the condition that separates each. This is explicit when-to-use and when-not guidance.

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

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

Annotations already declare readOnly=true, idempotent=true, destructive=false, and openWorld=false, so the safety profile is fully covered by structured data. The description adds the deterministic behavioral traits an agent needs: fixed size (54 entries) and deterministic ordering, which imply stable, repeatable output. It stops short of any rate-limit or failure-mode detail, deferring instead to a docs URL.

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 payload summary, then clearly sectioned by WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH, which makes it easy to scan. Slightly verbose in the field enumeration and the 'BEFORE: None — standalone catalogue' line carries little weight, but every section is purposeful.

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?

A read-only catalogue with an output schema, full annotation coverage, and one well-documented parameter needs little more than routing guidance, which this provides. Output values need not be re-explained given the output schema, yet the description still lists them usefully, and the error/output contract is linked.

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

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

Schema description coverage is 100% and there is only one optional enum parameter (response_format), whose schema description already explains both values. The prose adds no syntax or format detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb and resource (returns all crystals) plus scope specifics: the exact count (54), the sort order (alphabetical), and a full inventory of the fields each entry carries. It also explicitly names the sibling tools it is not, so an agent can distinguish the full catalogue from the single-crystal and filtered variants.

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 WORKFLOW BEFORE/AFTER block gives explicit sequencing, and 'DO NOT CONFUSE WITH' lists three sibling tools with the distinguishing condition for each (single crystal by name, filter by Vedic planet, recommendations by zodiac/chakra/intention). It also states the input contract (no required parameters). 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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), yet the description still adds real operational context: payload magnitudes (about 100 KB vs over 20 MB), the fact that data.interpretation ignores from_date/to_date, and the unknowable-birth-time fallback (sunrise chart, birth_time_provided=false, never pass 00:00). The one gap is that it defers the full error contract to an external URL rather than summarizing it inline.

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

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

Front-loaded one-sentence summary followed by labeled blocks (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE), which makes scanning easy. The levels explanation largely restates the schema enum, a minor redundancy, but the density of the remaining content justifies the length.

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

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

For a nested-input, output-schema-bearing computation tool, it covers everything an agent needs: birth data contract, unknown-time edge case, depth/payload tradeoff, date filtering semantics, output date format quirk, and correct sibling routing. Return values need not be documented further because an output schema exists.

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 would be 3; the description earns a point by adding meaning the schema lacks — the per-level names (Maha/Antar/Pratyantar/Sookshma/Prana), the DD/MM/YYYY date format inside periods[] versus ISO elsewhere, and the explicit recommendation to pair date filters with levels 4-5 to bound payload size. It also clarifies the semantic asymmetry of the date filters (periods that started by to_date vs still running after from_date).

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 ("Computes Vimshottari Dasha from birth data") plus the exact return shape (hierarchical period trees and current Maha/Antar interpretation blocks). The DO NOT CONFUSE section names the three closest siblings (char, yogini, ashtottari dasha) and the discriminator for each, so the agent can select this tool 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 workflow sequencing (RECOMMENDED prerequisite asterwise_get_natal_chart, follow-on asterwise_get_dasha_transits) with the reason for each. Exclusions are spelled out by naming rival dasha tools and their distinguishing payload fields rather than leaving the agent to infer.

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 closed-world, so safety is covered. The description adds genuine value beyond that: it discloses the return payload shape (score, percentage, boolean dosha flags, diagnostics) and the workflow ordering, though error behavior is deferred to an external docs link rather than stated inline.

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 purpose sentence followed by clearly labeled WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH blocks. Every line adds routing or contract information; nothing is redundant padding.

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

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

With an output schema present, return values need not be spelled out, yet the description still summarizes them. Combined with workflow ordering, sibling disambiguation, and the input contract, an agent has everything needed to select and call this tool correctly.

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

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

Schema description coverage is 100% and both nested BirthData objects document every field, so the schema carries the load. The description only adds 'Two BirthData objects per global contract,' which does not extend meaning beyond what the schema already says. Baseline 3 applies.

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

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

States a specific verb and resource ('Computes the ten-koota Dashakoot grid for two charts'), plus the transformation ('converts it to a ten-point score with percentage') and secondary returns. It explicitly distinguishes itself from two similar-sounding siblings (Ashtakoota 36-point compatibility, Tamil ten-porutham) by naming their differing breakdown keys.

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 an explicit BEFORE (get_natal_chart, marked RECOMMENDED) and AFTER (get_papasamyam, optional) workflow. The DO-NOT-CONFUSE-WITH block names two alternatives and the condition that separates them, 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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuinely useful behavioral context beyond that: birth time is mandatory with no sunrise fallback, and the agent is told to admit ignorance rather than pass '00:00'. It stops short of describing pagination/rate limits or the scoring scale, so not a full 5.

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

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

Front-loaded one-sentence purpose followed by clearly labelled WORKFLOW, INPUT CONTRACT and DO NOT CONFUSE WITH blocks. Every sentence carries routing or constraint value with no filler, and the output-contract link is deferred to the end where it belongs.

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 tool with 5 params, a nested birth object, 100% schema coverage and an output schema, the description supplies everything an agent needs: purpose, prerequisites, defaults, the hard birth-time requirement, and disambiguation from the three nearest siblings.

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

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

Schema description coverage is 100% and every parameter (including the nested birth object) is documented in-schema, so the baseline is 3. The description restates the target_date/target_time/target_timezone defaults and the no-sunrise-fallback rule, which duplicates rather than extends the schema.

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

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

States a specific verb and composite resource: combines active Vimshottari lords with transits for one date, returning scored correlations plus transit longitudes and houses from Moon and Lagna. The 'DO NOT CONFUSE WITH' block explicitly separates it from asterwise_get_gochar, asterwise_get_transits and asterwise_get_dasha, 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?

Explicit WORKFLOW section gives a BEFORE prerequisite (get_natal_chart to understand houses/lords) and an AFTER alternative (get_gochar for a broader transit snapshot without dasha scoring). The alternatives block names three siblings with the exact distinguishing trait of each, covering when-not-to-use.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so safety is covered. The description adds real behavioral context beyond that: enum enforcement is local, and with an unknown birth time the lagna, houses, and houses table are omitted with birth_time_provided=false. It does not cover failure modes or rate limits, which is delegated to the docs URL.

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 core sentence, then clearly labeled WORKFLOW / INPUT CONTRACT / DO NOT CONFUSE WITH blocks. Every sentence carries information; no filler.

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

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

For a read-only computation tool with a full output schema, the description covers what is computed, the optional-parameter behavior, output contents, degradation without birth time, prerequisites, and sibling disambiguation. 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 description coverage is 100%, so birth fields, ayanamsa, timezone, and the omission-for-unknown-time semantics are already documented in the schema. The description's 'omit chart_type for all sixteen' and the birth_time_provided note largely restate what the schema says, so the baseline 3 applies.

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

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

States a specific verb and resource ('Computes divisional (varga) charts from BirthData') and immediately names the two siblings it is not: get_natal_chart and get_chart_strength. An agent can distinguish it from all ~90 siblings 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 WORKFLOW block recommends asterwise_get_natal_chart as the D1 anchor beforehand, states AFTER: None, and the DO NOT CONFUSE WITH section routes on the specific conditions (radix chart with houses/drishti vs. varga set; varga-based strength scores vs. placements).

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, and closed-world behavior. The description adds useful output context (presence flags, typed details, optional summaries, remedy lines) and workflow sequencing. However, its statement that unknown birth time at midnight is accepted silently is ambiguous and appears to conflict with the schema's explicit instruction never to pass '00:00' for unknown time.

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 front-loaded with the core purpose, then organized into scannable WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH sections. No sentence is wasted, and the structure supports rapid agent parsing.

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

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

For a read-only tool with an output schema and full annotations, the description is largely complete: it covers purpose, workflow, sibling exclusions, and input contract. The only gap is the potentially misleading midnight-time guidance, which prevents a perfect score.

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 parameters in detail. The description's only parameter-related addition is 'BirthData follows the global contract', which adds no actionable detail, plus the ambiguous/conflicting midnight-time statement. This falls below the baseline because it may mislead rather than clarify.

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 ('Scores'), a precise resource ('thirteen fixed dosha buckets'), and the output shape. It explicitly distinguishes itself from asterwise_get_chart_strength and asterwise_get_compatibility, making sibling selection unambiguous.

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

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

The WORKFLOW section names recommended predecessor and successor tools. The DO NOT CONFUSE WITH section explicitly names alternatives and the conditions under which they differ, leaving no inference needed.

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 annotations (read-only, idempotent, non-destructive), the description discloses case-insensitive lookup, standalone execution, and provides a link to the full output and error contract. These are behavioral details not covered by the annotations.

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

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

The description is well-organized with clear sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH, full contract link). It is concise, uses short bullet-like sentences, and avoids unnecessary elaboration.

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

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

The description covers the return content (Jungian archetype, Vedic meaning, context variants, related symbols), the input format with examples, the output format options, and points to a full contract link. Combined with the schema and annotations, it gives the agent full context needed to invoke correctly.

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

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

The schema has 100% description coverage for both parameters. The description's INPUT CONTRACT section only repeats the name parameter details already present in the schema (e.g., examples). No additional semantic meaning is added beyond what the schema already provides.

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

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

The description explicitly states the action ('Lookup a specific dream symbol'), the target resource ('by slug or name (case-insensitive)'), and the output contents ('full dual-tradition interpretation...'). It also names the sibling tool it is not to be confused with, making the purpose unmistakable.

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

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

The description provides clear 'DO NOT CONFUSE WITH' guidance to distinguish from asterwise_get_dream_symbols (full listing), and includes a WORKFLOW section indicating it is standalone with no prerequisites or follow-ups. This gives explicit when-to-use and when-not-to-use direction.

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, non-destructive behavior, so the safety profile is covered. The description adds useful context: the dual-tradition nature of each symbol, the total corpus size, and the default filter behavior. It stops short of describing pagination or response shape, but with an output schema present 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?

Front-loads the core purpose, then uses labeled blocks (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH, docs URL) that each earn their place. No filler sentences and nothing 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 only two optional params, a full output schema, and complete annotations, the description covers everything an agent needs: purpose, corpus scope, category semantics, the alternative tool, and a docs link for the full output/error contract.

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%, setting a baseline of 3, and the description adds value beyond the schema by enumerating the eight valid categories in the INPUT CONTRACT and clarifying that omission returns all 500 symbols — richer than the schema's terse 'omit for all 500 symbols.' The response_format parameter is left to the schema, which is acceptable at full coverage.

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

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

States a specific verb and resource ('Returns dream symbols from the database') and defines scope precisely: 500 symbols across 8 categories with dual Jungian/Western and Vedic interpretation. It explicitly distinguishes itself from the singular asterwise_get_dream_symbol.

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 an explicit workflow block (BEFORE: none — standalone; AFTER: asterwise_get_dream_symbol), an input contract on optional category usage, and a 'DO NOT CONFUSE WITH' clause naming the sibling and its distinct role.

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, non-destructive, closed-world, so the safety profile is covered. The description adds genuine behavioral context beyond them: the Decoz per-part reduction order and the invariant that master numbers 11/22/33 are preserved at every step. It stops short of describing error responses, deferring those to a docs link.

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 one-sentence definition, then labelled WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE sections that an agent can scan. No filler sentences; the docs link replaces what would otherwise be bloated return-value prose.

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

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

An output schema exists, so return values need not be re-explained, and the description correctly omits them. Between the algorithm note, input contract, sibling disambiguation, and docs link, an agent has everything required to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so 3 would be the baseline, but the INPUT CONTRACT adds meaning the schema does not carry: worked examples ('Arjun Mehta', 'Sofia Rossi'), explicit case-insensitivity, and a validation constraint (at least one alphabetic character). The response_format enum is already documented in the schema.

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

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

States a specific verb (Calculates) and resource (Expression/Destiny number) plus the algorithm family (Pythagorean letter values) and scope (full name). A 'DO NOT CONFUSE WITH' block names the sibling tools it must be distinguished from, 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?

Explicitly states WHEN via workflow ('BEFORE: None — standalone', 'AFTER: soul_urge' to complete the core trinity) and the alternatives via the DO NOT CONFUSE block (soul_urge=vowels, personality=consonants, profile=all-in-one, chaldean=different system). 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?

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds useful methodology — how lunar festivals are fixed by month, tithi and day-part, tie-break rules, Bhadra/Smarta Ekadashi rules — and validation against published panchang dates. However, it does not disclose practical behaviors like response size for a full year or rate limits; solid added context, but not exceptional beyond annotations.

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

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

Front-loads purpose, then structured WORKFLOW / INPUT CONTRACT / DO NOT CONFUSE sections. The tithi and Bhadra methodology sentence is dense and somewhat verbose, but it is relevant and does not bury the routing 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?

The tool is complex (astronomical festival computation, six parameters, category defaults), and the description covers placement workflow, disambiguation, defaults, category expansion and validation basis. Because an output schema exists, it need not explain return values, so this is complete 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 coverage is 100%, so the baseline is 3. The description earns an extra point by adding meaning the schema does not convey in the same words: the default ['festival'] yields about 50 named festivals, and 'vrat'/'period'/'eclipse' each expand the result set in specific ways. It supports the enum semantics rather than merely repeating 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+resource with scope: Hindu festivals, vrats, sankrantis, eclipses and periods for a year at a location. It explicitly names the siblings it is not (get_panchanga_calendar, get_muhurta), so an agent can distinguish it 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 BEFORE/AFTER workflow (geocode, then panchanga) and a 'DO NOT CONFUSE WITH' section naming alternatives with disambiguating conditions. It also explains exactly when to add each category value.

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=true, idempotent=true, destructive=false, so the safety profile is covered and the bar is lower. The description still adds value by disclosing that output includes contraindications and a safety note, and that wearing advice presupposes a confirmed chart — meaningful context for a recommendation tool that could be misused.

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

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

Front-loaded with the core purpose, then clearly labeled WORKFLOW / INPUT CONTRACT / DO NOT CONFUSE blocks that are easy to scan. Slightly longer than needed because the docs URL and output listing duplicate coverage available in the 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 an output schema exists, the description need not explain return values, yet it summarizes them briefly and adds a route to the full output/error contract. Workflow, prerequisites, sibling disambiguation and data contract are all present for a single-required-parameter read tool.

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

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

Schema description coverage is 100%, with nested BirthData fields fully documented (including the explicit no-sunrise-fallback rule for 'time'), so the schema carries parameter semantics. The description only adds a pointer that BirthData follows the global contract, which is orientation rather than new per-parameter meaning.

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 ('Computes Ratna-style gemstone picks and cautions from the natal chart') and names the returned artifacts. The DO NOT CONFUSE section explicitly separates it from asterwise_get_remedies and asterwise_get_lal_kitab_remedies, so an agent can route 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?

Provides an explicit BEFORE/AFTER workflow (confirm chart via asterwise_get_natal_chart, follow up with asterwise_get_remedies) plus two named alternatives with the condition that selects each. When-to-use and when-not-to-use are both covered directly.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world). The description adds real value beyond that: it declares that all inputs derive from birth data with no sunrise fallback and states the computational dependency on the natal Moon sign. It stops short of richer behavioral detail (cost, latency, precision limits) but covers what matters for correct invocation.

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

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

Front-loaded one-line purpose followed by labeled blocks (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH). Every sentence carries routing or input information; nothing is padding, despite the length.

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

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

An output schema exists so return values need no prose, and the description supplies the missing pieces: workflow placement, the input contract, disambiguation from siblings, and a docs link for the full output/error contract. Nothing needed to call it correctly 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 description coverage is 100%, so the schema already documents birth, response_format and every nested field (including the ayanamsa enum and the warning against guessing birth time). The description only adds that Moon sign is computed from birth data, which is derived behavior rather than new parameter meaning. Baseline 3 applies.

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

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

States a specific verb and resource: returns the four Ghatak (inauspicious) timing parameters, scoped to Janma Rasi. It explicitly names and contrasts the sibling tools it could be confused with, so an agent can select it 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?

The WORKFLOW block gives explicit BEFORE/AFTER sequencing, and the DO NOT CONFUSE WITH block names two alternatives (get_nakshatra_prediction, get_panchanga) with the exact distinguishing condition for each. Nothing about when to use this vs. those is left to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds real operational context beyond them: no sunrise fallback for missing birth time, an instruction not to guess or pass '00:00', and the fact that target_date is evaluated at 12:00 India time. It stops short of describing error surfaces beyond pointing at an external contract URL.

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, then uses labeled blocks (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) so an agent can scan to the relevant section. Dense but every block carries routing or constraint information; the trailing doc link is the only mild padding.

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

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

Given an output schema exists, the description need not explain return values, yet it does summarize them. Combined with the input contract, defaults, sibling disambiguation, and workflow ordering, an agent has everything needed to select and call this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3; the description goes slightly beyond by framing the input contract (target_date optional and defaulted, birth time mandatory with no fallback path) rather than merely repeating field names. It does not add format or validation detail beyond what the schema already encodes.

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 ('Computes Gochar against the natal Moon and Lagna') and enumerates the output payload (longitudes, houses, AVK scores, vedha flags, roll-up summary). The DO NOT CONFUSE WITH block explicitly separates it from asterwise_get_transits and asterwise_get_dasha_transits.

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 an explicit BEFORE/AFTER workflow chain (natal chart first, dasha transits after) and names both alternatives with the condition that distinguishes them ('ingress and station tables for a chosen date window' vs 'single-day Gochar snapshot'). Prerequisites are also stated: birth time is required and there is no sunrise fallback.

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 include readOnlyHint=true and idempotentHint=true, covering the key behavioral aspects. The description adds context about the output (tags each hour with ruler, quality, and 'current' status) and references a full output/error contract link. This goes slightly beyond the annotations, though it doesn't explicitly mention side effects or permissions (which are covered by the readOnlyHint).

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

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

The description is well-structured with clear sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH, full contract link). It is concise yet comprehensive, using bullet-like separations to convey essential information without unnecessary verbosity, especially given the large number of sibling tools it must differentiate from.

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

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

The tool has a relatively simple input structure (one nested location object) and an output schema is present. The description provides enough context to understand the tool's purpose and output, and it includes a link to the full output/error contract. Given the output schema exists, the description adequately covers what an agent needs to invoke 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?

The input schema has 100% description coverage for all properties, including date format, lat/lon ranges, timezone default, and response_format enum. The description only restates the location rules ('date/coordinate rules apply locally') without adding new semantic details beyond the schema, so it does not exceed the baseline for schema-covered parameters.

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

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

The description clearly states the specific function: 'Builds the twenty-four planetary Horas between successive sunrises for a location and tags each hour with ruler, quality text, and whether it is current.' It also explicitly differentiates from sibling tools like asterwise_get_choghadiya and asterwise_get_natal_chart, ensuring no ambiguity.

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

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

The description provides explicit guidance on when to use this tool versus alternatives. It states 'WORKFLOW: BEFORE: None — this tool is standalone' and 'DO NOT CONFUSE WITH' sections that clarify the differences from get_choghadiya and get_natal_chart, giving clear conditions for selection.

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-structured context: the content is AI-synthesised, the payload includes model and period metadata, moon_sign resolution happens upstream, and response_format 'selects JSON vs markdown rendering only' — an important clarification that formatting does not alter content. It does not mention latency, rate limits, or failure modes beyond the external docs link.

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 lead sentence followed by clearly labelled WORKFLOW / INPUT CONTRACT / DO NOT CONFUSE sections, which is easy for an agent to parse. Minor waste: the period enum is re-listed verbatim from the schema, and a docs URL is carried in the description rather than a structured field.

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

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

With an output schema present, the description needn't describe return fields, and rich annotations cover the safety profile; what it does provide — sign-name vocabulary, upstream resolution, format-vs-content semantics, sibling disambiguation — is sufficient to call it correctly. The full output and error contract is deferred to an external URL, which leaves error behaviour undocumented in-context.

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

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

Schema coverage is 100%, so baseline would be 3, but the description adds real meaning: the full accepted Sanskrit and English moon-sign name lists (the schema only shows one example pair) and the note that resolution is upstream, implying the tool will not validate the sign itself. The restatement of the period enum duplicates the schema and earns nothing.

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 — 'Fetches an AI-synthesised Moon-sign horoscope for a chosen horizon' — and names the return shape (guidance fields plus model/period metadata). It explicitly separates itself from asterwise_get_natal_chart and asterwise_get_gochar, but never distinguishes itself from the close sibling asterwise_get_western_horoscope, nor does it say the horoscope is Vedic/sidereal in the prose (that only appears inside the moon_sign parameter description).

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: BEFORE None (standalone), AFTER asterwise_get_natal_chart with the condition 'if the user needs a personalised chart', plus a DO NOT CONFUSE WITH block naming two alternatives and the reason each differs. An agent has enough to choose correctly without opening another schema.

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 readOnlyHint/idempotent/non-destructive, and the description adds real value beyond them: the actual algorithm, a worked example, and an input contract. It doesn't detail error/edge behavior beyond linking to a docs URL, so not a full 5, but the safety profile plus method is well 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?

Front-loaded with the purpose, then structured into WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH headings. The worked example is long but earns its place by demonstrating the algorithm; only minor trimming is possible.

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

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

An output schema exists, so return values need not be explained, and the description still covers purpose, algorithm, workflow ordering, sibling disambiguation, and an error-contract pointer. Nothing an agent needs 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 100%, so the baseline is 3, but the description adds an INPUT CONTRACT section with a concrete worked example ('Arjun Mehta' → letters → missing {6,7}) that makes the 'name' parameter's expected form clearer than the schema alone.

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 ('Identifies karmic lessons by scanning all letter values...finding which digits 1–9 are absent') and goes further to explain the mechanism. It actively distinguishes itself from siblings with a 'DO NOT CONFUSE WITH' section naming balance_number and expression_number.

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 an explicit workflow (BEFORE: None — standalone; AFTER: asterwise_get_numerology_profile) and enumerates the sibling tools this should NOT be confused with, along with why. When-to-use and when-not-to-use are both 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?

Annotations already carry readOnly/idempotent safety, but the description adds real behavioral context annotations cannot: ayanamsa is accepted but ignored, no sunrise fallback, and a warning never to pass 00:00 for unknown time. That is the load-bearing disclosure. It doesn't describe the response shape, but an output schema exists.

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

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

Front-loaded purpose sentence, then labelled WORKFLOW / INPUT CONTRACT / DO NOT CONFUSE blocks. Every line earns its place; no filler.

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

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

For a read-only chart builder with an output schema and fully documented nested params, the description covers everything an agent needs: how to call it, what it ignores, what to do if birth time is unknown, and where to route before and after.

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

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

Schema coverage is 100% and nested, so the schema already documents birth fields, enums, defaults and ranges. The description adds one genuine constraint beyond the schema (ayanamsa ignored) plus the birth-time requirement, which the schema itself repeats. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

States a specific verb ('Builds') and resource ('KP natal chart with sub-lords on grahas and twelve cusps') and pins the ayanamsa. It names two siblings it is not (natal_chart, kp_ruling_planets), so an agent can distinguish it 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?

Explicit BEFORE (cross-check birth record) and AFTER (kp_significators) routing, plus a DO NOT CONFUSE block naming the alternative tools and the condition that selects each. 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?

Annotations already declare readOnly/idempotent/non-destructive, but the description adds substantial non-obvious behavior: DST handling for skipped times (moved forward by the gap) and ambiguous times (first occurrence), plus data.local_time_status values. It also discloses the accepted date range (1800–2099) and which fields (target_utc, target_timezone) echo back what was used.

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

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

Front-loads the core purpose, then organizes the rest under labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH), which is appropriate for a tool with real edge cases. It is long, but nearly every sentence carries distinct information; minor trimming of the DST detail is possible.

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 purpose, standalone vs. follow-up routing, the full input contract including defaults and DST edge cases, sibling disambiguation, and a doc link for the full output/error contract. With an output schema present, it does not need to enumerate return fields, and its brief mention of returned values is sufficient.

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

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

Schema coverage is 100%, so the schema already documents lat/lon, date/time defaults, and timezone. The description nevertheless adds value beyond the schema: the 1800–2099 date-range constraint, the DST resolution rules, and the timezone default derivation from lat/lon. It does not add format/syntax beyond the schema, so it lands just above baseline.

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 (computes), resource (KP ruling planets), and scope (at a lat/lon for the current instant or a given local date/time, with no birth data). It even names the returned components (day lord, Moon/Ascendant lord chains, deduplicated ruling_planets list). The DO NOT CONFUSE WITH block explicitly separates it from kp_chart and prashna_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?

Provides explicit workflow routing: 'BEFORE: None — standalone. AFTER: asterwise_get_kp_chart — if natal confirmation is needed.' The DO NOT CONFUSE WITH section names the two nearest alternatives and the distinguishing condition for each (kp_chart needs BirthData; prashna_chart is horary). 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?

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral context beyond that: an ordering dependency on asterwise_get_kp_chart, the fact that the tool reads BirthData with no sunrise fallback, and the shape of the result (house tables plus planet-tier reverse indexes). It does not discuss cost, rate limits, or failure modes, which is acceptable given the annotations and output schema.

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

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

The one-line summary is front-loaded and the labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) make the routing information scannable rather than buried in prose. It is slightly padded by the redundant INPUT CONTRACT line and the external docs URL, but nothing is materially wasteful.

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

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

With a full input schema, a rich nested birth object, an output schema, and safety annotations, the description covers the remaining gaps an agent needs: when to run it relative to the KP chart tool, and which sibling tools it is not. The only omission is domain context on what a 'significator tier' means, which is reasonable to defer to the linked documentation.

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

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

Schema description coverage is 100% and every parameter (birth fields, ayanamsa, timezone, house_number, response_format) is documented in the schema itself, including the important 'never pass 00:00 for unknown' warning. The description's INPUT CONTRACT ('house_number optional int 1..12; omit for all twelve') only restates what the schema already says, so baseline 3 applies.

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

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

The first sentence states a specific verb and resource ('Computes KP significator chains') and names the scope ('all houses or one optional house from BirthData'), plus what it returns ('house tables plus planet-tier reverse indexes'). The DO NOT CONFUSE WITH section explicitly separates it from asterwise_get_kp_chart and asterwise_get_natal_chart, so an agent can identify it 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?

The WORKFLOW block gives an explicit precondition ('BEFORE: RECOMMENDED — asterwise_get_kp_chart — establish cusps before significators') and states there is no follow-up tool. The DO NOT CONFUSE WITH section names two alternatives and explains the discriminating dimension (cusps/sub-lords vs. tiered significator unions; drishti matrices vs. KP tiers).

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 this is a read-only, idempotent, non-destructive operation, so the bar is lower; the description goes well beyond them by disclosing that tropical ayanamsa is refused with INVALID_PARAMS, that omitting time yields a sunrise chart with birth_time_provided=false and approximate houses, and that the output enumerates specific derived structures.

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 purpose sentence followed by clearly labeled WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH sections; the structure makes scanning fast. It is somewhat long, and the docs URL/last line is minor overhead, but each block carries actionable content rather than filler.

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

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

An output schema exists and the description summarizes the returned structures rather than restating them; combined with the ayanamsa constraint, unknown-time fallback, error behavior, and sibling routing, nothing an agent needs to invoke this 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 description coverage is 100%, so the baseline is 3, but the description adds real semantics the schema lacks: it clarifies that ayanamsa options are used 'as sent' except tropical, which the schema lists as a valid enum value but the tool rejects, and it explains the unknown-birth-time behavior of the time parameter. That is meaningful guidance beyond the field descriptions.

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

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

States a specific verb and resource ('Produces a Lal Kitab chart from BirthData') and grounds it in a named system ('following the 1952 Lal Kitab: houses counted from the Vedic lagna'). It also enumerates what the chart contains (pakka ghar, uchcha/neecha, twelve houses, nine rin) and explicitly separates itself from asterwise_get_natal_chart, so an agent can pick it correctly 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?

Provides explicit BEFORE/AFTER workflow chaining (standalone, then asterwise_get_lal_kitab_remedies for planets needing remedies) and a 'DO NOT CONFUSE WITH' block naming the two nearest siblings with the condition that distinguishes them. Nothing about when-to-use is left to inference.

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

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

Annotations already establish read-only, idempotent, non-destructive, closed-world behavior, and the description goes further with traits the annotations cannot express: tropical ayanamsa is refused with INVALID_PARAMS and why, and unknown birth time yields a sunrise chart with approximate houses and therefore approximate remedies. These are real invocation-shaping 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?

Labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE) keep it scannable and the highest-value constraints are front-loaded. There is mild redundancy where the INPUT CONTRACT restates schema defaults, and the contract URL adds length, but nothing 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?

For a read-only 2-parameter tool with an output schema and full annotation coverage, the description supplies everything an agent needs: routing, prerequisite, ayanamsa policy, unknown-time degradation, and a pointer to the full output/error contract. No material gap remains.

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, but the description adds meaning beyond the schema: it explains that ayanamsa is 'used as sent' for lahiri/raman/kp while tropical is rejected, and that omitting time sets birth_time_provided=false. Marginal but genuine value over the already-complete schema.

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

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

States a specific verb and resource ('Lists Lal Kitab remedies from the 1952 Lal Kitab') with scope: planets that need them plus indicated debts (rin). It explicitly distinguishes itself from siblings asterwise_get_remedies and asterwise_get_gemstone_recommendations, so an agent can route without opening another 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?

Provides an explicit BEFORE workflow ('asterwise_get_lal_kitab_chart — see the chart and malefic reasons first') and a DO NOT CONFUSE section naming two alternatives with the distinguishing trait for each. When-to-use, prerequisites, and exclusions are all 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?

Annotations already carry the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), lowering the bar. The description adds context beyond annotations by declaring the tool standalone (no workflow dependencies) and noting the input is validated upstream. No contradiction with annotations.

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

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

The description is front-loaded with the core purpose, then uses clearly labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) that each earn their place. Slightly long but efficiently organized with zero filler; the docs link consolidates the full contract rather than inlining it.

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

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

An output schema exists, so return values need not be spelled out. The description covers the input contract, workflow dependencies, sibling disambiguation, and points to a docs URL for the full output/error contract. For a read-only two-parameter tool this is nearly complete, with only the error behavior deferred to the external docs.

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

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

Schema description coverage is 100% — both date (YYYY-MM-DD format) and response_format (markdown/json enum with default) are documented in the schema. The description's INPUT CONTRACT note ('date string only') reinforces but does not add semantic detail beyond what the schema already provides, so the baseline 3 applies.

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

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

The description states a specific verb (derives), resource (Lo Shu three-by-three frequency grid), input source (birth-date digits), and the analytical outputs (planes, missing/repeated digits, per-digit traits). It also explicitly names two sibling tools it should not be confused with, which sets it apart from the dozens of numerological 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?

The 'DO NOT CONFUSE WITH' section explicitly routes the agent to asterwise_get_numerology_profile for letter-based Western numbers and asterwise_get_name_correction for spelling harmonics. The INPUT CONTRACT states the sole accepted input (date string) and that validation is handled upstream, giving clear when-to-use and when-not-to-use guidance.

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

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

Annotations already cover read-only, idempotent, non-destructive, closed-world behavior, so the bar is lower; the description adds the useful disclosure that name and date are forwarded upstream without local checks (no client-side validation). It does not describe rate limits or error behavior, deferring those to an external doc link.

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 first sentence carries the entire payload summary, followed by clearly labelled WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE sections. Every line maps to a decision the agent must make; nothing is redundant padding.

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

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

Coverage is complete for a read-only, closed-world tool with an output schema: purpose, output fields, workflow ordering, sibling disambiguation, and an input-handling caveat are all present. Remaining detail (error contract) is deliberately delegated to a documentation URL.

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 baseline would be 3, but the INPUT CONTRACT line adds meaning beyond the schema by stating the parameters are passed through without local validation. It stops short of adding format or edge-case guidance for name/date beyond what the schema already says.

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 ('Fetches condensed lucky-number guidance') and enumerates the payload (primary/secondary picks, power number, interpretation, date_specific flag). It explicitly separates itself from asterwise_get_numerology_profile and asterwise_get_number_meaning, so an agent can identify it 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?

Explicit workflow block says BEFORE: None — standalone, and AFTER: numerology_profile if deeper context is required. The DO NOT CONFUSE WITH section names two siblings and states the distinguishing condition for each, leaving no routing ambiguity.

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 real value beyond that: it discloses the deterministic dependency on two other numbers and that the prerequisite profile call is recommended before interpreting the sum. It does not cover error behavior inline, deferring to an external docs URL.

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 what and the why, then cleanly sectioned into workflow, input contract, and disambiguation — no sentence is filler. The external 'full output and error contract' URL is of limited use to an agent at call time and is the one slightly wasteful element.

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

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

With an output schema present, annotations covering the safety profile, and 100% parameter coverage, the description supplies everything else needed: derivation, prerequisites, and sibling disambiguation. Nothing required for a correct call is missing.

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

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

Schema description coverage is 100%, so all three params are already documented, which sets the baseline at 3. The INPUT CONTRACT restates name and date with an example but omits response_format entirely, and adds no syntax or format meaning beyond what the schema already says.

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 (calculates), the exact resource (Maturity number), the derivation formula (Life Path + Expression, reduced to a single digit or master number), and the interpretive meaning. An agent can distinguish it from the ~90 sibling numerology/astrology tools 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?

Explicit workflow guidance (BEFORE: recommended asterwise_get_numerology_profile to confirm Life Path and Expression; AFTER: None) plus a DO NOT CONFUSE section naming two siblings and why. It stops short of an explicit 'use this instead of X when you only need the number' statement, leaving that inference to the agent.

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

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

Annotations already establish that this is a read-only, idempotent, non-destructive, closed-world operation. Beyond that, the description discloses the actual computation behavior: which nakshatra, tithi, weekday, seasonal-ban, and inauspicious-period rules are applied, that results are scored 0-100 with reasons, and that excluded_minutes explains an empty result.

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?

Despite being detailed, the description is well structured with a front-loaded purpose sentence followed by WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE sections. For a tool with many nested parameters and close siblings, every section adds useful routing or contract 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?

The tool has an output schema, so the description need not document return values. It still covers scope, activity rules, required and optional inputs, workflow dependencies, sibling distinctions, scoring behavior, and empty-result behavior, making it complete enough 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 100%, so the baseline is 3. The description adds organizational clarity by separating required fields from optional ones and summarizing the participant alternatives, but it also omits some optional schema fields such as ayanamsa and response_format, and much of its input contract repeats schema descriptions.

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

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

The first sentence gives a precise verb, resource, scope, and output format: it finds auspicious time windows for a named activity between two dates at a location, returning ISO start/end times. It explicitly lists supported activities and distinguishes itself from the closest siblings with a DO NOT CONFUSE section.

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 WORKFLOW section states when to call asterwise_geocode before this tool and asterwise_get_panchanga after it. The DO NOT CONFUSE section names the two most likely alternative tools and explains their different purposes, leaving no ambiguity about when to select this 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 read-only, idempotent, closed-world and non-destructive traits, and the description goes further: it documents input normalization (case, spaces, hyphens, romanisation variants), the exact failure mode (404 listing the 27 valid names), and near-miss suggestions. That is behavioral detail beyond what annotations carry.

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 purpose sentence followed by clearly labelled WORKFLOW, INPUT CONTRACT and DO NOT CONFUSE sections. No redundant restatement of the name or title, and the docs link is a compact pointer to the full contract.

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

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

An output schema exists so return values need not be described; the description instead covers the error contract, matching semantics, and routing against siblings. For a two-parameter read-only lookup this is complete enough to invoke 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% and the enum for response_format is self-explanatory, so the baseline would be 3. The description adds real value by explaining the accepted name variants and matching behavior ('Moola', 'Krithika', hyphens/spaces ignored), which the schema's short example does not convey.

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

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

States a precise verb ('looks up') and resource ('static metadata for one of twenty-seven nakshatras by name') and enumerates the returned data categories. The DO NOT CONFUSE section distinguishes it explicitly from get_natal_chart and get_dasha, so an agent can differentiate 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 declares the tool is standalone with BEFORE/AFTER None, and names two sibling tools it should not be confused with, including the reason for each. It does not, however, contrast against the closest sibling, get_nakshatra_prediction, which is the more plausible confusion.

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