Asterwise

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

Annotations already declare read-only, idempotent, non-destructive behavior, so the bar is lower. The description adds meaningful behavior beyond that: formatting noise is ignored, only digits contribute, country code digits are included in the reduction sum, and the output is harmonic scoring plus interpretive copy. A doc link supplies the full output/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?

The description is compact and uses labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE) to front-load the most important routing and input information. Every sentence earns its place, and the docs link is an appropriate terminal reference.

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

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

For a read-only numerology analysis tool, the description covers what the tool does, how inputs are normalized, which sibling to use before it, which siblings to avoid confusing it with, and where to find the full contract. An output schema and annotations handle return shape and side-effect safety.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by clarifying input normalization and reduction semantics: formatting noise is ignored, only digits contribute, and country code digits are included in the reduction sum—details not inferable from 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 opens with a specific transformation: digit-stripping a mobile string, reducing it with the owner's name and birth date, and returning harmonic scoring plus interpretive copy. It also names two sibling tools it should not be confused with, making its domain distinct.

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

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

A WORKFLOW section recommends anchoring with asterwise_get_numerology_profile before judging the line, and the DO NOT CONFUSE WITH section explicitly excludes vehicle plate and business-name analysis by contrasting their rules. This gives an agent clear routing between this tool and near-neighbor siblings.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior, so the description only needs to add context beyond those. It does: current-day pinning, output components (intensity, upcoming cycles, historical rows), and a link to the full output/error contract. This goes beyond minimal safety disclosure, though it could still mention rate limits or auth requirements explicitly.

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 tightly organized into labeled sections: WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH. The main capability is front-loaded in one sentence, and the rest is scannable without redundancy. The external contract link is a reasonable substitute for listing every error code inline.

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 astrological tool with a detailed input schema, output schema, and full annotations, the description covers what an agent needs: workflow order, sibling alternatives, current-date behavior, output shape, and a fallback link for detailed contracts. No crucial decision factor appears missing.

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

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

The input schema already documents all parameters with 100% coverage, including defaults, formats, and enums, so the baseline of 3 applies. The description adds the important 'no explicit query date' constraint and references the BirthData global contract, but it does not need to re-explain the schema's parameter details.

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

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

The description opens with a specific verb and resource: 'Evaluates Saturn's seven-and-a-half-year Moon-sign cycle phases against natal data for the current day and returns intensity, upcoming cycles, and historical rows.' This clearly separates it from generic transit tools. The 'DO NOT CONFUSE WITH' section names asterwise_get_gochar and asterwise_get_transits and explains exactly how they differ.

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

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

Usage guidance is explicit and structured: it recommends calling asterwise_get_natal_chart before, suggests asterwise_get_gochar after, and says when not to use this tool in favor of get_gochar or get_transits. The INPUT CONTRACT also states that no query date should be supplied because the API pins to the current day.

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, and non-destructive behavior. The description adds useful behavioral context beyond that: letters and separators are ignored, reduction uses only numeric digits, the output schema matches mobile analysis, and a full output/error contract link is provided. It doesn't discuss auth or rate limits, but those are not salient for this read-only tool.

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

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

The core behavior is front-loaded, and the WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH sections are clearly labeled and scannable. It is longer than the minimal case, but every section earns its place and no content is redundant.

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

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

With comprehensive annotations, 100% schema coverage, an existing output schema, and a link to the full contract, the description covers input normalization, parameter participation, workflow, and sibling differentiation. A direct 'use this when...' trigger would strengthen it, but the alternative routing already implies the intended use case.

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 adds high-level context that name and birth date participate in the reduction and that non-digits are stripped, but it does not give parameter-by-parameter detail beyond the already rich schema. No compensation is needed.

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

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

The opening sentence uses specific verbs and resources: it strips non-digits from a vehicle registration token, reduces the numeric run with owner name and birth date, and returns the same harmony schema as mobile analysis. The 'DO NOT CONFUSE WITH' section explicitly names sibling tools and what they examine, making 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 states a recommended preceding tool and notes that no follow-up is needed. The 'DO NOT CONFUSE WITH' section explicitly routes to asterwise_check_mobile_number for phone digit rules and asterwise_get_business_name_analysis for business Expression, 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 declare readOnlyHint=true and destructiveHint=false, but the description adds materially useful behavioral context: cryptographic randomness via secrets.SystemRandom, complete independence with no session state, uniqueness of drawn cards, local range validation with MCP INVALID_PARAMS, and the independent 50% reversal probability. No statement in the description contradicts 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 detailed but tightly structured into WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH sections, with the core behavior front-loaded in the first sentence. Every section earns its place, and the documentation link closes any remaining output or error questions.

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?

Together with the full input schema and the presence of an output schema, the description covers invocation arguments, validation behavior, the interpretation of drawn cards via active_meaning and active_keywords, and disambiguation from nearly 100 sibling tools. Nothing critical 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?

Schema coverage is 100%, yet the description still adds significant meaning beyond the schema: count's valid 1–78 range, default, concrete usage examples, and rejection behavior; allow_reversed's independent 50% cryptographic chance. This goes well beyond the schema's one-line property descriptions.

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

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

The description opens with a precise action: 'Draws N unique random cards from the 78-card deck using cryptographic randomness.' It clearly specifies the resource, the verb, and the uniqueness constraint, and the 'DO NOT CONFUSE WITH' section names sibling tools with their different behaviors, making differentiation immediate.

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 dedicated 'DO NOT CONFUSE WITH' section explicitly contrasts this tool with asterwise_get_tarot_card_of_the_day, asterwise_get_tarot_three_card_spread, and asterwise_get_tarot_celtic_cross, explaining why each is different. It also states the standalone workflow with BEFORE and AFTER sections, leaving no ambiguity about when to invoke it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context beyond that: supported number formats, a standalone workflow with no dependencies, and a link to the full output and error contract, which partially covers error/edge-case behavior.

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

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

The description is well-structured and front-loaded: the core action appears first, followed by compact labeled sections for workflow, input contract, exclusions, and documentation. Each section earns its place, and the 'DO NOT CONFUSE WITH' block is especially efficient for agent disambiguation.

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 parameters, one required, an output schema present, and simple flat structure, the description is complete for an agent to call the tool correctly. It covers supported inputs, shows examples, explains the difference from related siblings, confirms no prerequisites, 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 coverage is 100%, so the schema already documents both parameters and the response_format enum. The description adds value by enumerating the exact supported angel number patterns (000, 111–999, 911, 1010, 1111, 1234, etc.) and providing additional examples like '444' and '911', which clarifies the intended input beyond the schema's generic 'as seen' wording.

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: 'Lookup the meaning of a specific angel number by its sequence.' It also explicitly distinguishes itself from three sibling tools in the 'DO NOT CONFUSE WITH' section, so an agent can reliably separate it from number_meaning, angel_number_today, and angel_number_personal.

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

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

The description gives clear when-to-use guidance by listing the exact supported sequences, and it names alternatives with the conditions that select them: today's collective daily number, personal angel number from birth date, and Pythagorean numerology for 1–33. This is explicit routing information rather than leaving usage up 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=true and idempotentHint=true, covering the safety profile. The description adds genuine value beyond the annotations: the internal computation logic (Pythagorean Life Path base, triple vs quadruple digit mapping) and a link to the full error contract. It doesn't detail edge-case error behavior, but the output schema and docs link fill that gap.

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

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

The description uses labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) and front-loads the core computation. Every sentence carries distinct information — the mapping rules, the recommended pre-call, the parameter contract, and sibling disambiguation — with no filler or repetition.

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

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

For a 3-param read-only tool with an output schema, the description covers the algorithm, a recommended pre-call, the input contract with an example, disambiguation from two closely related siblings, and a pointer to the full output/error contract. 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 all three parameters. The description adds a concrete date example ('1994-03-31') and clarifies that date means birth date, but the name parameter description largely repeats the schema's wording and response_format is handled entirely by the schema. This is the baseline-3 case where structured data does the heavy lifting.

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

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

The description opens with a specific verb and resource: 'Computes a personal angel number from a birth date using the Pythagorean Life Path as the base.' It then pins down the exact behavior with the mapping rule (Life Path 1-9 → triple sequence, master numbers 11/22/33 → 1111/2222/3333), making the tool's identity unambiguous even among ~100 siblings.

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

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

