Rafid Intelligence Network

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

Adds meaningful behavior beyond the annotations: it returns a call identifier immediately while completion/duration arrive asynchronously, calls cost $0.30 USD, and an unpaid x402 call returns payment instructions instead of executing. It also flags the consent-aware/authorization framing. Annotations already cover destructive/idempotent/readOnly, so this extra context earns solid credit.

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

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

The purpose is front-loaded and the pricing/payment sentences are useful, but the 'Selection' sentence is a broken duplicate of the 'When' sentence, wasting space on a circular self-reference. Overall length is moderate but one sentence does not earn 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?

The output-schema existence means return values need not be re-explained, and the async note is a good touch. However, for a complex 6-parameter tool with 0% schema coverage and consent/safety inputs, the description leaves the entire input contract undocumented, which is a substantial completeness gap.

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

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

Schema description coverage is 0% across 6 parameters (including nested safety/context objects), yet the description adds nothing about phoneNumber format, objective, language, safety, context, or duration - it only says 'Input is a strict JSON object; see the schema.' With no schema prose at all, the description fails to compensate for the coverage gap.

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

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

States a concrete verb+resource: 'Initiate an authorized outbound AI telephone call and return a call identifier immediately', plus the async completion model. An agent can tell this places outbound calls. It does not differentiate from the sibling appointment_call_agent, which is a near-identical call-placement tool.

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

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

The 'When' clause gives loose conditions (authorized, lawful/consent-aware, must reach a customer by phone, structured result later), but the 'Selection' sentence merely restates that same clause nearly verbatim ('prefer for Use when an authorized agent...'), so it provides no real preference rule. No 'when-not' guidance and no differentiation from appointment_call_agent or voice_lead_qualifier.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), and the description layers on genuinely useful context the annotations lack: the tool returns evidence rather than a verdict, costs $0.35 per call, has no free preview, and an unpaid call returns x402 payment instructions rather than results. That payment/failure behavior is exactly what an agent needs before invoking a paid capability.

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 sentences are front-loaded and readable, but the 'Selection' clause is a verbatim duplicate of the prior 'When' sentence, which is pure waste. Pricing and payment mechanics take up roughly a third of the text, which is defensible for a paid tool but verbose.

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

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

With an output schema present, the description need not explain return values, and annotations cover the safety profile; the description sensibly covers purpose, when-to-use, the verdict caveat, and the payment model. The remaining gap is parameter-level guidance, which is missing entirely against 0% schema coverage for a four-parameter tool.

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

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

Schema description coverage is 0%, so the description carries the full burden, and it only partially discharges it. The enumerated signal categories map loosely onto the 'checks' enum values, but the 'company', 'country', and 'website' parameters are never explained, nor is the fact that all four are optional despite 'company' being the obvious subject of the analysis.

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 (gather) and resource (risk signals for a company) and enumerates the exact signal categories, which makes the scope concrete. It adds a real boundary with 'never a safe/unsafe verdict', but it never differentiates itself from the many near-identical siblings (company_due_diligence, business_risk_score, company_risk_report, company_reputation_check), so an agent cannot route between them from this text alone.

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

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

Explicit 'When' guidance ties the tool to pre-transaction / partnership / onboarding decisions, and 'not a substitute for compliance/legal sign-off' is a genuine when-not boundary. However, 'Selection: specialized; prefer for <verbatim repeat of the When sentence>' is a broken loop that names no actual alternative among the crowded risk-sibling set, so the guidance stops short of real disambiguation.

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, and the description adds genuinely new operational context: deterministic output, a $0.75 USD per-call price, x402 paid execution, and the fact that an unpaid call returns payment instructions rather than results. It does not mention latency, rate limits or what the signals actually contain beyond their names.

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

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

Front-loads the purpose well and pricing is clearly flagged, but the 'Selection: supporting; prefer for <verbatim repeat of the When clause>' sentence is a garbled duplication that wastes space, and 'Input is a strict JSON object; see the schema' is filler that defers rather than informs.

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

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

With an output schema present, return values need no explanation, and annotations carry the safety profile; the description covers purpose, usage context, payment model and input shape. The only real gap is routing against the many overlapping Oman/company-analysis siblings, which is left entirely unaddressed.

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

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

Schema description coverage is 0%, so the description must compensate and only partly does: 'evaluation purpose' and the supplier/customer/partner/investment-target phrasing loosely map to the purpose enum values, but general and investor are never explained, and companyId has no format or sourcing guidance beyond 'see the schema'.

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

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

States a specific verb and resource: 'Generate deterministic commercial-intelligence signals, risk flags and positive signals for one Oman company by companyId.' However, it never distinguishes itself from close siblings such as analyze_company_risk, due_diligence_oman_company or get_oman_company_profile, so an agent cannot tell which of the near-duplicates to pick from the sentence alone.

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

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

The 'When' clause gives clear context: use it to assess whether an Oman company looks like a serious, established operating business as supplier, customer, partner or investment target. There are no when-not conditions and the 'Selection: supporting; prefer for ...' sentence is a broken duplicate of the When text, so no alternative tool is ever named despite a very crowded sibling set.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description goes well beyond them: $0.25/call pricing, x402 paid-execution flow, unpaid calls returning payment instructions, a free preview_capability path, and caveats about data coverage with provenance/freshness metadata. This is rich operational context an agent needs.

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

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

Front-loads purpose then uses labeled sections (When/Selection/Do not use/Input/Price) that make scanning easy. The one long sentence listing partner-supplied sales records and provenance metadata is somewhat dense but still earns its place by signaling data provenance.

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 paid, complex 11-parameter analytical tool, it covers decision context, exclusions, pricing, preview routing, and payment behavior; an output schema exists so return values need not be described. The only material omission is any parameter-level guidance, which the schema does not compensate for at 0% coverage.

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

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

Schema description coverage is 0% across 11 parameters (5 required), and the description explicitly punts with 'Input is a strict JSON object; see the schema.' It hints at operating-cost analysis (mapping loosely to the two optional cost fields) and Al Mouj/Muscat for area, but explains no parameter formats, units, or required-vs-optional distinction, leaving the gap unfilled.

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 ('Analyze an Oman residential property') and enumerates the analytical dimensions (rental comparables, market context, investment metrics, sale-price positioning, operating costs). It clearly distinguishes itself from the generic analyze_property and property_investment_report siblings by being Oman/Al Mouj Muscat-specific.

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

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

Contains explicit 'When' (Oman rental/yield/sale positioning, especially Al Mouj Muscat), 'Selection' (primary; prefer for Oman-specific with local comparables), and 'Do not use' clauses (property outside supported Oman market, simple yield with supplied numbers). This is the full when/when-not/alternative structure.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds real value beyond that: 'Calculations only' (no live data fetching), a per-call price, x402 payment flow, and the fact that an unpaid call returns payment instructions instead of results.

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 and the When/Selection/Do-not-use framing is well structured. However, payment details are restated ('$0.01 USD per call' plus 'Full execution is paid per call via x402') and 'No free preview is advertised' is redundant filler that dilutes an otherwise tight definition.

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

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

An output schema exists, so return values need not be explained, and the behavioral/pricing context is complete. The gap is on the input side: a 7-parameter tool at 14% schema coverage with no parameter explanation in the description leaves required and optional field semantics underspecified for an arithmetic 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 only 14% across 7 parameters, so the burden falls on the description, yet it adds no meaning for propertyValue, annualRent, serviceCharge, vacancyRatePct, maintenanceCost, or otherAnnualCosts. It merely says 'Input is a strict JSON object; see the schema,' which offers no semantic help for the undocumented fields.

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

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

The description names a specific verb and a concrete set of outputs (gross/net rental yield, income, operating costs, simple payback) and currency (OMR), which clearly identifies the resource. It distinguishes scope from multi-property and market-comparable work, but does not explicitly separate itself from the very similar sibling analyze_oman_property, leaving some name-level ambiguity.

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

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

It gives an explicit 'When' context and a 'Do not use for...' exclusion covering live market comparables and portfolio screening, which is genuine routing guidance. It falls short of a full 5 because the alternative tools (compare_properties, portfolio_screen, analyze_oman_property) are described by category rather than named.

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 destructive=true, non-idempotent, non-readonly, so the safety profile is partly covered. The description adds substantial non-obvious behavior: the call is asynchronous, costs $0.50 per call, has no free preview, and an unpaid MCP call returns payment instructions. It stops short of explaining what the destructive 'cancel' action actually alters.

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

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

The opening sentence and the payment disclosure are efficient and front-loaded, but the 'Selection' clause duplicates the 'When' clause word-for-word, wasting roughly a third of the text on a templating artifact rather than new information.

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

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