There is an explicit WORKFLOW section ('BEFORE: RECOMMENDED — asterwise_get_numerology_profile — confirm Life Path before calling') and a DO NOT CONFUSE WITH section that names asterwise_get_angel_number_today ('collective daily number from today's date, not birth date') and asterwise_get_numerology_profile ('full Pythagorean profile; this tool extracts only the Life Path → angel sequence mapping'). Selection conditions are explicit and actionable.

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

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

Annotations already cover read-only, idempotent, non-destructive traits. The description adds useful behavioral context beyond annotations: the date is used automatically, no parameters are required, and the computation/reduction logic is spelled out. A link to the full output/error contract covers remaining 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 front-loaded with the core behavior and keeps each section purposeful: algorithm, workflow, input contract, disambiguation, and documentation link. No filler or repetition of annotation values.

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

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

For a zero-required-parameter, read-only tool with an output schema, the description covers computation, standalone usage, sibling differences, and points to a full contract. 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% for the single response_format parameter, and the schema already explains markdown vs json. The description adds no parameter-specific meaning, but the baseline of 3 applies because the schema carries the full burden for the only parameter.

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

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

The description opens with a precise verb and resource: 'Returns today's angel number computed from the current date.' It adds the exact algorithm (sum digits, reduce to 1-9, triple it) and explicitly distinguishes the tool from asterwise_get_angel_number and asterwise_get_angel_number_personal, so an agent can tell it apart.

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

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

The WORKFLOW section declares 'BEFORE: None — standalone' and directs the agent to asterwise_get_angel_number_personal after this tool when a personal number is needed. The DO NOT CONFUSE WITH section names the two sibling alternatives and the exact condition that selects them, so when-to-use vs alternatives is explicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavioral context: what is computed (bindu matrices, reductions, sarva totals), how it fits into transit analysis, and a link to the full output/error contract. It does not over-promise or contradict 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 into clear, labeled sections and every section serves a purpose: workflow, input contract, and sibling disambiguation. The uppercase labels add structure but are slightly noisy, and the repeated mention of asterwise_get_gochar in workflow and disambiguation is minor redundancy. Overall it is tight and front-loaded.

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

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

Given the rich input schema, output schema, and annotation coverage, the description is complete enough for an agent to select and invoke the tool correctly. It covers workflow placement, input constraints, sibling differentiators, and points to the full contract via the documentation link. Nothing essential for correct 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?

Schema description coverage is 100%, so the input schema already documents all parameters comprehensively. The description's 'INPUT CONTRACT: BirthData only' adds minor clarifying context, but it does not materially extend the parameter semantics beyond what the schema provides. 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 and resource: 'Computes full Ashtakavarga bindu matrices, trikona and ekadhipatya reductions, and sarva totals from BirthData for transit support analysis.' This clearly differentiates the tool from siblings via the 'DO NOT CONFUSE WITH' section, naming asterwise_get_chart_strength and asterwise_get_gochar explicitly.

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

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

The WORKFLOW section provides explicit before/after guidance: recommend asterwise_get_natal_chart before and asterwise_get_gochar after. The 'DO NOT CONFUSE WITH' section explicitly names alternatives and explains why they are different, and 'INPUT CONTRACT: BirthData only' sets clear invocation constraints.

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

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

Annotations already mark the tool as read-only and idempotent; the description adds the critical behavioral contract: periods appear under data.periods.root[] rather than data.periods[], dates are DD/MM/YYYY, and levels are validated locally before the API call. It also points to a full output/error contract, making runtime behavior predictable.

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 front-loaded purpose and clear bolded sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE). It is slightly redundant, repeating the data.periods.root[] and DD/MM/YYYY details in both the opening line and INPUT CONTRACT, but every section still contributes.

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 dasha tool with nested input, three parameters, and many astrological siblings, the description covers workflow, input constraints, output location/date format, and disambiguation from two near neighbors. The output schema carries return-value details, and a link supplies the full error contract, so nothing essential 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; the description adds value by pinning levels to 1–5, cross-referencing asterwise_get_dasha's level semantics, and stating local enforcement. This is more than the schema alone provides, though birth and response_format are already fully documented there.

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: 'Computes the 108-year Ashtottari Dasha tree' with configurable depth and output path. It explicitly differentiates itself from asterwise_get_dasha and asterwise_get_yogini_dasha by system, length, and response shape.

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 a recommended preceding tool (asterwise_get_natal_chart) and an optional follow-up (asterwise_get_dasha) for Vimshottari comparison. The DO NOT CONFUSE WITH section names the alternatives and the exact conditions that distinguish them, so an agent can select the right tool without 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 carry the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false). The description adds useful behavioral context beyond that: it is a standalone reference returning all four systems in one call, and it links to the full output/error contract. 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?

Purpose is front-loaded in one sentence, followed by compact labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) and a docs link. Each section earns its place with no filler or redundancy.

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

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

For a simple two-optional-param lookup tool with an output schema and safety annotations, the description covers purpose, workflow context, input contract, sibling differentiation, and points to the authoritative output/error contract. Nothing needed 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% — both date and response_format are fully documented with format, default, and enum values. The description largely restates the date contract from the schema and does not materially add parameter-level meaning, so the baseline 3 applies.

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

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

Opens with a specific verb+resource+scope: 'Returns ayanamsha values for all four supported systems (Lahiri, Raman, KP, Tropical) for a given date.' The DO NOT CONFUSE WITH section further disambiguates it from asterwise_get_natal_chart and asterwise_get_western_natal, so an agent can distinguish it from siblings 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?

Provides explicit when-not guidance: asterwise_get_natal_chart 'applies Lahiri ayanamsha automatically to natal positions' and asterwise_get_western_natal 'uses tropical zodiac (ayanamsha = 0).' The WORKFLOW section also declares it a standalone reference with no before/after dependencies, leaving no ambiguity about when to invoke it.

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

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

Annotations already cover readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is known. The description adds valuable algorithmic behavior: first-letter selection, Pythagorean values, summing and reduction, plus worked examples and a link to the full output/error contract. No hidden behavioral concerns are apparent.

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

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

The description is well-structured with a one-sentence summary, WORKFLOW, INPUT CONTRACT, examples, and sibling disambiguation. Every section earns its place, and the core algorithm is front-loaded. The length is justified given the large sibling tool set.

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?

Together with annotations and the output schema, the description covers naming rules, reduction behavior, standalone status, disambiguation from relevant siblings, and a documentation link for the full contract. Nothing critical for correct 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?

Schema coverage is 100% for both parameters, so the baseline is met. The description goes beyond the schema by specifying that the name should be the full legal name as used at birth and that each space-separated part contributes exactly one initial, with concrete examples. The response_format parameter is sufficiently documented by 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 'Calculates the Balance number from the first letter of each name part, using Pythagorean values' — a specific verb, resource, and method. The DO NOT CONFUSE WITH section distinguishes it from asterwise_get_expression_number and asterwise_get_karmic_lessons, making its unique purpose clear.

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

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

The WORKFLOW section clearly says the tool is standalone with no before/after steps, and the INPUT CONTRACT defines how to format the name. DO NOT CONFUSE WITH names relevant siblings and explains the key difference in letter usage, but there is no explicit 'use this when...' directive, so it falls just short of perfect guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so no side-effect disclosure is needed. The description adds meaningful context: it is standalone, computes three named cycles, has sensible date/day defaults, and points to a full output and error contract. It does not inline the error contract details, but for a read-only computation this is sufficient.

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 organized into clear labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) with no filler. The core function is front-loaded, and every sentence contributes either a default, a constraint, or a sibling distinction that helps the agent act 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 tool with one required parameter, fully described schema fields, an output schema, and safety annotations, the description is complete: it covers prerequisites (none), post-steps, defaults, exclusions, and a pointer to the full contract. Nothing necessary for correct selection or 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?

Schema description coverage is 100%, so the schema already documents every parameter; that sets a baseline of 3. The description adds extra value by restating the required/optional contract, calling out the 1-90 valid range for days (absent from the schema), and confirming defaults for target_date and days.

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

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

The opening sentence uses a specific verb ('Computes') plus a precise resource: physical, emotional, and intellectual biorhythm cycles with their period lengths (23/28/33 days). It also distinguishes itself from asterwise_get_nakshatra_prediction and asterwise_get_panchanga, making it easy to tell apart from the large sibling 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 section explicitly states 'BEFORE: None — standalone' and points to asterwise_get_nakshatra_prediction as a sensible AFTER step. The DO NOT CONFUSE WITH section names two siblings and the condition that selects them, giving the agent 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 declare readOnlyHint and idempotentHint, and the description adds non-obvious input behavior: special characters and digits are acceptable, non-letters are stripped per upstream rules, and no local validation is performed on name or date. It also provides a full output and error contract link, giving the agent a path for any remaining behavioral questions. There is no contradiction with the annotations.

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

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

The description is front-loaded with a one-sentence functional summary, then organized into labeled WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH sections. Each section contributes distinct information, and the length is justified by the large sibling set and the need to communicate input tolerances.

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 output schema, annotations, and the linked full contract, the description covers prerequisites, follow-up routing, input validation behavior, and alternatives. Nothing needed to correctly invoke the tool is missing, aside from the schema-level date required/default ambiguity noted under parameter semantics.

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 coverage, the schema already documents each parameter, so the baseline is 3. The description adds meaning by clarifying that date is the founder birth date and that business_name tolerates special characters/digits while non-letters are stripped. One caveat: the schema lists date as required while its own property description says it defaults to today when omitted, an internal ambiguity the description does not resolve.

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

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

The opening sentence names a specific operation (reduces), the resource (business name), the basis (founder birth date), and the outputs (thematic suitability lists, harmony score). The DO NOT CONFUSE WITH section explicitly separates it from asterwise_get_name_correction and asterwise_check_mobile_number, making it distinguishable from siblings 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 section states there is no prerequisite and names the AFTER tool (asterwise_get_name_correction) with the exact condition: if the entity is a person, not a brand. The DO NOT CONFUSE WITH section gives two explicit alternatives and their distinguishing use cases, so an agent knows when not 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful non-annotation context: input is 'forwarded as-is; no local validation,' the operation is standalone, and output includes specific analysis types. This is a meaningful supplement 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 core purpose is front-loaded, followed by compact labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) that each carry distinct value. The documentation link is included without padding. Every sentence earns its place.

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

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