The presence of an output schema means return values need not be described, and the payment/async behavior is covered. Still, for a 9-parameter tool with nested objects, zero schema descriptions and five required inputs, the description leaves an agent without enough guidance to populate the request correctly.

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

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

Schema description coverage is 0% across 9 parameters including nested 'safety' (recording, consentNotice, transcription) and 'context' objects, and the description explicitly defers everything with 'see the schema'. Only the action enum is echoed, leaving phoneNumber, timezone, language, appointmentType, availableSlots, and maxDurationSeconds unexplained in both places.

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

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

States a specific verb and resource — 'Place an asynchronous appointment call' — and enumerates the scheduling actions (propose, book, confirm, reschedule, cancel), which maps precisely to the schema enum. It is clear what the tool does, though it never names the nearest sibling (ai_call_agent, voice_lead_qualifier) to distinguish itself from other telephone-agent tools.

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

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

The 'When' clause gives a usable trigger condition (an authorized agent coordinating a customer appointment by telephone and needing a machine-readable scheduling result). However, the 'Selection' clause degenerates into a verbatim repetition of the 'When' sentence, so no genuine alternatives or when-not conditions are provided.

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

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

Annotations already establish this as a safe read-only, idempotent, closed-world computation. The description adds genuinely new context not in annotations: the $0.10 USD per-call price, the x402 payment flow, and the critical fact that an unpaid MCP call returns payment instructions rather than a result. That payment/auth behavior is the kind of disclosure annotations cannot carry.

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

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

The purpose is front-loaded, but the 'When:' and 'Selection:' sentences are template artifacts that repeat the tool name twice and consume space without conveying information. The unique payment information is buried after the filler.

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

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

An output schema exists, so return values need not be described, and the schema covers most parameters. Combined with the payment disclosure, the definition is serviceable, but it leaves the agent without any real guidance on when this tool beats its many financial-analysis siblings.

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

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

Schema coverage is 80%, so the schema already documents each OMR parameter, its bounds, and the integer-baisa internal calculation. The description only says 'from supplied fixed and variable costs' and 'see the schema', adding no format, unit, or default semantics beyond what is already structured. Baseline 3 applies.

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

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

The opening sentence states a specific verb and resource: 'Calculate break-even and target-profit units from supplied fixed and variable costs.' It is distinguishable from siblings like product_pricing_calculator or monthly_business_financial_report, though it never explicitly names an alternative to differentiate against.

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 'When:' and 'Selection:' lines are circular boilerplate that restate the tool name ('Use when an agent needs the Creative Techno book framework for break even calculator') without stating a real condition, prerequisite, or excluded case. The only actionable routing hint is the pointer to preview_capability, which concerns payment rather than tool 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 readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely non-obvious behavior: $0.40 USD per call, no free preview, x402 payment, and that an unpaid call returns payment instructions rather than failing silently. That is real value beyond the 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 "When" and "Selection" sentences are near-verbatim restatements of the tool name (including a duplicated sentence fragment and stray punctuation), consuming space without adding information. The pricing/payment sentences do earn their place, but the definition is bloated by dead 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?

An output schema exists, so return values and a sufficient set of annotations need not be re-explained. What remains missing is the one thing the description could uniquely supply: how this differs from the many other business-plan/validation siblings, and what constraints on the generated plan (e.g., Oman-specific, book framework) actually apply.

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

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

Schema description coverage is 0%, but the single parameter is a self-explanatory language enum (ar/en) with a default, so little compensation is required. The description only says "Input is a strict JSON object; see the schema", which adds nothing about the language parameter or what it affects.

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

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

The first sentence gives a concrete verb (Generate) and concrete deliverables (three-month post-launch goals, milestones, KPIs, review gates), which is more specific than most siblings. However, "the book's" is undefined and the reference to a "Creative Techno book framework" never gets explained, so an agent cannot tell how this differs from final_business_plan_builder, business_validation_plan, or oman_business_launch_plan.

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 "When:" clause merely restates the tool name ("Use when an agent needs the Creative Techno book framework for business 90 day growth plan"), and the "Selection:" clause repeats the same phrase verbatim after the word "specialized". No when-not conditions, prerequisites, or named alternatives are given, so the guidance is effectively circular.

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 safe read-only/idempotent profile, so the description clears a low bar. It goes further with genuinely useful behavioral context: $0.20 USD per call, no free preview, x402 paid execution, and that an unpaid call returns payment instructions. That payment/auth flow is real information not available in the schema or annotations.

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

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

The purpose sentence is front-loaded, but two of five sentences (the 'When' and 'Selection' lines) are circular boilerplate that repeat the tool name and earn no place. The repeated 'Use when an agent needs the Creative Techno book framework' phrasing reads as templated 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?

A pre-existing output schema excuses the absence of return-value detail, and payment context is covered. But for a twelve-parameter tool with zero required fields and 8% schema coverage, the description provides no guidance on what inputs matter or how to supply them, leaving the agent under-equipped to invoke it correctly.

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

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

Schema description coverage is only 8% across 12 parameters, so the description carries the burden of explaining inputs and does not. It offers only 'Input is a strict JSON object; see the schema,' which defers entirely to the schema, and its sole gesture at semantics is the vague 'from user-observed problems and constraints.' Fields like skills, customer, budgetOMR, and startupDifficulty remain unexplained.

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

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

The opening clause gives a specific verb+resource ('Generate candidate ideas from user-observed problems and constraints') and even adds a scope caveat ('does not claim market demand'). However, it never distinguishes itself from close siblings like business_idea_validate or business_model_builder, and the follow-on 'Creative Techno book framework' phrasing muddies rather than sharpens the purpose.

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 'When' line is circular: 'Use when an agent needs the Creative Techno book framework for business idea generator' just restates the tool with no external trigger. 'Selection: supporting' is a meaningless label and the 'prefer for...' clause repeats the same circular sentence. No when-not conditions or named alternatives (e.g. business_idea_validate) are given.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds substantial context beyond them: a $0.25 per-call price, the x402 payment flow, that unpaid calls return payment instructions, and that a free preview is reachable via preview_capability. It also bounds capabilities ('does not independently verify live demand'). Value-add is real, though it doesn't describe return content.

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 pricing and preview sentences earn their place, but the 'When:' and 'Selection:' sentences repeat the tool name verbatim and are wasted space. The structure interleaves usage boilerplate with payment logistics rather than front-loading the 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?

An output schema exists so return values needn't be described, and annotations cover the safety profile, which the description supplements well with pricing/auth details. The gap is parameter meaning: with 7 params at 0% coverage, an agent still lacks guidance on fields like prospects and language.

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

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

Schema description coverage is 0% across 7 parameters, so the description must carry the semantic load. It merely names concepts (problem, customer, solution, willingness-to-pay) that map loosely to problem/customer/solution/paymentEvidence without explaining format, constraints, or the roles of idea, prospects, or language.

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 clause gives a specific verb ('Evaluate') and names the evidence dimensions (problem, customer, solution, willingness-to-pay), and the scope caveat 'does not independently verify live demand' further distinguishes it. However, the 'When'/'Selection' phrasing is circular boilerplate that restates the tool name rather than sharpening the purpose against siblings like business_validation_plan.

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 'When:' and 'Selection:' lines are pure tautology ('Use when an agent needs the Creative Techno book framework for business idea validate'), offering no real when-to-use condition or alternatives. It never explains how this differs from business_validation_plan, startup_readiness_score, or business_idea_generator, so the agent gets no routing help.

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

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

Annotations declare a safe, idempotent read, so the description's job is to add operational context — and it does: $0.25 USD per call, no free preview, x402 paid execution, and payment instructions returned on unpaid calls. That payment/auth behavior is not derivable from the annotations and is exactly what an agent needs before invoking.

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

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

Short overall, but two of six sentences are verbatim duplicates of each other and of the name, adding no information. The useful content (deliverable, price, x402 payment behavior) is buried after the redundant routing boilerplate.

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

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

An output schema exists, so return values need not be described, and the payment model is well covered. However, for an 11-parameter tool with 0% schema description coverage, the description leaves the input contract essentially undocumented, which is a real gap.

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

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

Schema description coverage is 0% across 11 parameters, so the description must carry the meaning — instead it only says "Input is a strict JSON object; see the schema." It does not explain the required field groups (product, customer, problem, value, channels, pricing, revenue), the optional arrays, or the language 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 opening sentence gives a concrete verb and deliverable ("Build ... ten-element one-page business map from supplied inputs"), which is more specific than the name alone. But it never distinguishes itself from close siblings like final_business_plan_builder or business_idea_generator, and "the book's" framework is unexplained.

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 "When" and "Selection" lines are circular restatements of the tool name ("Use when an agent needs the Creative Techno book framework for business model builder") and name no alternatives or exclusion conditions. The only genuinely useful routing hint is "Selection: supporting," which is too vague to act on.

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

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

Annotations already establish that this is a safe, read-only, idempotent, closed-world operation. The description adds genuinely non-redundant behavior: $0.15 per call, no free preview, paid execution via x402, and that an unpaid MCP call returns payment instructions. That payment/auth behavior is the kind of context annotations cannot express.

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

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

The purpose sentence is front-loaded and efficient, but the 'When'/'Selection' boilerplate is garbled and repeats the same clause twice with no added information, which is wasted space rather than concision.

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

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

An output schema exists, so return values need no prose, and the description covers pricing and input format. It is nonetheless incomplete on the routing dimension: for a crowded finance/analysis sibling set, it never says how this differs from adjacent tools, which is the main thing an agent needs to choose 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?

The description adds no parameter meaning beyond 'Input is a strict JSON object; see the schema.' With 75% schema description coverage, the schema already documents most fields (OMR units, baisa note, min/max), so the baseline of 3 applies; the two undocumented parameters and the language enum are left entirely to structured data.

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 gives a specific verb (calculate) and concrete outputs (revenue, gross profit, net profit, margins) from monthly data, which is a clear, actionable purpose. It does not, however, differentiate itself from near-neighbors such as monthly_business_financial_report, break_even_calculator or product_pricing_calculator, so an agent cannot route confidently on purpose alone.

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

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

The 'When:' clause is circular — it says to use this tool when an agent needs this tool's analysis — and 'Selection: supporting; prefer for [verbatim repeat]' adds no discriminating condition. No alternatives, exclusions, or prerequisites are stated, so there is no real when/when-not guidance.

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

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

With annotations already covering safety (readOnly, idempotent, non-destructive, closed-world), the description adds genuinely useful non-structured context: a $0.20 per-call price, no free preview, x402 payment flow, and that an unpaid call returns payment instructions. It also asserts the output contains no unsupported probabilities, which is a real behavioral claim. This goes meaningfully beyond 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 text is bloated and partly broken, most notably the duplicated, ungrammatical 'prefer for Use when an agent needs the Creative Techno book framework for business risk check..' The pricing/payment sentences are useful, but the purpose and usage sentences waste space without conveying 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?

An output schema exists, so return values need not be described. However, for a paid, three-parameter tool with a nested input object, the definition leaves the core concept ('the book') undefined, gives no parameter semantics, and offers no real routing against the many sibling risk tools.

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

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

Schema description coverage is 0% across three parameters, including a nested 'signals' object and a 'language' enum, yet the description only says 'Input is a strict JSON object; see the schema' and adds no meaning for any parameter. With zero schema coverage it was obliged to compensate and does not.

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 says it will 'diagnose the book's common mistakes from supplied signals', but never identifies what 'the book' is beyond a vague 'Creative Techno book framework', which effectively restates the tool name. It does not distinguish this from near-identical siblings like business_risk_score, analyze_company_risk, or company_risk_report, so an agent cannot tell which to pick.

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 'When' clause is circular: 'Use when an agent needs the Creative Techno book framework for business risk check' simply repeats the tool name back. There is no statement of when to use this over the many sibling risk tools, no prerequisites, and no exclusions.

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

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

Annotations already declare readOnly/idempotent/destructive=false, and the description adds materially: per-call pricing ($0.50 USD), the x402 payment gating with a free preview_capability path, and the behavioral consequence of the optional flags (skipping news makes reputation coverage 'none'; skipping digital signals makes digital coverage 'none'). Those are real operational facts an agent cannot infer from the schema or annotations.

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

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

Front-loaded with the purpose, then When/Selection/payment, so an agent can stop reading early and still decide. The long enumeration of return fields is somewhat over-extended for a tool that already has an output schema, which is the only wasted weight.

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

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

For an 11-parameter, paid, output-schema-backed tool, the description covers the decision-relevant extras: eligibility triggers, exclusions, cost, and the payment/preview flow. Return-value detail is redundant with the output schema, and it never clarifies how it relates to the several overlapping company-risk siblings in the catalog.

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 (lei, registrationNumber, knownAliases, includeNews, includeDigitalSignals, etc.) is already documented with its disambiguation role in the schema. The description adds only the meta-note that input is a 'strict JSON object' and repeats the coverage effects of the two booleans, 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?

States a specific verb+resource ('Assess the risk of doing business with a company') and enumerates the evidence categories used, so the agent knows exactly what computation happens. It partially differentiates from siblings by naming the excluded use cases ('public reputation only', 'finding companies'), which routes away from company_reputation_check and find_companies. However, with near siblings like business_risk_check, analyze_company_risk and company_risk_report, it never states how this tool differs from 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 'When:' clause gives concrete trigger scenarios (onboarding a supplier, paying a new business, entering a B2B transaction, extending credit/insurance) and the following sentence adds an explicit exclusion ('Do not use for public reputation only or finding companies'). What is missing is naming the specific alternative tool to use instead of those excluded cases, so routing is implied rather than 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 readOnly, idempotent, non-destructive, closed-world behavior, but the description adds genuinely useful operational context beyond them: it only produces the plan while execution/evidence collection stays with the caller, and it discloses the $0.25 per-call price, absence of a free preview, and x402 payment-instruction behavior on unpaid calls. That is substantially more than the 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 contains visible redundancy, notably the duplicated 'prefer for Use when an agent needs the Creative Techno book framework for business validation plan..' fragment with stray punctuation, and the purpose is not cleanly front-loaded. Payment details are repeated ('Price' and 'Full execution is paid per call'), wasting space in an otherwise short string.

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

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

An output schema exists, so return values need not be described, and the annotations plus payment notes cover the safety and cost dimensions. However, for a 7-parameter tool with zero schema coverage, the definition leaves parameter usage and the distinction from sibling validation/preview tools unresolved, so it is only minimally complete.

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

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

Schema description coverage is 0% for 7 parameters (idea, customer, problem, solution, prospects, language, paymentEvidence), so the description must compensate and does not. Its only input remark is 'Input is a strict JSON object; see the schema,' which defers entirely to the schema and explains no parameter meaning, format, or the enum/default on language.

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

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