Given the output schema exists, annotations cover safety, and the description covers workflow, input handling, sibling differentiation, and points to the full error contract, this is complete. An agent can correctly invoke and route this tool without external guessing.

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 adds the note that name and date are forwarded as-is with no local validation, which is mild extra context, but it does not enrich the meaning of individual parameters beyond what the schema already states.

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

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

The description opens with a specific verb-resource pair: 'Reduces a name and birth date through the Chaldean letter-value system and returns name, birth, and combined compound analyses.' It also explicitly names sibling tools it is not, such as asterwise_get_numerology_profile and asterwise_get_lo_shu_grid, making differentiation immediate and unambiguous.

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

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

The description provides a structured WORKFLOW section stating the tool is standalone, an AFTER suggestion for when to compare with Pythagorean cores, and a DO NOT CONFUSE WITH section that names two alternatives and explains why they differ. This gives an agent explicit routing criteria.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds valuable behavioral context beyond annotations: output includes ISO-dated Maha/Antar sequences and karaka mappings, and the period date format differs from asterwise_get_dasha. A link to the full output and error contract further discloses expected behavior.

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

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

The description is efficiently structured with clear labels: WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH. Every section adds distinct value—core function, sequencing, date-format caveat, and sibling disambiguation—without unnecessary repetition.

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

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

Given the tool's complexity, the description is complete: it states the operation, output shape, workflow, disambiguation from two related dasha tools, ISO date contract, and points to full documentation. With output schema, 100% parameter schema coverage, and safety annotations also present, nothing critical is missing for an agent 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%, and the input schema thoroughly documents birth fields, response_format, defaults, and constraints. The description adds only marginal parameter-relevant meaning, mainly clarifying that period dates in the output are ISO-formatted and that other parameters follow the BirthData global contract. This meets the baseline expectation but doesn't go 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?

Description states a precise verb and outcome: 'Computes Char Dasha from birth data and returns sign lords as period rulers with ISO-dated Maha and Antar sequences plus karaka mappings.' It clearly differentiates itself from sibling tools by naming asterwise_get_dasha and asterwise_get_yogini_dasha and explaining what they do instead.

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 guidance: use asterwise_get_natal_chart before for context and asterwise_get_dasha after for an optional Vimshottari cross-check. The 'DO NOT CONFUSE WITH' section explicitly tells the agent when not to use this tool and names the correct 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=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: it aggregates from BirthData only, has no extra toggles, and points to a full output/error contract. This goes beyond what annotations alone provide, though it stops short of describing the exact output shape or error modes.

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 WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH sections. Every sentence earns its place: the opening lists what is returned, the workflow sections guide sequencing, and the confusion section prevents mis-selection. It is longer than a one-liner, but the complexity of the tool 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?

Despite the high complexity of the astrological content, the description is complete for an agent: it lists the returned data bundles, gives workflow context, names the relevant alternative tools, states the input contract, and links to the full output/error contract. The output schema also exists, so the description does not need to explain return values in detail. Nothing critical 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 input schema fully documents birth and response_format, including nested fields and defaults. The description adds only the contract-level note 'BirthData only; no extra toggles,' which is marginally useful but not necessary given the schema's completeness. Baseline 3 is appropriate.

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

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

The description opens with a specific verb ('Aggregates') and enumerates the exact resources returned: Shadbala, Bhavbala, Vimshopaka with varga contributions, sixteen vargas, Ashtakavarga, karaka maps, and graha yuddha pairs. It also explicitly differentiates itself from similar siblings in the DO NOT CONFUSE WITH section, so an agent can tell it apart from asterwise_get_yogas and asterwise_get_ashtakavarga.

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 gives explicit before/after context: run asterwise_get_natal_chart before and asterwise_get_yogas after. The DO NOT CONFUSE WITH section states exact conditions for choosing alternatives, such as using asterwise_get_ashtakavarga when the full strength bundle is not needed. This is strong 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 declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds meaningful behavioral context by explaining the computation basis (sunrise/sunset at a location) and the returned slot attributes (quality, ruler, local clock bounds). It also links the full output and 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?

The description is well-structured with clear WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE sections, and the core sentence is front-loaded. The line 'All parameters are defined in the tool schema' is redundant and adds little value, keeping this 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?

The description is broadly complete: it covers workflow, sibling distinctions, result semantics, and provides a documentation link, with an output schema available. It loses a point because the location parameter's schema description is contradictory and the tool description does not explicitly clarify whether a place name is acceptable or only lat/lon/date are.

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 even with no parameter details in the description. The description adds only a restatement that LocationInput enforces date format and lat/lon ranges, while the schema's location property itself is internally ambiguous about a place-name alternative versus required lat/lon/date; the description does not resolve that ambiguity.

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

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

The description opens with a specific verb and resource: splitting a solar day into sixteen Choghadiya segments and labeling quality, ruler, and local clock bounds. It also explicitly distinguishes itself from asterwise_get_hora and asterwise_get_muhurta, so the agent can tell this tool apart from its closest 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 description provides a WORKFLOW section stating BEFORE and AFTER usage, including the optional follow-up with asterwise_get_rahu_kaal for an inauspicious band overlay. The DO NOT CONFUSE WITH section names alternatives and their key differences, giving clear routing guidance.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive, and the description adds useful behavioral context: scoring is computed upstream from the payloads, unknown midnight times are accepted without extra flags, and a full output/error contract is linked. The described behavior is consistent with the annotations.

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

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

The description is longer than average but uses labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) that are easy to parse, and the primary purpose is front-loaded in the first sentence. Every section adds distinct value with no filler.

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

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

For a high-complexity tool with nested BirthData inputs, the description covers prerequisites, related follow-up tools, input contract, sibling disambiguation, and points to a complete output/error contract; the output schema handles return-value specifics. Nothing essential for correct 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 has 100% coverage, so the schema already documents person1, person2, and response_format fully. The description adds the useful cross-reference that the two objects follow a global BirthData contract, but it does not materially extend the schema's parameter explanations.

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

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

The opening sentence names the exact operation ('Scores North Indian Ashtakoota / 36-point Guna Milan'), the resource (two charts), and the returned contents (koota breakdown, dosha flags, vetoes, mangal cross-check, narrative guidance). It is further disambiguated from the two most similar siblings, asterwise_get_dashakoot and asterwise_get_porutham.

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 explicitly tells the agent to call asterwise_get_natal_chart first for each person and optionally asterwise_get_papasamyam afterward, and the DO NOT CONFUSE WITH section names the alternatives that should not be used. This is explicit when-to-use and when-not-to-use guidance, not just a vague hint.

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, so the safety profile is covered. The description adds useful behavioral detail: case-insensitive matching, full detail including cautions, and a link to the output/error contract. It doesn't discuss invalid inputs or edge cases, but this is adequate for a read-only lookup with an 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 description is organized with clear section headers and front-loaded with the core purpose. Each section — workflow, input contract, disambiguation, documentation link — earns its place without unnecessary filler.

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

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

Given the tool's simple two-parameter interface and output schema, the description is complete: it covers prerequisites, input semantics, examples, sibling-tool differentiation, and points to the 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?

The schema's description for 'name' is mismatched (numerology-related text), but the description's INPUT CONTRACT corrects this by specifying 'Crystal slug or display name' and giving concrete examples. It also adds case-insensitivity. The response_format parameter is already well described in the schema, so the description doesn't need to repeat it.

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: 'Lookup a specific crystal by slug or name.' It clearly states what is returned (Vedic/Western planetary assignments, healing properties, safety cautions) and includes a DO NOT CONFUSE section that directly separates it from 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?

WORKFLOW explicitly states that no prerequisite is needed and that it can be used standalone or after asterwise_get_gemstone_recommendations. The DO NOT CONFUSE section names three alternatives and explains when each is appropriate, giving an agent unambiguous routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds valuable behavioral detail: results are sorted with primary Navaratna gems first, only Navaratna/Uparatna assignments are returned, and non-Vedic crystals are excluded. A docs link for the output/error contract further improves transparency.

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

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

The description is well-structured with clear sections: main behavior, workflow, input contract, and disambiguation. Every sentence serves a purpose, and the most important scoping information is front-loaded.

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

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

Given the tool's low parameter count, complete schema coverage, and presence of an output schema, the description is fully sufficient. It covers when to use it, what it returns, how results are sorted, valid input values, related workflows, and where to find 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%, so the schema already documents both parameters. The description adds value by enumerating the exact valid planet values in the INPUT CONTRACT, which is more specific than the schema's examples. It does not describe response_format directly, but the schema already fully explains that parameter.

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

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