The description gives a verb+resource ('Create the book's structured seven-day validation workflow'), so the general purpose is inferable, but 'the book' and 'Creative Techno book framework' are unexplained references that leave the actual deliverable ambiguous. It never distinguishes itself from close siblings like business_idea_validate, startup_readiness_score, or business_90_day_growth_plan.

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 'When' and 'Selection' clauses are circular, restating 'Use when an agent needs the Creative Techno book framework for business validation plan,' which adds no discriminating condition. No alternatives or exclusion criteria are given despite many overlapping siblings, so an agent gets no real 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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds real value beyond them: no hiring decision is emitted, cost is $0.10 per call, execution is paid via x402, and an unpaid MCP call returns payment instructions. This is exactly the kind of behavioral context annotations cannot 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 core purpose is front-loaded well, but the 'Selection' clause duplicates the 'When' sentence almost verbatim, and the payment/price boilerplate adds length. Roughly a third of the text is redundant filler.

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

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

An output schema exists, so return values need not be described, and annotations cover safety. The description completes the picture with input shape, the no-decision guarantee, and the paid-invocation model. Minor gap: max_candidates and the candidate object structure are never mentioned.

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

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

Schema description coverage is 0%, so the description must carry the load. It maps the two headline inputs (candidate profiles, job profile) and notes the 'up to 100' cap, but says nothing about max_candidates, the candidate_id requirement, or the free-form profile objects. Partial compensation only.

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 (Score) and resource (up to 100 candidate profiles against one job profile) plus the output artifacts (matched requirements, gaps, confidence). The batch framing and the explicit 'no hiring decision is emitted' distinguish it from single-candidate siblings like cv_score and cv_job_match.

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 'When' clause gives a clear trigger: use after extracting multiple candidate profiles for transparent batch comparison against one job, which implicitly routes from extract_candidate_profile. It lacks an explicit when-not or a named alternative, but the context is unambiguous.

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

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

Annotations already cover the read-only/idempotent/non-destructive profile, and the description adds substantial context beyond them: per-call price ($1.50 USD), x402 paid execution, that an unpaid MCP call returns payment instructions, and that a free preview is available via preview_capability. It also discloses the deterministic nature of the returned assessment and the machine-actionable next action.

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

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

Front-loaded with purpose, then clearly labeled When/Selection/Input/Price sections, so an agent can scan it quickly. It is somewhat long and the payment/preview details occupy nearly as much space as the functional description, but every sentence carries real selection or invocation value.

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

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

An output schema exists, so return values need no explanation, and the description covers scope, exclusions, cost, preview path and payment behavior for what is an expensive, gated operation. The remaining gap is parameter-level guidance for a mostly undocumented 8-parameter 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 only 25% across 8 parameters (including a nested checks object and two enums), and the description defers entirely with 'Input is a strict JSON object; see the schema.' The evaluated-signal list loosely hints at the checks toggles, but it never explains depth levels, purpose values, country, lei or registrationNumber, so the large coverage gap is not compensated.

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

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

States a specific verb+resource ('Perform company due diligence') and enumerates exactly what is evaluated (registration, website identity, sanctions, adverse news, legal, financial, reputation) plus the output shape (deterministic risk assessment with evidence and a next action). It also excludes siblings ('Do not use for simple company search or stock price lookup'), so an agent can separate it from find_companies or research_company.

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

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

Explicit 'When:' clause (agent must decide whether to continue doing business, and what verification/escalation follows) and 'Selection: primary; prefer before onboarding a supplier or before signing a commercial agreement', plus an exclusion. Strong context, but it never names the competing siblings (analyze_company_risk, company_reputation_check, company_risk_report, supplier_due_diligence_report) that an agent is likely to weigh it against.

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

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

Annotations already cover read-only, idempotent, closed-world, and non-destructive behavior. The description adds substantial operational context beyond annotations: pricing ($0.40 per call), a free preview via preview_capability, paid execution through x402, and unpaid-call payment instructions, plus the evidence-linked-score and confidence-score output shape.

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 purpose sentence followed by 'When,' 'Selection,' 'Input,' and 'Price' sections, and the most important selection guidance is front-loaded. There is some redundancy in restating reputation and screening scope, but it remains efficient for a complex paid tool.

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

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

Given the complex scope, rich schema, existing output schema, and annotations, the description covers purpose, usage, exclusions, input expectations, price, preview, and payment model. It omits minor operational details such as failure behavior or latency, but an agent has enough to select and invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters in detail. The description only says input is a strict JSON object and to see the schema, adding no parameter-level meaning beyond what is structured.

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: 'Investigate the public reputation and commercial risk signals of a company in any country,' then enumerates the signals and outputs. It distinguishes the tool from some siblings by ruling out deterministic business risk decisions and company finding, but it does not name the specific alternative tools an agent should use 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?

It provides explicit 'When' and 'Do not use for' guidance, plus a 'prefer for' preference statement. Alternatives are implied but not named, so an agent gets clear context without a direct routing table to sibling tools.

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

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

Goes well beyond the annotations (which only declare it read-only/idempotent/non-destructive) by disclosing pricing ($8.00 USD per call), the x402 payment flow, that unpaid calls return payment instructions rather than results, and that per-row results and provider failures are preserved. Partial-failure semantics and cost are exactly the kind of context annotations cannot carry, though rate limits and latency are not mentioned.

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 correctly front-loaded, but the 'Selection: specialized; prefer for Use when an agent needs to screen many companies efficiently instead of making separate risk-report calls..' line is a duplicated, syntactically broken restatement of the preceding sentence — pure waste that also risks confusing the reader.

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 batch tool with an output schema already covering return values, the description supplies the essential extras: batch bounds, accepted input shapes, cost, and payment behavior. Missing only CSV format specifics, which is a modest gap given the schema documents the structured path.

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

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

Top-level schema description coverage is 0% for the two parameters (csv and companies), and the description only offers 'from structured rows or CSV' plus 'see the schema.' That hints at the two input modes but does not explain the CSV format, column mapping, or the mutual-exclusivity question of supplying both csv and companies. The nested per-company fields are documented in the schema itself, so the gap is limited but real.

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 with explicit scope: 'Assess 1–100 companies from structured rows or CSV in one bounded batch.' It contrasts itself against 'separate risk-report calls,' which implies a distinction from the single-company risk siblings, but it never names them (analyze_company_risk, company_risk_report, business_risk_score), so the routing is only implicit.

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

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

The 'When' clause gives a concrete condition — screening many companies efficiently rather than making separate risk-report calls — which is actionable guidance with a named alternative pattern. The 'Selection' clause is garbled repetition and adds nothing, so no explicit exclusions or prerequisites are provided.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuinely useful non-schema behavior: $1.50 USD per call, no free preview, x402 paid execution, and that an unpaid MCP call returns payment instructions. That payment/auth context is exactly the kind of value the annotations cannot supply; only the lack of rate-limit or latency/pagination notes keeps it from a 5.

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

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

The core purpose sentence and the pricing/x402 sentences earn their place and are front-loaded, but the 'When/Selection' block is largely duplicated boilerplate and one clause is a verbatim, ungrammatical repeat of the When text. Roughly a quarter of the description is dead weight.

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

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

An output schema exists, so return values need no explanation, and the payment model is fully covered. What is missing is selection context against the large family of overlapping company-risk tools, plus notes on the two undocumented boolean toggles (includeNews, includeDigitalSignals). Adequate but with a clear routing gap for a paid, high-stakes analysis 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 82%, so for most of the 11 parameters the schema already documents meaning (lei, domain, country, registrationNumber, etc.). The description contributes only 'Input is a strict JSON object; see the schema,' adding no disambiguation guidance (e.g. companyName vs legalName, includeNews/includeDigitalSignals which lack schema descriptions). Baseline 3 is appropriate.

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

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

The first sentence states a specific verb and resource — it combines reputation evidence with business-risk scoring into one 'company risk report' — which is clear and actionable. However, it does not name or contrast with the many near-identical siblings (analyze_company_risk, business_risk_score, business_risk_check, company_reputation_check, company_due_diligence), so an agent cannot easily tell which risk tool to pick. The 'Selection: specialized' sentence is garbled and merely restates the When clause, adding no differentiation.

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

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

The 'When:' clause just paraphrases the purpose ('use when an agent needs a consolidated company risk report with both evidence and an explicit risk model') rather than giving a triggering condition. There are no when-not conditions and no alternatives named, despite a crowded set of overlapping risk/reputation siblings. The broken 'Selection: ...prefer for Use when...' fragment implies prioritization but conveys nothing usable.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description usefully adds traits those annotations cannot express: deterministic ordering by rounded net yield with input-order tie-breaking, and the x402 payment model where an unpaid MCP call returns payment instructions.

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 ranking rule and payment terms are front-loaded and useful, but the 'When'/'Selection' sentences are redundant with each other (the 'prefer for' phrase repeats the preceding sentence verbatim and ungrammatically), which is wasted tokens in a short 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?

An output schema exists so return format need not be explained, and the description covers the two things an agent must know before calling: the input is a strict JSON object and the call is paid per execution via x402. Only the sibling-routing guidance is thin.

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

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

Schema description coverage is 0% and the single parameter is a nested object of required fields (name, annualRent, propertyValue). The description contributes the 'uniquely named' uniqueness constraint and 'same metrics' comparability requirement, but leaves the per-field meaning (maintenance vs maintenanceCost alias, vacancyRatePct) entirely 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?

States a concrete verb and resource ('Compare 2–20 uniquely named properties in OMR'), the shared metric basis, and the ranking rule (rounded net yield, ties in input order). It clearly separates itself from the single-property siblings like analyze_property, though it never names them.

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

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

The 'When' clause gives a usable trigger (rank or choose between 2-20 candidates by net yield), but the follow-up 'Selection: supporting; prefer for Use when...' is a garbled duplication that adds no information, and no exclusion against sibling tools (analyze_property, property_investment_report) is offered.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld=false, so safety is covered. The description adds genuinely useful behavioral facts beyond that: competitors must be user-supplied (no live discovery), pricing is $0.30/call via x402, and an unpaid call returns payment instructions rather than results. This is meaningful context a caller cannot get from 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 pricing sentence is front-loadable value, but the 'When:' and 'Selection:' boilerplate is redundant and grammatically garbled ('prefer for Use when an agent needs...'), and 'see the schema' plus 'No free preview is advertised' pad the text without adding routing information.

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

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

An output schema exists, so return values need not be explained, and annotations plus the pricing/scope sentences cover safety and cost. What is missing is the shape of the analysis the framework produces and any meaning for the inner competitor fields, which is a gap given the nested competitor objects, but the definition is minimally sufficient to invoke.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden, but it only restates the 3-20 count and says 'see the schema'. The language enum, the required name field, and the product/priceOMR/strengths/complaints/weaknesses/positioning sub-fields are entirely undocumented in prose, leaving the agent dependent on raw schema inspection.

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 clause gives a specific verb and resource with scope: 'Compare 3-20 user-supplied competitors', and the negative clause 'does not discover or verify competitors without live evidence' distinguishes it from discovery/verification siblings like find_companies or company_reputation_check. The 'Creative Techno book framework' reference is circular and adds no clarifying detail, keeping it short of a 5.

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

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

The 'When:' clause merely restates the purpose ('Use when an agent needs the Creative Techno book framework for competitor analysis'), which is tautological rather than situational. 'Selection: supporting; prefer for Use when...' is garbled and names no actual alternative sibling, so the agent gets no real when-to-use/when-not-to-use routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds genuinely useful behavioral context beyond that: the $0.20/call price, the x402 payment model, that no free preview exists, and that an unpaid call returns payment instructions rather than erroring.

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 first sentence is front-loaded and efficient, and the payment note is compact. But the 'When' condition is repeated verbatim inside the 'Selection' clause, producing clear template filler that wastes reader attention.

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

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

An output schema exists, so return-value explanation is not required, and the payment/authorization behavior is documented. Still, with 7 parameters at 0% description coverage and no real usage routing, the definition is under-specified for an agent to invoke it confidently against its many plan-oriented siblings.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate. It only gestures at offer, channels, and the 14/30 day choice, leaving business, icp, language, and postingFrequencyPerWeek entirely unexplained in both the schema and the description.

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 (Generate), resource (structured content calendar), scope (14- or 30-day), and inputs (offer, selected channels), so the core purpose is clear. However, it does not differentiate itself from siblings like business_90_day_growth_plan or first_10_customers_plan, and the surrounding boilerplate muddies rather than sharpens the purpose.

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?

'When: Use when an agent needs the Creative Techno book framework for content plan generator' is circular and restates the tool name instead of giving a real condition. 'Selection: supporting; prefer for [same phrase]' names no alternatives and no when-not, so an agent gets no routing guidance despite the labeled fields.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, but the description adds genuinely useful behavior the annotations cannot convey: strict JSON input, a $0.25 per-call price, x402 paid execution, and the fact that an unpaid call returns payment instructions rather than results. This payment/auth behavior is real added value.

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

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

The opening purpose sentence is well front-loaded, but the definition is undermined by a broken 'Selection' segment that duplicates the preceding 'When' text verbatim with a doubled 'prefer for' fragment. That is pure waste rather than earned 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?

The presence of an output schema means return values need not be explained, and annotations plus the pricing note cover the safety/payment profile. However, for a 4-parameter tool with 0% schema description coverage, the description leaves parameter usage entirely unaddressed, which is a notable gap.

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

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

Schema description coverage is 0%, so the description should compensate, but it only says 'see the schema.' It never explains cv_text, target_job_description, the empty candidate_profile object, or the meaning of the five mode enum values, leaving all four parameters undocumented.

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

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

The first sentence gives a specific verb (Produce), resource (CV improvement recommendations), and scope (evidence-grounded, job-specific guidance, ATS actions, without inventing facts). It is clear what the tool does, though it does not explicitly distinguish itself from adjacent siblings like cv_score or cv_job_match.

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 'When' clause names a generic triggering scenario (a candidate or recruitment agent needs improvement guidance), but offers no when-not conditions and no comparison to sibling tools. The 'Selection' clause is a garbled verbatim repeat of the 'When' clause and provides zero additional 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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds genuinely new behavioral context: $0.25 per call, x402 paid execution, and that unpaid MCP calls return payment instructions. It does not describe result shape, but the output schema exists.

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

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

The opening sentence and pricing note earn their place, but the 'Selection:' sentence is malformed and restates the When clause verbatim, adding noise. Front-loading is decent but the duplication hurts efficiency.

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

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

An output schema exists, so return values need not be explained, and payment behavior is covered. But with 0 required params and 0% schema coverage, an agent still lacks guidance on how to populate the four inputs, and the garbled selection text leaves usage partially unclear.

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

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

Schema description coverage is 0% across 4 parameters, so the description must carry the load. It only says 'Input is a strict JSON object; see the schema' and loosely names the concepts (CV, job profile/description, candidate profile), leaving format, mutual exclusivity of job_profile vs job_description, and requiredness unexplained. It defers rather than compensates.

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

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

States a specific verb (compare) and resources (candidate profile/CV vs job profile/description) and adds the mechanism (normalized skills, experience evidence, transparent weighted scoring). This lets an agent distinguish it from siblings like cv_score and candidate_shortlist_score, though it does not name those siblings directly.

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 'When' clause gives a usable condition ('evidence-based candidate-to-job matching for one candidate'), which implies the scope. However, the 'Selection' sentence is garbled ('supporting; prefer for Use when an agent needs...') and duplicates the When clause instead of naming alternatives or exclusions, so no real routing guidance beyond the basic case is provided.

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

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

Annotations already establish read-only, idempotent, non-destructive, closed-world behavior, and the description adds genuinely new operational context: $0.20 per call, x402 payment, and the fact that an unpaid MCP call returns payment instructions rather than an error. It still says nothing about latency, rate limits, or what the score breakdown contains.

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

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

The purpose is front-loaded and the Price/payment note is tight, but the "Selection" line repeats the entire "When" clause verbatim ("prefer for Use when an agent needs general CV quality feedback independent of a specific job"), which is pure duplication and reads as a template artifact. Removing that sentence would lose nothing.

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

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

An output schema exists, so return values need no explanation, and the payment flow is covered. However, for a 3-parameter tool with no required parameters and no schema descriptions, the description leaves the agent unable to tell what candidate_profile is for or whether cv_text is mandatory.

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

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

All three parameters (cv_text, target_role, candidate_profile) have 0% schema description coverage, and the description only says "Input is a strict JSON object; see the schema." It adds no meaning for any parameter, not even clarifying what candidate_profile should contain or whether target_role affects scoring. The low-coverage case requires the description to compensate, and it does not.

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 clause names a specific verb (score), a specific resource (CV), the exact dimensions (completeness, clarity, ATS-readability) and the scale (0-100), and explicitly excludes job matching. That exclusion is enough to separate it from siblings like cv_job_match and candidate_shortlist_score without opening either schema.

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

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

"Use when an agent needs general CV quality feedback independent of a specific job" gives a clear selection condition, and the description points to preview_capability as the free-preview path before paying. It stops short of naming cv_job_match or cv_improve as the contrast cases, so the when-not side is only implied.

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

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

Annotations already flag the read-only, idempotent, non-destructive profile, and the description layers on meaningful operational detail: per-fact 0-1 confidence, verbatim excerpts with character offsets and pages, normalization only when unambiguous, 25-page limits, rejection (not truncation) of oversized text, $0.25 per-call pricing via x402, and the fact that unpaid calls return payment instructions. This is well beyond what the 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?

Purpose and constraints are front-loaded in a dense but readable opening paragraph, followed by labeled When/Selection/Price sections. It is somewhat long and mildly redundant ('primary; prefer for evidence-backed extraction...' paraphrases the preceding sentence), but nearly every sentence carries information.

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

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

With an output schema present, the description correctly avoids explaining return values and instead covers input modes, size/format limits, scoping to document-grounded work, and the payment lifecycle. Nothing an agent needs to decide or invoke correctly appears to be missing.

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

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

Schema description coverage is 100%, and the description largely restates it: the accepted documentUrl formats, the text alternative, and the 25-page cap are all already documented per-parameter. It adds little new semantic content on mode, requestedFacts, or includeSourceEvidence beyond what the schema states, so the baseline 3 applies.

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

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

The description opens with a precise verb+resource: extracting structured, evidence-backed facts (entities, dates, amounts, obligations, deadlines, risk indicators) from business documents. It enumerates the document types in scope and clearly separates itself from siblings like company_due_diligence or analyze_company_risk by requiring a supplied document. An agent can identify the tool's function without opening the schema.

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

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

Explicit 'When:' guidance states the use case (reliable machine-readable facts instead of a general summary), and 'Do not use for general company due diligence without a document or legal advice' supplies a clear exclusion. It also points to preview_capability as a free preview alternative before payment, giving the agent an alternative path.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds genuinely useful non-schema behavior: $2.00 per call, no free preview, x402-paid execution, and that an unpaid call returns payment instructions rather than results.

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

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

Front-loaded with purpose and deliverables, but the 'Selection:' sentence duplicates the 'When:' clause verbatim, wasting a whole sentence, and the pricing block is dense. Mixed efficiency.

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

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

Payment/pricing mechanics are unusually complete and an output schema exists so return values need no elaboration. But for a 3-parameter, 0%-coverage schema the description never documents transactionType or transactionValueOMR, leaving a real gap before invocation.

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

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

Schema description coverage is 0%, so the description carries the full burden. It names companyId and alludes to a 'stated transaction' but never explains transactionType's enum values or what transactionValueOMR is used for (e.g., risk tiering), leaving two of three parameters semantically thin.

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 ('Perform structured commercial due diligence on one Oman company by companyId') and enumerates the four deliverables returned. However, it gives no differentiation from close siblings such as company_due_diligence, supplier_due_diligence_report, or analyze_oman_company, so an agent cannot tell why this one is chosen.

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 'When' clause gives concrete triggering contexts (awarding a contract, partnership, extending credit, investing) which is clear contextual guidance. It stops short of explicit when-not or named alternatives, despite several competing due-diligence/risk siblings existing.

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, and the description adds substantive context beyond them: that the model is an 'uncalibrated heuristic, not a survey', plus pricing ($0.02/call), no free preview, and x402 payment behavior for unpaid calls. That is genuinely useful pre-invocation 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?

Labeled sections (When/Selection/Price) aid scanning, but the 'Selection' field repeats the 'When' sentence word-for-word, and the paragraph is bloated with payment boilerplate. Real information density is low relative to length.

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

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

An output schema exists, so return values need not be explained, and the pricing/payment model is covered. What is missing is any guidance on the optional nested 'assumptions' object and how defaults apply, which matters for a tool whose description emphasizes 'explicit optional assumptions'.

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

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

Schema description coverage is only 20% across 5 parameters, so the description must compensate. It names value, age and unit count, but says nothing about the nested 'assumptions' object contents (annualRatePct, additionalUnitCost) or confirms the legacy status of annualRent beyond what the schema already notes.

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

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

States a specific verb and resource — 'Estimate an annual maintenance reserve in OMR' — and names the driving inputs (value, age, unit count). It also distinguishes the output from a real 'survey'/'inspection'. Points off only because the purpose statement is padded by duplicated surrounding boilerplate.

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 'When' clause gives a usable trigger ('needs an annual maintenance reserve estimate for a property, not an actual inspection'). However, no alternative sibling is named, and the 'Selection' clause just restates the same sentence verbatim rather than routing the agent away from an alternative 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 readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds genuinely new context the agent needs: per-call pricing ($0.10), a free preview path via preview_capability, and x402 payment behavior where an unpaid call returns payment instructions.

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

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

The core sentence is well front-loaded, but the 'Selection: supporting; prefer for Use before scoring or matching a CV...' clause is a verbatim duplication that wastes space and reads as a defect.

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

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

An output schema exists, so return values need no explanation, and the payment/preview mechanics are complete. But with four parameters at 0% schema coverage and no parameter guidance in the prose, the agent lacks enough to construct the input confidently.

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

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

Schema description coverage is 0% for all four parameters, so the schema documents nothing about cv_text, language, document_url, or target_schema_version. The description only says 'Input is a strict JSON object; see the schema,' which does not compensate for the coverage gap.

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

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

The description gives a specific verb and resource transformation ('Normalize an English, Arabic or mixed-language CV into a machine-readable candidate profile') plus scope ('only stated professional evidence'). This clearly distinguishes it from siblings like cv_score or cv_improve, though it does not name any sibling explicitly.

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

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

It provides a real when-clause: 'Use before scoring or matching a CV when an agent needs reusable structured candidate evidence.' However, the 'Selection' line is a broken duplicate of the same sentence, gives no alternatives or exclusions, and does not route the agent among the numerous CV/shortlist 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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely new behavioral facts: a $0.50 USD per-call price, no free preview, paid x402 execution, and the specific consequence that an unpaid call returns payment instructions. That is real value beyond the structured fields, though it says nothing about the contents or format of the assembled plan.

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 and sentences are short. But the Usage/Selection lines duplicate each other and the tool name verbatim, and the awkward "prefer for Use when..." phrasing wastes budget on zero-information text.

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

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

An output schema exists, so return values need no explanation, but for a 17-parameter (15 required) tool the description gives the agent almost nothing about the inputs it must supply. Combined with the garbled selection guidance, the definition is under-specified for a tool of this complexity.

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

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

With 17 parameters, 15 required, and only 24% schema description coverage, the description carries a heavy burden but offers none: it only says "Input is a strict JSON object; see the schema." No field meanings, accepted value ranges, or the role of the one enum (language) are clarified, so it fails to compensate for the coverage gap.

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

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

The opening sentence states a concrete verb and resource: assemble a final project plan from business and financial inputs. However, "the book's final project plan" and the "Creative Techno book framework" are opaque jargon, and the selection clause is a garbled restatement that fails to distinguish it from the many sibling plan/builder 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 "When:" and "Selection:" lines are tautological, both essentially repeating the tool name ("Use when an agent needs... final business plan builder"). No sibling alternative (e.g. business_model_builder, oman_business_plan_generator) or preconditions are named, leaving the agent with no real 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 safety is covered. The description adds real context beyond that: results are cited, never fabricated, carry a confidence score, cost $0.05 per call, and unpaid calls return payment instructions via x402. That pricing and payment behavior is valuable, but there is nothing on latency or result volume.

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 front-loaded discovery sentence and pricing note are efficient, but the 'Selection' sentence is duplicated boilerplate ('supporting; prefer for Use when...', a visible template error) that adds no information. That waste offsets the otherwise tight opening.

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

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

An output schema exists, so return values need not be explained, and the description covers provenance (cited, non-fabricated), confidence scores, and payment mechanics. The main gap is that with zero parameter documentation, an agent still has to open the schema to learn how the eight inputs, including employee ranges and limit, behave.

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

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

Schema description coverage is 0% across 8 parameters, so the description must compensate. It only lists the dimensions conceptually (industry, location, size, keywords) without attending to the actual parameters: no mention of the limit cap of 100, the employeeMin/employeeMax pair, city/country distinctions, or the separate query field, and it says only 'Input is a strict JSON object; see 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 ('Discover companies from public web sources') plus the filter dimensions (industry, location, size, keywords). It also distinguishes from analysis siblings by contrasting discovery of candidates versus analyzing a known company. However, it never names specific sibling tools it competes with, so sibling differentiation is implied rather than explicit.

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

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

A 'When' clause gives context: use when an agent needs to discover a list of candidates rather than analyze an already-known company. That is useful and marks the analysis-family exclusion, but no specific alternative tool is named, and the 'Selection' sentence is garbled boilerplate that simply restates the same clause rather than adding routing information.

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

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

Annotations already declare readOnlyHint/idempotentHint/destructiveHint=false, so safety is covered; the description adds real operational context the annotations cannot: a $0.25 per-call price, no free preview, and that unpaid x402 calls return payment instructions. It says nothing about what the generated plan contains or its size limits.

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

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

The text contains duplicated, garbled scaffolding ('prefer for Use when an agent needs the Creative Techno book framework...') and repeats the payment model across three sentences. Front-loading is acceptable but several sentences do not earn their place.

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

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

An output schema exists, so return values need not be described, and annotations cover the safety profile. However, with 3 required fields and 6 parameters at 17% schema coverage, the description should have clarified the core inputs, and the circular usage text leaves routing unresolved.

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

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

Schema description coverage is only 17% across 6 parameters, and the description compensates with nothing beyond 'Input is a strict JSON object; see the schema.' It never explains business, customer, offer, prospects, language, or the baisa-based priceOMR, leaving most inputs undecided for the agent.

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

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

The first sentence gives a concrete verb and deliverable: create a plan covering 20 prospects and the first 10 paying customers. It is distinguishable from siblings like business_90_day_growth_plan or ideal_customer_profile, though the 'Creative Techno book framework' phrasing is jargon that does little to sharpen the boundary.

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 'When' clause merely restates the tool name ('use when an agent needs the...first 10 customers plan'), which is circular, and the 'Selection: supporting' label is an unexplained tier marker. No sibling alternative is named and no condition for choosing this over other plan generators is given.

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

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

It goes beyond the annotations (readOnly/idempotent/openWorld=false) by disclosing the commercial behavior: $0.15 per call, a free preview_capability path, x402 payment, and that an unpaid MCP call returns payment instructions instead of results. That is genuinely useful context an agent needs before calling. It stops short of describing result shape or rate limits.

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

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

The 'When' and 'Selection' fragments are duplicated boilerplate that conveys nothing, and 'see the schema' spends words without adding information. The remaining content (purpose, pricing, preview path) is front-loaded but buried among filler.

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

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

An output schema exists, so return values need not be explained, and the payment/preview flow is covered. However, for a 13-parameter paid comparison tool with a nested preferences object, the near-absent parameter guidance and the missing relationship to flight_search leave the agent under-equipped to call it correctly.

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

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

Schema description coverage is only 8% across 13 parameters, so the description must compensate and largely does not. It gestures at the four comparison dimensions (price/duration/stops/reliability) implicitly matching the nested preferences weights, but never explains origin, dates, currency, cabinClass, adults/children, or the preference weighting model, only deferring with 'see 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 opening sentence gives a specific verb (compare) and resource (current flight offers) plus the comparison dimensions: price, duration, stops and reliability signals. It is distinguishable from generic siblings, though it never names flight_search or trip_cost_estimate, which is where an agent would most plausibly look first.

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 'When' clause is circular: 'Use when an agent needs flight compare from current travel offers' restates the tool name rather than naming a real trigger. The 'Selection: supporting' line then repeats the same sentence verbatim, offering no condition under which this beats flight_search.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description adds genuine behavioral context beyond them: per-call pricing ($0.10 USD), the x402 paid-execution model, the preview_capability free-preview path, and the fact that unpaid calls return payment instructions. This is exactly the kind of non-obvious operational detail descriptors should surface.

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

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

The purpose is front-loaded and the payment paragraph is worth its space, but the 'When/Selection' block contains a duplicated sentence and a broken fragment ('prefer for Use when...'), which is avoidable noise in an otherwise short 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?

An output schema exists, so return values need no explanation, and the payment model is well covered. But for a 12-parameter tool with almost no schema descriptions and no meaningful alternative-routing guidance, the definition leaves an agent under-equipped to select and parameterize 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 only 8% across 12 parameters, so the description carries the burden of explaining them — yet it says nothing beyond 'Input is a strict JSON object; see the schema.' Required/optional fields, the origin/destination format, sort semantics, and passenger constraints are left entirely unexplained.

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

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

The opening sentence states a specific verb and resource ('Search current flight offers') and enumerates the returned artifacts (normalized prices, itineraries, stops, timing). It does not, however, distinguish itself from the sibling 'flight_compare', which an agent would reasonably confuse with 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?

The 'When' clause merely restates the purpose ('Use when an agent needs flight search from current travel offers'), and the 'Selection: supporting; prefer for ...' fragment is garbled, repeating the same phrase verbatim. There is no real condition separating this from flight_compare or trip_cost_estimate.

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, idempotentHint, destructiveHint, openWorldHint), and the description usefully goes beyond them with cost and flow details: $0.10 per call, a free preview_capability, and the fact that an unpaid call returns payment instructions rather than executing. That payment/x402 behavior is genuinely valuable context an agent cannot get from annotations.

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

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