The description clearly states the tool returns all crystals associated with a specific Vedic planet, with specific inclusion/exclusion criteria and sorting behavior. It is easily distinguished from sibling tools like asterwise_get_crystals and asterwise_get_gemstone_recommendations.

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 an explicit WORKFLOW section with recommended BEFORE and AFTER tools, plus a DO NOT CONFUSE WITH section naming alternatives and the conditions under which they should be used instead. This is excellent routing guidance for an 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 the tool as read-only, idempotent, and non-destructive. The description adds meaningful behavioral context beyond annotations: results are sorted by how many criteria match, at least one filter is required, and the follow-up workflow points to asterwise_get_crystal. It does not mention rate limits or auth, but those are not critical for this simple read-only tool.

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

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

The description is well-structured with clear sections for workflow, input contract, and disambiguation. It is front-loaded with the core purpose and retains useful detail. Minor redundancy exists because 'at least one filter is required' appears in both the opening paragraph and the input contract, but the overall structure is efficient.

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

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

Given the output schema, annotations, and full schema parameter coverage, the description is complete enough for an agent to select and invoke the tool correctly. It covers required input conditions, sorting behavior, follow-up workflow, sibling disambiguation, and points to a full output/error contract. Nothing essential 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 real value beyond the schema: it specifies that at least one of three filters is required, enumerates valid chakra values, gives examples for zodiac_sign and intention, and adds a max of 20 for limit that the schema does not state. The response_format parameter is left entirely to the schema, but that is acceptable given full schema coverage.

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

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

The description states a specific action and resource: it recommends crystals based on zodiac sign, chakra, or intention keyword. It also distinguishes itself from directly related siblings such as asterwise_get_crystal_by_planet and asterwise_get_gemstone_recommendations in the 'DO NOT CONFUSE WITH' 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 description gives clear when-to-use context with the standalone consumer-app workflow, and explicitly lists alternatives to avoid confusing with. It also states the required input contract, making it clear that at least one of zodiac_sign, chakra, or intention must be supplied.

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

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

Discloses that the tool internally computes the natal chart, eliminating a prerequisite, and warns that inaccurate birth time changes the Lagna and therefore all house lords and recommendations. It also implies the return shape by noting that a sibling lacks match_score and match_reasons, and points to a full output/error contract. Since annotations already declare readOnlyHint and idempotentHint, this description adds substantial behavioral context beyond them.

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

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

The description is long but well organized into labeled sections: WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH. The primary purpose is front-loaded, and every section earns its place given the large number of related sibling tools.

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 2-parameter nested-input tool with an output schema present, the description covers the before/after workflow, the input contract, the critical birth-time caveat, and sibling disambiguation. It also links to the full output and error contract, so an agent has everything needed 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 the baseline is 3, but the description adds a meaningful semantic warning: birth time is pivotal because it changes the Lagna and all house lords. It also confirms the Lahiri ayanamsa default. The phrase 'time (required)' slightly conflicts with the schema's optional/null default, but the intended meaning appears to be a correctness requirement rather than a field-required contract.

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: 'Recommends crystals from a Vedic natal chart using house lordship rules for gem selection.' It also asserts it is the only API that derives recommendations from a computed natal chart, and explicitly says it is not based on zodiac sign or chakra preference, clearly distinguishing 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?

Provides a WORKFLOW section with BEFORE/AFTER steps and explicitly says no separate natal chart call is required. The DO NOT CONFUSE WITH section names three alternative tools and the exact conditions that select each, including 'use this for reference, not prescription.'

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 behavior. The description adds valuable context beyond those: it returns exactly 50 records, sorted alphabetically, and enumerates all content categories (chakra, planetary assignments, healing properties, origins, affirmations, cautions). It also links to the full output and error contract, which covers error handling beyond what annotations provide.

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

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

The core behavior is front-loaded in the first sentence, followed by a concise list of included data. The WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH sections are clearly labeled and add distinct value. It is slightly verbose for a no-parameter tool, but every sentence serves a disambiguation or contract purpose, so it is not 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?

For a simple list endpoint with zero required parameters and full schema coverage, the description is complete: it states the exact result size and ordering, enumerates response content, names related tools, gives follow-up workflow, and points to the error contract. An agent has everything needed to decide when and how to invoke 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% — the only parameter, response_format, is fully documented with enum, default, and explanatory text. The description's 'No required parameters' reinforces the contract but doesn't add new meaning beyond the schema. Baseline 3 is appropriate because the schema carries the parameter documentation 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 opens with 'Returns all 50 crystals in the database sorted alphabetically' — a specific verb, resource, and scope. It also lists the detailed fields returned and explicitly differentiates itself from sibling tools via the 'DO NOT CONFUSE WITH' section, so an agent can clearly understand what this tool does.

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 there is no prerequisite and names the natural follow-up tool (asterwise_get_crystal_by_planet) for filtering by Vedic planet. The 'DO NOT CONFUSE WITH' section explicitly contrasts this catalogue tool with asterwise_get_crystal, asterwise_get_crystal_by_planet, and asterwise_get_crystal_recommendations, 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 mark the tool read-only and idempotent, and the description adds substantial behavioral context: response dates use DD/MM/YYYY rather than ISO, unknown birth time can make lagna-sensitive timing wrong even when '00:00' is accepted, and tree depth levels affect payload size. A full output and error contract URL is also provided.

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 longer than average but tightly organized with WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH sections, each earning its place. The core purpose is front-loaded, and the structured format makes it easy for an agent to scan and apply.

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 output schema exists and annotations cover safety, the description still supplies the missing contextual pieces: workflow sequencing, sibling-tool disambiguation, date-format caveats, and a link to the full output/error contract. This is a complete operating manual for the tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds genuine value beyond the schema: it clarifies the levels max of 5, warns about the DD/MM/YYYY date format in periods[], and explains the '00:00' birth-time edge case. This extra context pushes it above the 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?

The description opens with a specific verb and resource: 'Computes Vimshottari Dasha from birth data' and explicitly states the return shape: 'hierarchical period trees plus current Maha/Antar interpretation blocks.' It also names and distinguishes multiple sibling dasha tools, so an agent can identify this tool unambiguously.

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 explicitly recommends calling asterwise_get_natal_chart before and asterwise_get_dasha_transits after, giving clear sequencing guidance. The DO NOT CONFUSE WITH section lists three alternative dasha tools and their key differences, providing both when-to-use and when-not-to-use signals.

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, so the safety profile is covered. The description adds meaningful behavioral context beyond those hints by specifying the output shape — score, percentage, boolean dosha flags, and supplementary diagnostics — and by directing the agent to the full output/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?

The description is compact despite its information density. The first sentence delivers the core purpose, and the WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH sections each carry decision-relevant guidance. The documentation link provides an escape hatch without bloating the description.

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

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

Given the output schema exists and the annotations cover safety, the description fills the remaining gaps: workflow ordering, sibling differentiation, input contract shape, and a link to the full output/error contract. An agent has everything needed to decide on and invoke 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 input schema already documents person1, person2, and response_format thoroughly, including defaults, formats, and constraints. The description's reference to 'Two BirthData objects per global contract' reinforces the core requirement but does not materially expand on 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 opens with a specific verb and resource: it computes the ten-koota Dashakoot grid, converts it to a ten-point score with percentage, and exposes boolean dosha flags plus diagnostics. It also explicitly distinguishes itself from asterwise_get_compatibility and asterwise_get_porutham, so an agent can tell it apart from nearby 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 WORKFLOW section states a recommended prerequisite (asterwise_get_natal_chart) and an optional follow-up (asterwise_get_papasamyam), giving explicit temporal context. The DO NOT CONFUSE WITH section names concrete alternatives and the exact reason they are not interchangeable, leaving little ambiguity about when this tool is appropriate.

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

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

Annotations already cover the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the description's burden is lower. It adds genuinely useful behavioral context beyond annotations: 'today' is fixed by the API, unknown birth time handling follows a global contract, and a full output/error contract is linked. The 'time=00:00 accepted without detection' phrasing is mildly confusing next to the schema's 'never pass 00:00 for unknown', but it does not contradict 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 core purpose is front-loaded in the opening sentence, followed by labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) that make the content easy to scan. Although roughly 120 words, the length is earned: this tool sits amid three near-identical siblings, and the doc link at the end avoids inlining the full error 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-value details need no further elaboration. The description covers every other selection and invocation need: what the tool computes, what to run before and after, the fixed-today input quirk, sibling differentiators, and a link to the full output/error contract. Nothing an agent needs to correctly select and invoke this tool is missing.

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

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

Schema description coverage is 100%, so the schema already documents every parameter in detail, warranting a baseline of 3. The description adds value by explaining why there is no date parameter ('today' is fixed by the API), which prevents an agent from searching for a nonexistent field, and by pointing to the global BirthData contract for shared conventions. This goes modestly beyond the schema without duplicating it.

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: 'Combines active Vimshottari lords with today's transits and returns scored correlations plus transit longitudes and houses from Moon and Lagna.' It is fully distinguishable from siblings because the DO NOT CONFUSE WITH section names three lookalikes (asterwise_get_gochar, asterwise_get_transits, asterwise_get_dasha) and states exactly what each one lacks relative to this tool.

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

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

Provides explicit workflow guidance: BEFORE recommends asterwise_get_natal_chart and AFTER suggests asterwise_get_gochar, with a reason for each. The DO NOT CONFUSE WITH section gives exclusion criteria for three alternatives, and the INPUT CONTRACT explains the critical 'no date field — today is fixed' constraint an agent must know before calling.

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, so the bar is lower. The description adds useful behavioral context: the default returns all sixteen vargas, chart_type selection overrides that, and there is a recommended D1 anchoring workflow. It stops short of detailing error behavior, but the linked full contract covers that, and the output schema exists.

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

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

The description is well-structured with a front-loaded summary followed by WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH, and a documentation link. Every section earns its place, though the INPUT CONTRACT sentence about local Pydantic enforcement is slightly redundant with schema information and could be trimmed without losing 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 core purpose, the selection behavior, workflow prerequisites, sibling distinctions, and points to a full output/error contract. With an output schema present and a documentation link, an agent has enough to call the tool correctly. It doesn't describe return structure inline, but that gap is adequately covered by the output schema and linked 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%, so the schema already documents all parameters thoroughly. The description's chart_type notes ('pass chart_type for one varga, or omit for all sixteen') largely mirror the schema description and add little new semantic value. It does minimally reinforce the selection behavior, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('Computes') and resource ('divisional (varga) chart positions from BirthData'), immediately clarifies the single-chart vs all-sixteen behavior, and explicitly distinguishes the tool from sibling tools. An agent can tell this apart from asterwise_get_natal_chart and asterwise_get_chart_strength 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 description provides a clear workflow hint (BEFORE: asterwise_get_natal_chart to anchor D1) and a dedicated 'DO NOT CONFUSE WITH' section naming two siblings with precise differentiators (radix chart vs full varga dictionary; strength metrics vs primary payload). This is explicit 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds value beyond that: it discloses the silent midnight/unknown-birth-time behavior, summarizes the return structure, and links the full error contract. Minor deduction: the midnight note is slightly ambiguous against the schema's 'never pass 00:00 for unknown' rule, but it does not contradict 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 core purpose sentence is front-loaded, followed by clearly labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH, docs link). Every section earns its place with distinct information, and the labeled format makes it fast for an agent to scan for the guidance it needs.

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?

Rich annotations plus an output schema already cover safety and return shape; the description fills the remaining gaps: workflow sequencing, unknown-birth-time handling, sibling disambiguation, and a pointer to the full output/error contract. Nothing needed for correct 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?

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds only marginal param-related context (the global BirthData contract reference and the silent midnight edge case). At the high-coverage baseline of 3, the description does not need to compensate further.

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

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

The opening sentence names a specific verb ('Scores'), a precise resource ('twelve fixed dosha buckets'), and the output content (presence flags, typed detail objects, summaries, remedy lines). The 'DO NOT CONFUSE WITH' block explicitly differentiates it from asterwise_get_chart_strength (Shadbala/Vimshopaka metrics) and asterwise_get_compatibility (pair scoring with nadi_dosha), so an agent can distinguish it from near-neighbor siblings 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 section gives explicit sequencing guidance: run asterwise_get_natal_chart BEFORE and asterwise_get_remedies AFTER. The 'DO NOT CONFUSE WITH' section names alternatives and states why they are not the right choice (power metrics vs dosha booleans; pair scoring vs twelve natal buckets). This is the strongest form of usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavior beyond annotations: case-insensitive lookup, the shape of the returned interpretation, and context variants. It does not spell out error cases, but the docs link supplies the error contract, so the 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?

The description is front-loaded with the core purpose, then organized into labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE, docs) that each add value. No filler or repetition; the formatting makes the relevant contract information scannable for an agent.

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

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

For a simple read-only lookup with an output schema and strong annotations, the description covers the input contract, sibling differentiation, standalone workflow, and points to the full output/error documentation. Nothing critical is missing for an agent 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?

The input schema's description for 'name' is factually wrong for this tool—it describes a person's numerology name. The main description compensates by giving a clear INPUT CONTRACT with proper semantics ('Symbol slug or display name') and concrete examples. This added meaning is essential because the schema alone would mislead the agent. response_format is adequately covered by the schema enum.

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: 'Lookup a specific dream symbol by slug or name (case-insensitive).' It clearly distinguishes the singular lookup from the sibling listing tool via the 'DO NOT CONFUSE WITH' note, and states the return content (dual-tradition interpretation, Jungian archetype, Vedic meaning, etc.).

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

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

Explicitly frames the tool as standalone with 'BEFORE: None' and 'AFTER: None'. It warns against confusion with asterwise_get_dream_symbols, describing that sibling as the full database listing, which tells an agent when not to use this tool. The INPUT CONTRACT with examples makes the intended usage unmistakable.

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

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

Annotations already cover the read-only, idempotent, non-destructive nature of the tool. The description adds valuable behavioral context: it returns 500 symbols, spans 8 categories, offers dual-tradition interpretation, and supports optional filtering. It also points to a full output and error contract URL, going beyond what annotations provide.

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 prominent sections for workflow, input contract, and disambiguation. It front-loads the primary purpose and keeps each section scannable. Minor repetition of 'omit for all 500 symbols' exists, but the overall structure is clean and each section serves a clear navigational purpose.

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

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

Given the output schema exists and annotations cover the safety profile, the description provides everything an agent needs to invoke the tool correctly: what it returns, how to filter, how to proceed to the following detail tool, and where to find the error contract. No critical operational context is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds concrete value by enumerating the exact allowed category values (animals, nature, people, places, objects, actions, body, abstract), which the schema itself does not fully list. The response_format parameter is adequately described in the schema, and the INPUT CONTRACT reinforces the optionality of the category parameter.

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

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

The description uses a specific verb ('Returns dream symbols from the database') and clearly defines the scope: dual-tradition interpretations, 500 symbols across 8 categories, and optional category filtering. It explicitly names the sibling tool asterwise_get_dream_symbol as the single-symbol detail counterpart, so an agent can distinguish between them.

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

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

The WORKFLOW section states that this tool is standalone and that asterwise_get_dream_symbol should be used afterward for full detail on a specific symbol. The DO NOT CONFUSE WITH section explicitly differentiates this list tool from the singular detail tool, giving clear guidance on when to use which.

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

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

Annotations already establish safety (read-only, idempotent, non-destructive); the description adds the non-obvious per-part reduction method and master-number preservation rule, which affect interpretability. It also links to a full output/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 calculation, then organized into labeled WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH blocks. Each section adds actionable information without redundancy, and examples anchor the format.

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 schema, annotations, output schema, and the description's workflow/input/alternatives/error-contract link, an agent has everything needed to select and invoke the tool correctly. No critical dimension is left unexplained.

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 both parameters completely, but the description enriches the `name` parameter with legal-name-at-birth semantics, space separation requirement, case-insensitivity, and an alphabetic-character constraint. The response_format parameter is already fully 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?

The first sentence names the exact operation ('Calculates the Expression (Destiny) number'), the input ('full name'), and the method ('Pythagorean letter values'). It also explicitly distinguishes itself from sibling tools (soul urge, personality, numerology_profile, chaldean), so an agent can tell them apart 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?

The 'DO NOT CONFUSE WITH' section explicitly lists when not to use each alternative, and WORKFLOW states this is a standalone step with a prescribed AFTER tool. This gives the agent unambiguous selection criteria.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, and the description reinforces that this is a standalone read operation. It adds useful behavioral context beyond annotations: the fixed scope of 20 pan-Hindu festivals, the location-or-coordinates requirement, and a link to the full output/error contract. No contradiction with annotations exists.

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

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

The description is structured into scannable sections: purpose, workflow, input contract, and sibling exclusions. Every section carries useful information with no redundant prose, and the purpose is front-loaded before routing details.

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 large sibling list, the description provides enough routing via explicit alternatives and an upstream/downstream workflow. The presence of an output schema covers return values, while the external contract link fills error-handling details. 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 the baseline is 3. The description adds meaningful semantic grouping and constraints not fully captured in the schema, such as year range 1900-2100 and the requirement to provide either a location or latitude+longitude+timezone. It does not discuss response_format, but the schema already documents that parameter's enum and default.

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

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

The description opens with a clear verb ('Computes') and resource ('all major Hindu festival dates'), and lists concrete examples such as Makar Sankranti, Diwali, and Holi. The DO NOT CONFUSE section explicitly separates it from asterwise_get_panchanga_calendar and asterwise_get_muhurta, making it easy to distinguish among 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?

WORKFLOW states BEFORE: None and AFTER: asterwise_get_panchanga for detail, giving an explicit usage path. INPUT CONTRACT and DO NOT CONFUSE identify when this tool is appropriate versus alternatives such as the monthly full Panchanga or muhurta windows. This gives 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 establish a safe read-only profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), and the description adds meaningful context beyond them: the dependency on confirming the natal chart first, the composition of the output (primary, role-based, secondary, contraindications, safety note), and a pointer to the full output/error contract. 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 appropriately dense but highly organized with labeled sections: main purpose is front-loaded, followed by WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH, and a documentation link. Every sentence earns its place; there is no filler or repetition of schema content.

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

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

Given an output schema exists and the input schema covers 100% of parameters, the description supplies what an agent still needs: the tool's position in the workflow, sibling disambiguation, expected output categories, and an external link for the full output/error contract. Nothing essential 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?