The purpose, payment, and preview information are front-loaded and useful, but the 'Selection:' sentence duplicates the 'When:' clause almost verbatim, which is wasted space. Structure is otherwise readable but contains obvious 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?

An output schema exists, so return values need no explanation, and the description covers purpose, usage trigger, and the payment/preview flow. The remaining gap is parameter meaning, which is left entirely to a schema with no field descriptions.

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

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

Schema description coverage is 0%, so the description carries the full burden for the three parameters, yet it only says 'Input is a strict JSON object; see the schema.' It never explains job_description, job_title, or the language field, and pointing to a schema that itself lacks descriptions compensates for nothing.

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

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

The opening sentence states a specific verb and resource ('Normalize a job description into required and preferred professional requirements with transparent weights totaling 100'), so the agent knows exactly what is produced. It frames the output for candidate matching/shortlisting, which loosely differentiates it from siblings like candidate_shortlist_score, but it never names an alternative tool 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 'When:' clause gives a usable trigger ('Use before candidate matching or shortlisting'), but there are no when-not conditions or named alternatives. The 'Selection:' sentence simply repeats the same trigger verbatim ('prefer for Use before candidate matching or shortlisting when an agent needs a structured job requirement profile'), adding no real routing information.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds material context beyond them: per-call pricing ($0.25), no free preview, x402 payment and that an unpaid call returns payment instructions rather than data.

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

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