Schema description coverage is 100%, so the schema fully documents the 'birth' object fields (date, lat, lon, time, ayanamsa, timezone, person_name) and response_format. The description's INPUT CONTRACT note ('BirthData follows the global contract') adds only marginal cross-tool consistency context, so the baseline of 3 applies.

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

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

The description states a specific verb ('Computes'), a clear resource ('Ratna-style gemstone picks and cautions from the natal chart'), and enumerates the returned content (primary/role-based stones, secondary options, contraindications, safety note). The DO NOT CONFUSE WITH section explicitly differentiates it from asterwise_get_remedies and asterwise_get_lal_kitab_remedies, so an agent can select it correctly among the large sibling list.

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

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

The WORKFLOW section gives explicit before/after guidance: run asterwise_get_natal_chart first to confirm the chart before wearing advice, and consider asterwise_get_remedies afterward for a broader programme. The DO NOT CONFUSE WITH section names two alternatives and states what they offer instead, 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=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context: Moon sign is computed from birth data, no external prerequisite is needed, and the output is static Ghatak parameters rather than a daily score. It also links to a full output and error contract, which further increases transparency.

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

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

The description is well-structured with short labeled sections: WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH. Each section contains only essential information, with no filler or redundancy. The front-loaded first sentence immediately communicates the tool's purpose, and the external docs link consolidates remaining details without bloating the description.

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

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

The description covers the tool's purpose, input requirements, computation basis, workflow position, alternatives, and links to a full output/error contract. Combined with the rich input schema, annotations, and output schema, there is no missing critical information for an agent 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%, and every input property already has a detailed description including formats, defaults, ranges, and enums. The description's INPUT CONTRACT restates the birth fields but adds conceptual value by noting that Moon sign is computed from birth data. It does not add much parameter-level detail beyond the schema, so the baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Returns the four Ghatak (inauspicious) timing parameters.' It also names the exact input basis (Janma Rasi / natal Moon sign), so an agent can understand what the tool produces and on what it is computed. The DO NOT CONFUSE WITH section explicitly differentiates it from asterwise_get_nakshatra_prediction and asterwise_get_panchanga, making sibling confusion unlikely.

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 that no prior tool is needed and recommends asterwise_get_nakshatra_prediction as a follow-up for daily auspiciousness. The DO NOT CONFUSE WITH section explicitly names two alternatives and explains why they are not this tool (daily Tarabala score vs static Ghatak parameters; panchanga elements vs Ghat Chakra lookup). This is 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 establish readOnlyHint, idempotentHint, and destructiveHint=false, so the description does not need to restate safety. It adds valuable behavioral context: target_date defaults to today, time='00:00' is accepted without unknown-time detection, and the output includes a roll-up summary. It also links to the full output/error contract, though it does not surface error semantics 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?

The description is well-organized with clear labeled sections: the one-line behavior summary, WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH. Every sentence contributes either selection guidance, invocation requirements, or output expectations — there is 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 tool with nested birth parameters, optional dates, output-format options, and many sibling tools, the description covers preconditions, disambiguation, input defaults, output contents, and a link to the full contract. The presence of an output schema means return-value details do not need to be spelled out here.

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

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

Schema description coverage is 100%, so the schema already documents all parameter meanings; baseline 3 applies. The description adds a little beyond the schema by noting the '00:00' handling nuance and pointing to the global BirthData contract, but it largely restates the target_date default already present 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?

The description opens with a strong verb and resource: 'Computes Gochar against the natal Moon and Lagna'. It then enumerates the specific return contents — per-planet transit longitudes, houses, AVK scores, vedha flags, and a roll-up summary — making the tool's function unambiguous. The 'DO NOT CONFUSE WITH' section sharpens differentiation 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?

The WORKFLOW section explicitly recommends running asterwise_get_natal_chart first and asterwise_get_dasha_transits after, giving concrete sequencing guidance. The DO NOT CONFUSE WITH section states exactly why asterwise_get_transits and asterwise_get_dasha_transits are different, so an agent can route between them without guessing.

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

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

Annotations already cover the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the description's job is to add behavioral context — which it does: computation is bounded between successive sunrises, each hour is tagged, and a 'current' hour is identified. It also defers the full output/error contract to a docs URL. This meaningfully enriches what annotations provide 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?

The core purpose is front-loaded in one dense sentence, followed by clearly labeled sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH) and a docs link. Every component earns its place — there is no filler or repetition of annotation data, and the labeled structure makes the content skimmable for an agent.

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 nested LocationInput schema, an existing output schema, and a large sibling family, the description covers everything needed to call correctly: purpose, output characteristics, workflow position, input rules, disambiguation from the two most confusable siblings, and a reference to the full output/error contract. No material gap remains for an agent selecting or invoking this tool.

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

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

Schema description coverage is 100%, so every parameter (date, lat, lon, timezone, response_format) is already documented in the schema. The INPUT CONTRACT line restates YYYY-MM-DD and bounded lat/lon, which adds little beyond schema constraints, though it usefully signals that a shared LocationInput contract applies. This meets the baseline for high schema coverage but adds no substantial 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?

The first sentence names a specific verb ('Builds'), a concrete resource ('the twenty-four planetary Horas between successive sunrises'), and the output shape (each hour tagged with ruler, quality text, and current status). The 'DO NOT CONFUSE WITH' section then explicitly separates it from asterwise_get_choghadiya and asterwise_get_natal_chart, so an agent can distinguish it from siblings 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?

The description is unusually explicit: WORKFLOW states there is no prerequisite ('BEFORE: None') and names the natural follow-up (choghadiya), while 'DO NOT CONFUSE WITH' gives the disambiguating conditions — sixteen segments vs twenty-four Horas, and natal analysis vs hourly muhurta tables. An agent is told both when to use this tool and when not to.

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, and the description adds useful behavior beyond that: it is AI-synthesised rather than calculated, returns metadata about the model and period, and response_format only changes rendering between JSON and markdown. It also links the full output/error contract. This goes beyond the structured annotation coverage without contradicting it.

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 labelled sections, and the key purpose is front-loaded. It is slightly verbose because it repeats the period enum values already present in the schema, but each section earns its place by adding workflow, exclusion, 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?

For a relatively simple read-only tool with an output schema, full schema coverage, and strong annotations, the description is complete. It covers workflow, alternatives, parameter constraints, output-format behavior, and points to the full output/error contract. Nothing critical is missing for an agent to select and invoke 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%, but the description adds meaningful detail: it lists all accepted Sanskrit and English moon sign names, clarifies that response_format only affects rendering, and confirms period is bounded by the schema enum. This enriches the parameter meaning 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 uses a specific verb ('Fetches') and resource ('AI-synthesised Moon-sign horoscope'), and clearly states it returns structured guidance fields plus metadata. It also differentiates itself from siblings in the DO NOT CONFUSE WITH section, so an agent can tell it apart from natal chart and transit 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 WORKFLOW section explicitly states this tool is standalone with no BEFORE step, and the AFTER step recommends asterwise_get_natal_chart for personalised needs. The DO NOT CONFUSE WITH section names concrete alternatives and conditions, making when-to-use versus when-not-to-use explicit.

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

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

Annotations already declare this as read-only, idempotent, and non-destructive. The description adds meaningful behavioral context beyond that: it explains the exact scan algorithm, provides a worked example showing how missing digits are derived, and links to a full output/error contract. It does not contradict 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?

Though longer than minimal descriptions, it is tightly organized into WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH, and documentation link sections. The front-loaded first sentence gives the core purpose immediately, and each section earns its place by aiding correct tool selection and invocation.

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

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

For a tool with 2 parameters, an output schema, and a large sibling list, this description is complete: it explains the algorithm, gives an example, names related tools, provides workflow context, and points to a full contract. The output schema covers return structure, so the description does not need to restate 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%, so the baseline is 3. The description enhances the 'name' parameter meaningfully by defining it as the full legal name at birth and walking through a concrete letter-to-digit mapping. The response_format parameter is not amplified, but the schema already documents its enum and default clearly.

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: 'Identifies karmic lessons by scanning all letter values in the full name and finding which digits 1–9 are absent.' It also clearly distinguishes itself from balance number and expression number in the DO NOT CONFUSE WITH section, which is essential given the large sibling 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?

Usage context is explicit: BEFORE states no prerequisites and AFTER recommends asterwise_get_numerology_profile. The DO NOT CONFUSE WITH section gives concrete decision criteria by explaining that balance number uses only initials and expression number reduces to a single digit rather than scanning for absent digits.

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 read-only, idempotent annotations, the description discloses important behavioral caveats: mismatched ayanamsa settings still post upstream, and time='00:00' is accepted without warning. It also warns to cross-check the birth record before trusting sub-lords, adding trust context not available in 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?

The description uses labeled sections with no wasted words: purpose, workflow, input contract, exclusions, and docs link. The most important operational caveats are front-loaded, and each sentence adds either capability, routing, or risk information.

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

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

Given the rich schema, annotations, output schema, and clear routing to sibling tools, the description leaves little ambiguity. The external link covers full output and error contracts without bloating the description itself.

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 real value by warning about the time='00:00' edge case and noting that ayanamsa settings are not enforced locally. It does not restate every parameter but meaningfully supplements the schema's own descriptions.

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

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