The purpose is well front-loaded, but the 'Selection:' sentence reproduces the 'When:' sentence almost verbatim, which is pure redundancy and bloats the definition. The payment sentences are justified, but the duplication costs structure.

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

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

With an output schema present, return values need not be documented (though they are), and annotations carry the safety profile. The description covers purpose, trigger condition, ID provenance, and the payment model, leaving only explicit exclusion criteria unstated.

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

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

There is a single parameter (companyId) with 0% schema description coverage, so the description must carry the load. It names the parameter and its origin (supplied by search_oman_company) but gives no syntax, format, or constraints beyond that, and defers to the schema with 'see the schema'.

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

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

States a specific verb and resource ('Return a structured profile for one Oman company by companyId') and enumerates the field groups returned (identity, registration, location, contact, digital-presence, provenance). This is clearly distinguishable from search_oman_company (which resolves the ID) and the analyze/due-diligence siblings.

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

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

Explicitly states when to use it ('Use after search_oman_company resolves a companyId ... before deciding whether deeper analysis or due diligence is warranted'), which routes the agent correctly against analysis siblings. However, it names no explicit when-not condition and the garbled 'Selection:' clause merely duplicates the 'When:' text rather than adding a real alternative comparison.

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 cover the safety profile (read-only, idempotent, non-destructive), and the description adds genuinely non-obvious behavior annotations do not carry: a $0.10 USD per-call cost, x402 payment flow, a free preview via preview_capability, and the fact that an unpaid call returns payment instructions instead of results. That payment/auth context is exactly what an agent needs before invoking. Minor tension: annotations declare openWorldHint=false while the description advertises live 'current inventory' and 'current travel offers', though openWorld semantics are fuzzy enough that I do not treat this as a hard contradiction.

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 correctly front-loaded and the pricing/preview sentences earn their place, but the 'When' and 'Selection' clauses are duplicated boilerplate — 'prefer for Use when an agent needs hotel search from current travel offers..' is garbled and repeats the When line verbatim. Two of the roughly five sentences could be deleted with no loss.

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

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

An output schema exists, so return values need not be re-explained, and the description does cover the money/preview dimension that matters most for a paid tool. However, with 4 required and 9 total undocumented parameters and no stated alternatives in a 70+ tool sibling set, an agent still lacks enough to fill the call correctly or route confidently.

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

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

Schema description coverage is 0% across 9 parameters, and the description offers nothing beyond 'Input is a strict JSON object; see the schema'. It never explains destination format, checkIn/checkOut date format, nationality as ISO-2, the childAges/children coupling, or currency. Parameter names are partly self-explanatory and the schema carries patterns/constraints, but the description fails to compensate for the coverage gap.

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

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

Specific verb+resource: 'Search current hotel inventory' with a stated return payload ('normalized full-stay room rates and cancellation information'), which separates it from flight_search/flight_compare siblings by domain. The mangled 'Selection: supporting; prefer for ...' line is circular and adds no differentiation, but the core purpose sentence is 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 'When' clause is a tautology ('Use when an agent needs hotel search from current travel offers') — it restates the tool's own name rather than describing a triggering situation. No alternatives are named (compare_properties, trip_cost_estimate, flight_search), and no exclusions or prerequisites are given for what is presumably part of a travel-offer pipeline.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely new behavior: $0.20 USD per call, no free preview, paid execution via x402, and an unpaid MCP call returns payment instructions. That payment/authorization behavior is exactly the kind of thing annotations cannot express. It does not restate or contradict the hints.

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

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

The purpose sentence is correctly front-loaded, but the 'When' and 'Selection' lines are near-verbatim duplicates of each other, and the three pricing sentences are wordy ('Full execution is paid per call via x402; an unpaid MCP call returns payment instructions'). Roughly half the text is redundant.

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

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

An output schema exists so return values need not be described, and payment behavior is well covered. The gap is input-side: a 14-field, single-required-field tool gives the agent no guidance on what counts as an 'observation' or how fields like ageRange/incomeLevel should be expressed, which the schema does not resolve on its own.

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 14 parameters and 0% schema description coverage, the description must carry the semantic load, but it only says 'Input is a strict JSON object; see the schema.' Field meanings such as triggers, objections, buyingBehavior, and the governorate/city distinction are left entirely to field names. No format, units, or examples are offered.

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 clause gives a concrete verb+resource ('structure an ideal-customer profile from supplied observations') and adds a real scope boundary ('does not infer verified demographics'). That is enough for an agent to distinguish it from sibling profile builders like extract_candidate_profile or generate_job_profile, though the tool never names an alternative directly.

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 'When' clause is circular: 'Use when an agent needs the Creative Techno book framework for ideal customer profile' just restates the name. 'Selection: supporting; prefer for <the same sentence>' is broken text that conveys nothing. No prerequisites, no when-not, no real alternatives are given.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds value beyond that: output shape (0–100 risk score, risk level, advisory decision continue/review/hold, machine-readable anomaly codes with severity/confidence/evidence), the deterministic decimal-safe guarantee, and the pricing/payment model (x402, unpaid calls return payment instructions, $0.25/call). It omits rate limits and exact latency, which keeps it below 5.

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

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