The description states a specific verb and resource: it 'Builds a KP natal chart with sub-lords on grahas and twelve cusps'. It clearly differentiates itself from asterwise_get_natal_chart and asterwise_get_kp_ruling_planets by naming what each lacks or provides instead.

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 gives before/after guidance, and the DO NOT CONFUSE WITH section explicitly names the sibling tools and why they are not substitutes. This tells an agent when to select this tool and when to avoid the 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=true, idempotentHint=true, and destructiveHint=false. The description adds important behavioral context beyond those annotations: the chart is instantaneous, 'now' is implicit on the server clock, no birth data is used, and the ruling_planets list is deduplicated. It also points to a full output/error contract, further increasing transparency.

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

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

The description is well-structured and front-loaded: the core purpose is in the first sentence, followed by compact labeled sections for workflow, input contract, and disambiguation. Every section earns its place, and the documentation link is included without 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 moderate-complexity tool with strong annotations, a complete input schema, and an output schema, the description covers what remains essential: standalone usage, follow-up tooling, the lack of a date parameter, the 'now' behavior, and links for full output/error details. An agent has enough context to select and invoke 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 adds value by explicitly narrowing the input contract to 'lat and lon only' and clarifying that no date parameter exists because 'now' is implicit on the server clock. This helps agents avoid inventing or supplying a date parameter, which the schema alone does not explicitly warn against.

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: 'Computes KP ruling planets for the instantaneous chart at lat/lon with no birth data' and lists concrete outputs (day lord, Moon/Ascendant lord chains, deduplicated ruling_planets list). It also explicitly distinguishes itself from asterwise_get_kp_chart and asterwise_get_prashna_chart, making sibling differentiation clear.

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

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

The WORKFLOW section states that the tool is standalone with no BEFORE step and names the AFTER tool (asterwise_get_kp_chart) for natal confirmation. The DO NOT CONFUSE WITH section explicitly names alternatives and explains why they should not be used instead, giving an agent clear routing guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful behavior beyond that: it states the output composition ('house tables plus planet-tier reverse indexes'), notes that values outside 1..12 are 'validated upstream only,' and links to the full output and error contract. This is strong context, though error specifics are deferred to the external docs.

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: purpose, WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH, and a docs link. The main sentence is front-loaded and efficient, and each section serves a purpose. Minor redundancy exists — the INPUT CONTRACT repeats house_number details already present in the schema — but it is not bloated.

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

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

Given that the tool has a nested birth object, an output schema, and three parameters, the description covers the essentials: what it computes, the recommended upstream call, the optional house_number behavior, exclusions from similar tools, and a link to the full output/error contract. There is no obvious gap that would prevent an agent from invoking 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, house_number, and response_format thoroughly. The description's INPUT CONTRACT mostly restates the schema ('house_number optional int; omit for all twelve') with only a small extra note about upstream validation. Since the schema does the heavy lifting, the baseline of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Computes KP significator chains for all houses or one optional house from BirthData and returns house tables plus planet-tier reverse indexes.' This clearly identifies what the tool does and its scope. The 'DO NOT CONFUSE WITH' section explicitly distinguishes it from asterwise_get_kp_chart and asterwise_get_natal_chart, making sibling differentiation strong.

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 gives an explicit prerequisite: 'BEFORE: RECOMMENDED — asterwise_get_kp_chart — establish cusps before significators.' The 'DO NOT CONFUSE WITH' section names alternatives and explains why they differ — kp_chart covers 'cusps and sub-lords, not tiered significator unions,' and natal_chart uses 'classical drishti matrices.' This gives an agent clear routing and sequencing 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 behavior, so the bar for the description is lower. The description adds useful context beyond those annotations: Lal Kitab is a distinct system, the chart includes Rin debt flags, and there is a documented full output/error contract link. It does not add operational details like rate limits, but that is not a gap 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 compact and well organized with purposeful sections: WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH. Every sentence earns its place by either clarifying scope, routing to the correct alternative, or pointing to the contract documentation.

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

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

The description is complete for tool selection and invocation: it defines the output, identifies the relevant workflow, disambiguates from the closest siblings, and links to the full output/error contract. Since an output schema exists, the description does not need to duplicate return-value details.

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

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

Schema description coverage is 100%, so the schema already documents every parameter including the nested birth object, timezone, ayanamsa, and response_format. The description only references the global BirthData input contract and does not add new parameter-level meaning, which fits the baseline-3 case.

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

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

The description states a specific verb and resource: it produces the Lal Kitab house/planet schema and Rin flags from BirthData. It also explicitly distinguishes Lal Kitab from standard Vedic computation, so an agent can tell it apart from related chart tools without inferring anything.

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 says it is standalone for Lal Kitab queries and names the AFTER tool for remedies. The DO NOT CONFUSE WITH section explicitly contrasts it with asterwise_get_natal_chart and asterwise_get_lal_kitab_remedies, 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 convey read-only, idempotent, and non-destructive behavior. The description adds useful behavioral context beyond annotations: it filters by stressed planets, returns priority tiers and typed action rows, and strictly accepts BirthData only. This gives agents a clearer model of what the tool does without contradicting 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 compact and sectioned with WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH labels. Every sentence provides actionable information, and the main purpose is front-loaded in the first sentence.

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

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

The description covers purpose, workflow, input contract, sibling-tool differentiation, and links to the full output/error contract. With an output schema present and detailed parameter schemas, 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 description coverage is 100%, so the input schema already documents all parameters thoroughly. The description adds an input contract ('BirthData only') but does not meaningfully elaborate on individual parameters beyond what the schema provides, meriting the baseline score.

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

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

The description uses a specific verb ('Lists') with a clear resource ('Lal Kitab style totkas') and source ('from BirthData'), and it specifies output characteristics (priority tiers, typed action rows). It also names sibling tools it should not be confused with, making differentiation explicit.

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

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

The WORKFLOW section explicitly recommends calling asterwise_get_lal_kitab_chart before this tool, and the DO NOT CONFUSE WITH section names asterwise_get_remedies and asterwise_get_gemstone_recommendations as alternatives with clear distinctions. This gives an agent concrete routing guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds behavioral value by specifying what the tool computes and annotates, and by referencing the full output and error contract, which goes beyond the structured 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 clearly labeled WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH sections. Every sentence carries operational value, and the primary purpose is front-loaded in the first sentence.

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

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

Given the output schema, annotations, and only two parameters, the description is complete for selecting and invoking the tool. It covers purpose, workflow, input contract, sibling differentiation, and provides a link to the full output and 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 schema already fully documents date and response_format. The description adds minimal extra parameter meaning beyond saying the input contract is a date string and that it is validated upstream, which is useful but not a major supplement to the schema.

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

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

The description states a specific verb and resource: it derives a Lo Shu three-by-three frequency grid from birth-date digits and annotates planes, missing or repeated digits, and per-digit traits. It also explicitly distinguishes itself from related sibling tools, so an agent can differentiate it from asterwise_get_numerology_profile and asterwise_get_name_correction.

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 when-not/alternative guidance in the DO NOT CONFUSE WITH section, naming two siblings and explaining why they are not substitutes. It also adds workflow context stating the tool is standalone with no before/after dependencies, making selection conditions 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, and destructiveHint, so the safety profile is fully covered. The description adds useful behavioral context beyond annotations: the payload is 'condensed', results include a 'date_specific' flag, and inputs are 'forwarded upstream without local checks,' which warns the agent that validation may be deferred. It also points to a full error contract via documentation, adding transparency about failure behavior.

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

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

The description is compact and effectively front-loaded: the opening sentence states the core function and output contents, followed by tightly scoped WORKFLOW, INPUT CONTRACT, and disambiguation sections. Every line adds decision-relevant information, with no filler or repetition of schema fields.

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

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

For a tool with only two required parameters, an output schema, and strong annotations, the description is complete. It covers what the tool returns, when to use it, how it relates to siblings, what validation does not happen locally, and where to find the full output/error contract. Nothing essential for invoking the 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 description coverage is 100%, with clear parameter descriptions for name, date, and response_format already present. The tool description does not significantly deepen parameter understanding; it mostly restates that name and date are used. The baseline of 3 is appropriate because the schema already carries the semantic load.

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 ('Fetches') and resource ('condensed lucky-number guidance') and enumerates the returned content: primary/secondary picks, power number, interpretation, and date_specific flag. It also explicitly contrasts itself with asterwise_get_numerology_profile and asterwise_get_number_meaning, so an agent can distinguish it from closely related 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 WORKFLOW section explicitly says there is no prerequisite ('BEFORE: None — standalone') and identifies when a sibling should be used instead ('AFTER: asterwise_get_numerology_profile — if deeper context is required'). The 'DO NOT CONFUSE WITH' section further clarifies exclusion conditions against two sibling tools, leaving no ambiguity about 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 the tool read-only, idempotent, and non-destructive, so the bar is lower; the description adds value by disclosing the calculation method (sum and master-number reduction) and the interpretive meaning of the result. It also links to the full output and error contract. It does not contradict any annotation, though it could have clarified how borderline master-number cases are handled for extra transparency.

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

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