The description is front-loaded with the core purpose and output contract, then usage, selection, exclusions, pricing. It is longer than strictly necessary, and the pricing/payment paragraph sits alongside the functional content, but every sentence informs an agent decision. Minor structural clutter (input-schema note) prevents 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?

Given the complexity (8 top-level params, nested objects, output schema present), the description covers what the tool does, when to use it, what it returns at a high level, its deterministic/country/currency scope, and the payment/preview flow. Since an output schema exists, it does not need to enumerate return fields, and it correctly doesn't. Nothing needed to invoke correctly is missing.

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

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

Schema coverage is 75% and nested, so the schema carries most of the burden; the description still adds meaning by naming the optional context inputs (historical invoices, supplier profile, PO, contract, approval threshold, payment history) and clarifying standalone vs. context-aware modes. It does not explain the options block (asOfDate, duplicateWindowDays, minHistoryForPatterns), which the schema covers, so this is a solid 4 rather than 5.

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

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

The description uses specific verbs (detect, returns) and names the exact resource (duplicate, inconsistent, unusual, or fraudulent invoices) plus the check types (arithmetic, supplier-history, PO, payment-detail). It also explicitly distinguishes itself from siblings by naming company_due_diligence-adjacent exclusion: 'Do not use for company-level due diligence or extracting arbitrary document facts', separating it from analyze_company_risk and document_facts_extract.

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

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

Provides an explicit 'When' section (before approving, paying, booking, reconciling, auditing) and a 'Selection' note ('primary; prefer for invoice review before payment or duplicate and arithmetic checks'), plus explicit exclusions ('Do not use for company-level due diligence or extracting arbitrary document facts'). The preview_capability mention further routes the agent before a paid call.

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

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

Annotations already declare a safe, idempotent, read-only operation, and the description adds genuinely non-obvious context: it is not accounting advice, costs $0.15 per call via x402, and an unpaid call returns payment instructions. That payment/authorization behavior is exactly the kind of trait annotations do not cover.

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

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

The purpose is front-loaded, but the 'When'/'Selection' pair is duplicative and effectively repeats the same phrase twice, wasting space. Payment details are useful but the section is padded with circular boilerplate.

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

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

An output schema exists, so return values need not be described, and the schema carries parameter detail. The description covers the essentials an agent needs (purpose, cost, payment behavior, JSON input) and only leaves the usage-routing guidance thin.

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

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

Schema description coverage is 67%, so the schema documents most fields (OMR units, baisa internal calc, currency bounds). The description only says 'Input is a strict JSON object; see the schema,' adding no per-parameter meaning, which is the expected baseline when the schema does most of the work.

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

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

States a specific verb+resource ('Generate a monthly business financial report') and the input source ('supplied OMR figures'), which is concrete. However, it does not differentiate itself from close siblings like business_profitability_analysis, break_even_calculator, or strategy_performance_analysis, all of which operate on business financials.

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 'When' clause is circular ('Use when an agent needs the Creative Techno book framework for monthly business financial report') and the 'Selection' line simply restates it ('supporting; prefer for Use when...'). No real condition, exclusion, or named alternative is given, so an agent has little to route on.

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 mutation/idempotency profile, and the description adds information they cannot carry: $1.50 USD per call, paid execution via x402, that an unpaid MCP call returns payment instructions rather than running, and that preview_capability offers a free preview. It does not explain what the destructiveHint implies here (e.g. credit consumption on failure), but cost and payment behavior are genuinely useful for invocation decisions.

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 sentences are front-loaded and short, but the 'Selection:' fragment duplicates a clause verbatim and reads as a template that failed to render, which wastes space and confuses the reader. Removing that one broken clause would make the description tight.

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

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

An output schema exists, so return values need no explanation, and the description covers scope, preconditions, pricing and payment failure behavior. The remaining gap is that the many tunable generation parameters are entirely undocumented, though the agent can still call the tool correctly using required fields and schema defaults.

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

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

Schema description coverage is 0% across 10 parameters, so the description must carry the load, and it mostly defers: 'Input is a strict JSON object; see the schema.' Its only substantive contribution is naming the four required fields (headline, summary, facts, sourceUrls) in prose, which partially maps to the required set. Optional parameters such as voice, aspectRatio, durationSeconds, language, subtitles and backgroundMusic are unexplained anywhere.

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

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

States a specific verb and resource — turning supplied factual news content into a publish-ready short-form news video — and scopes it against research/fabrication, which separates it from siblings like product_promo_video and social_video_generate. It never names those siblings, so an agent must infer the boundary from the 'news' qualifier alone.

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

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

The 'When:' clause gives a concrete precondition — the agent already holds a verified headline, summary, facts and source URLs — which is a real gating condition. The 'Selection:' clause is meant to supply the alternatives/exclusions but is instead a garbled restatement of the same sentence, so no sibling routing or 'do not use when' guidance is delivered.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld=false, and the description adds genuinely new operational context: $0.20 per call, no free preview, x402 paid execution, and that an unpaid call returns payment instructions. The 'never invents scarcity' rule also constrains generated output. It stops short of describing the returned artifact, though an output schema exists.

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

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

The 'When' and 'Selection' sentences are near-duplicates of each other and of the tool name, and 'Input is a strict JSON object; see the schema' is filler. Only the pricing/x402 sentence earns its place, so roughly half the text is wasted and the duplicated phrasing obscures the front-loaded 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?

With an output schema present, return values need no explanation, and the payment model is fully disclosed. The gaps are the useless usage guidance and the near-absent parameter semantics for a 10-parameter, 5-required tool, leaving it only minimally adequate for an agent to invoke correctly.

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

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

Schema description coverage is only 10% (just priceOMR), so the description must carry the load, and it does not. It gestures at three inputs ('outcome, bundle and delivery terms') but leaves product, customer, bonuses, guarantee, genuineScarcity and language — including the only enum — undocumented in either place.

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 clause gives a specific verb and resource — 'Construct a commercial offer from supplied outcome, bundle and delivery terms' — which is far better than a name restatement, and 'never invents scarcity' adds a meaningful constraint. It does not differentiate itself from adjacent generators like sales_response_builder or business_model_builder, and the 'Creative Techno book framework' reference is unexplained jargon.

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 'When:' clause is circular — 'Use when an agent needs the Creative Techno book framework for offer builder' restates the tool name rather than giving a trigger condition. 'Selection: supporting; prefer for...' repeats the same circular sentence and names no alternative or exclusion, so an agent gets no real routing signal.

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, idempotent, non-destructive), and the description adds genuinely new invocation context: $0.50 USD per call, no free preview, x402 paid execution, and that an unpaid call returns payment instructions. That prevents an agent from misreading a payment failure as a tool error, though nothing is said about what the computation does or returns.

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

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

It is short, but a full clause is duplicated verbatim ('prefer for Use when an agent needs the Creative Techno book framework for oman business launch advisor..'), including a stray double period. Two of five sentences convey no information, which is waste rather than conciseness.

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

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

An output schema exists so return values need not be explained, but for a 14-parameter, 11-required computation tool the description leaves the agent with no idea how to populate the required inputs or what distinguishes this from the many planning siblings. The paid-invocation note is the only complete piece of information.

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

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

Schema description coverage is only 43% and 11 of 14 parameters are required, yet the description offers nothing beyond 'Input is a strict JSON object; see the schema.' It gives no meaning for the 15-boolean 'answers' array, the free-text fields, or the OMR cost inputs, so it does not compensate for the coverage gap at all.

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 does name the domains it combines (readiness, idea validation, finance, launch logic) for an Oman founder workflow, which is more than a tautology. However, it never says what artifact it produces, and with siblings like oman_business_launch_plan, final_business_plan_builder, and startup_readiness_score in the same namespace, an agent cannot tell them apart from this text.

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

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

The 'When:' clause is circular - 'Use when an agent needs the Creative Techno book framework for oman business launch advisor' simply restates the tool name. The 'Selection: supporting; prefer for ...' sentence duplicates the same circular phrase and names no alternative tool or condition. No when-not guidance exists.

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