The core computation is front-loaded in the first sentence, and the WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE sections make the content scannable. Some redundancy with the schema's parameter descriptions exists, but the examples and workflow notes justify most of 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 deterministic read-only calculation with an output schema, the definition covers the formula, prerequisite workflow, alternatives, input contract, examples, and a link to the full output/error contract. No essential selection or invocation information is missing; return-value details are already supplied by the output schema.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds useful semantic value by specifying name as 'Full legal name as used at birth', giving concrete examples, and framing date as the birth date in YYYY-MM-DD format. This goes slightly beyond the schema's own descriptions without being exhaustive about response_format, which the schema already covers.

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 — 'Calculates the Maturity number' — and gives the exact derivation: sum of Life Path and Expression numbers reduced to a single digit or master number. The 'DO NOT CONFUSE WITH' section explicitly separates it from asterwise_get_numerology_profile and asterwise_get_personal_cycles, so it is unambiguous among the 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 WORKFLOW block states a concrete prerequisite and a terminal state: 'BEFORE: RECOMMENDED — asterwise_get_numerology_profile' and 'AFTER: None'. The DO NOT CONFUSE WITH block names the alternatives and the exact conditions for preferring them, which is exactly the kind of routing guidance an agent needs.

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

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

Annotations already cover the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the bar for added value is met by disclosing that invalid activity slugs are NOT validated locally and surface as MCP INTERNAL_ERROR, and that date ordering/span rules are enforced upstream. These are genuinely useful non-obvious behaviors beyond what annotations convey.

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 efficiently sectioned (purpose, WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE WITH, docs link) with the core purpose front-loaded. Each section earns its place; the labeled headers make machine parsing easy. Slightly longer than minimal, but every sentence carries either a constraint, a routing decision, or an error-behavior disclosure.

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 domain tool with output schema present, nested location object, and ~100 siblings, the description covers purpose, workflow, input constraints, error behavior, sibling differentiation, and points to a full documentation contract. Minor gaps: the supported activity slugs are referenced but not enumerated, and the schema's location ambiguity (place-name vs. coordinates) is not fully reconciled in the description.

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 value beyond the schema by warning that activity must be one of the supported English slugs (not locally validated) and that date ordering/span rules are enforced upstream. It also notes LocationInput validation reuse for lat/lon/date, which helps an agent understand cross-tool consistency.

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

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

The opening sentence states a specific verb ('Searches'), a precise resource ('date span for top-scoring muhurta windows'), and the distinguishing scope ('named activity', 'at a location', using Panchanga/Choghadiya/siddhi flags). The DO NOT CONFUSE WITH section explicitly names two siblings and explains why they differ, so an agent can discriminate without inspecting 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?

The WORKFLOW section declares this tool is standalone (BEFORE: None) and routes to asterwise_get_panchanga afterwards, while DO NOT CONFUSE WITH names asterwise_get_choghadiya (enumerates all windows, no activity scoring) and asterwise_get_panchanga (single-day detail, not ranked search) as alternatives. This is explicit when-to-use and when-not-to-use guidance with named 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, and non-destructive behavior. The description adds meaningful context beyond annotations: the data is static, nakshatra_name is forwarded raw with no fuzzy matching or normalization, and the return payload includes interpretive, professional, activity, and body-map reference data. A minor gap is that the error contract is only linked, not summarized.

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

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

The core purpose is front-loaded in the first sentence, and the remaining sections are compact and labeled. WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE WITH all earn their place, and the documentation link prevents unnecessary duplication.

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

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

Given that an output schema exists, annotations cover safety, and the schema fully covers parameters, the description provides everything else an agent needs: exact-match behavior, output categories, sibling disambiguation, and a link 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 schema already documents both parameters. The description adds value by clarifying that nakshatra_name is passed exactly as provided with no local normalization, which is important for a lookup tool. It doesn't need to explain response_format since the schema covered its enum and default.

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

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

The description opens with a specific verb and resource: 'Looks up static metadata for one of twenty-seven nakshatras by exact name' and lists the return categories. It also names the sibling tools it is not, making it easy for an agent to distinguish it from asterwise_get_natal_chart and asterwise_get_dasha.

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 tells the agent when not to use this tool and names concrete alternatives: natal chart computation and dasha timing. The workflow section confirms it is standalone with no prerequisites or follow-up actions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context by stating the prediction is personalised and daily, that birth data computes everything needed, and by linking to a full output/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?

The description is well-structured with WORKFLOW, INPUT CONTRACT, and DO NOT CONFUSE sections. Each section carries distinct value, the core purpose is front-loaded, and there is no redundant or filler content.

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

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

Given the presence of a rich input schema, a full output schema, and annotations covering safety, the description provides the remaining needed context: workflow, exclusions, parameter defaults, and a link to the full output/error contract. Nothing necessary for correct tool selection or 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?

Schema description coverage is 100%, so the baseline is 3. The description's INPUT CONTRACT restates birth and target_date at a high level but omits ayanamsa and person_name from the birth object, and does not mention response_format; the schema itself fully compensates for these details.

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

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

The description opens with a specific verb+resource: 'Returns a personalised daily prediction using Tarabala and Chandrabala.' It also explicitly distinguishes this tool from asterwise_get_nakshatra_details, asterwise_get_panchanga, and asterwise_get_biorhythm, so an agent can clearly identify what this tool is and is not.

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 that no prerequisite tool is needed and recommends asterwise_get_panchanga afterward for full daily context. The 'DO NOT CONFUSE WITH' section names three sibling tools and explains exactly why they are not alternatives, giving the agent explicit routing guidance.

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

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

Annotations already establish the tool as read-only, idempotent, and non-destructive. The description adds meaningful behavioral context beyond that: it scores spelling against Life Path, returns alternate spellings with harmony metrics, echoes recommendation stub fields, and points to the full output/error contract. This is enough for an agent to predict the tool's behavior without over-relying on 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 labeled sections: main purpose, WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE, and a docs link. Every section earns its place by giving an agent actionable selection and invocation information without fluff or repetition.

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

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

The description covers the essential context: what the tool does, which tool to run before it, what inputs are valid, how it differs from close siblings, and where to find the full output/error contract. With an output schema present and only three parameters, this is a fully sufficient description for correct agent 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 the input schema fully documents all three parameters: name, date, and response_format. The description only reinforces that name and date strings are expected and says upstream validates, adding little semantic value beyond the schema. Baseline 3 is appropriate because the schema carries the load.

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

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

The description names a specific verb and resource: it scores a personal name's spelling against the birth-date Life Path and suggests alternate spellings with harmony metrics. It also explicitly distinguishes itself from two relevant siblings (asterwise_get_business_name_analysis and asterwise_get_chaldean_numerology), so an agent can confidently separate it from similar numerology 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 WORKFLOW section explicitly recommends running asterwise_get_numerology_profile before this tool and states there is no AFTER step. The DO NOT CONFUSE WITH section explains what this tool is not and how the named siblings differ, giving the agent clear routing guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description goes beyond this by disclosing that unknown birth time can be passed as '00:00' without error but that lagna-sensitive results become unreliable, and that the API does not flag this. It also links to the full output and error contract, adding meaningful behavioral context.

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

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

The description is well-structured with clear sections (WORKFLOW, INPUT CONTRACT, DO NOT CONFUSE, docs link) and front-loads the core purpose. It is somewhat dense and repeats validation details already present in the schema, but for a complex tool with nested parameters, the organization earns its length.

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

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

Given the tool's complexity, the description covers what the tool returns, workflow sequencing, the closest sibling alternative, a critical input caveat, and a link to the full output/error contract. An agent has enough context to invoke it correctly, apart from the time='00:00' contradiction noted above.

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. However, the description's INPUT CONTRACT states 'Unknown birth time may be entered as time='00:00' without error', which directly contradicts the schema's explicit instruction to 'Omit if unknown' and 'never pass "00:00" for unknown'. This is actively misleading and likely to cause incorrect tool invocation despite the high schema coverage.

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

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

The description opens with a specific verb and resource: 'Computes the full sidereal natal chart from BirthData' and enumerates the exact output components (planet rows, houses, aspects, arudhas, upapada, bhava cusps, avakhada metadata). It also explicitly distinguishes itself from asterwise_get_divisional_chart, so an agent can clearly separate this tool from its closest sibling.

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

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

The WORKFLOW section states this tool is standalone before, and recommends asterwise_get_yogas after, giving sequencing guidance. The 'DO NOT CONFUSE WITH' section explicitly names asterwise_get_divisional_chart and explains the difference, satisfying the when-to-use vs alternative requirement.

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 readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds meaningful behavior beyond that: the local guard restricting number to 1 through 33 and raising MCP INVALID_PARAMS before the HTTP call, plus the disclosure that extended fields are stubbed. This is useful contextual detail.

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 short labeled sections: workflow, input contract, disambiguation, and a link to the full contract. The main action is front-loaded, and each section earns its place. It is slightly verbose due to the workflow section, but the formatting keeps it scannable.

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

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

For a simple read-only dictionary lookup, the description covers the lone required parameter, its validation boundaries, the high-level output shape, and points to a full output/error contract. An output schema exists, so detailed return values do not need to be repeated. The description 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.