IranTools (paid)

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

With no annotations, the description carries the full burden. It usefully discloses the commercial model ('Auth mode: paid', '$0.005 per call'), which is real behavioral context. But it never states the return type, and critically never resolves which calendar the year/month/day inputs use (Gregorian vs Jalali) or what 'weekend' means for the Iranian locale.

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 functional content is a single sentence that is duplicated verbatim as both 'Summary' and 'Source description'. It is wrapped in origin URLs, hostnames, brand strings, family keys, endpoint paths, keyword lists, and pricing, so the actual signal is buried and not front-loaded.

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

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

For a 2-parameter tool with 0% schema coverage, nested objects, no annotations, and no output schema, the description should pin down the calendar system, the definition of a weekend, and the result shape. None of these are addressed, so an agent cannot call it with confidence.

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 both parameters are nested {year, month, day} objects with no ranges, no descriptions, and no calendar indicator. The description adds nothing beyond implying 'from' and 'to' are dates, so it fails to compensate for the coverage gap on a genuinely ambiguous input shape.

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 core sentence 'Count business days between two dates (weekends excluded)' gives a specific verb and resource with a scope qualifier. It does not, however, differentiate from adjacent siblings such as iran_holiday_check or iran_holidays, leaving the agent to infer whether holiday-aware counting exists elsewhere.

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 three 'Use case' lines sketch plausible contexts (delivery estimates, task duration), which is more than nothing. But there are no exclusions or named alternatives, and one use case ('add working days to a deadline') describes an operation the from/to signature cannot perform, which is mildly misleading.

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 no annotations, the description carries the full behavioral burden, and it does disclose genuinely useful facts: auth mode is paid and each call costs $0.005 via x402/MPP, plus the HTTP endpoint. It does not describe error behavior, input validation, or the response shape, so the disclosure is partial.

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 bloated with origin URL, hostname, brand, provider aliases, family key and repeated keyword lines, and the actual functional summary is buried in the middle. The useful content could fit in two sentences; most of the payload 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?

It specifies the returned fields, pricing and auth, which is adequate context for a pure date-computation tool with no output schema. The gaps are the undocumented required parameters and any failure/validation behavior.

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 description never explains year/month/day — no ranges, no whether month is 1-12, no format expectations, even though all three are required. For a low-coverage schema the description should compensate, and here 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 Summary line states a specific verb+resource and enumerates the outputs (weekday, ISO week, day of year, quarter, leap year, weekend), which lets an agent distinguish it from siblings like business_days, iran_holiday_check, and gregorian_to_jalali. It is clear but never explicitly contrasts itself with those neighbours, so it falls short of the top score.

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 'Use case' lines (find ISO week, check weekend/leap year, get quarter and day of year) give concrete scenarios, so usage is implied rather than absent. However there is no guidance on when to prefer this over business_days or iran_holiday_check, and no stated exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden. It discloses payment/auth behavior ('Auth mode: paid', '$0.005 per call'), which is useful, but it does not explicitly state that detection is read-only or describe return format, error behavior, or idempotency.

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

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

The definition is bloated with origin URL, provider branding, endpoint metadata, keywords, and pricing rather than being front-loaded with the tool's purpose. The core description is buried, and many lines do not help an agent select or invoke the tool.

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

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

For a simple one-parameter tool with no output schema and 0% schema description coverage, the description should clarify the parameter format and return value. It names possible encodings, which partially implies outputs, but leaves the 'bytes' input format unexplained and omits how results are returned.

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 explain the single 'bytes' parameter. It calls it a 'byte string' and lists encodings to detect, but does not clarify the expected array-of-numbers format, ranges, or whether hex/base64 strings are accepted.

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: 'Detect the encoding of a byte string' and enumerates the possible encodings (ascii, utf-8, utf-16, hex, base64, latin-1). It is clear what the tool does, but it does not differentiate itself from close siblings like detect_format or script_detect.

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 concrete use cases such as detecting whether a string is UTF-8, finding the encoding of a payload read from a file, and decoding a base64 blob. It gives clear context for when to use the tool, though it does not mention when not to use it or name alternative 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?

No annotations are provided, so the description carries the full burden. It does add genuine behavioral context by disclosing the auth mode ('paid') and price ($0.005 per call via x402/MPP), which the agent cannot get from structured fields. It omits, however, what the tool returns (e.g. a format label vs. a structured object), how ambiguous or unrecognized strings are handled, and whether detection is locale/length constrained.

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 payload is dominated by machine-generated keyword spam ('Keyword: uuid', 'Keyword: email validation', etc.), origin URL/hostname/brand metadata, and a duplicated summary ('Summary' and 'Source description' are identical strings). The actual purpose is buried after the origin boilerplate rather than front-loaded, so structure works against fast scanning.

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 one-parameter, no-output-schema utility, the description supplies enough to attempt a correct call: it names the input as a string, lists supported formats, and gives use cases. It is incomplete in that nothing describes the return value (format name, confidence, or 'unknown' handling) and the parameter itself is undocumented in both schema and description.

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

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

Schema description coverage is 0% and the single 'value' parameter has no description in the schema. The description partially compensates by framing the input as a string whose format is being detected, but it never names the parameter or clarifies expected input shape (encoding, length limits, single vs. multiple values). Baseline-adequate but not additive.

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 summary line states a specific verb and resource ('Detect the format of a string') and enumerates the detectable formats (uuid, email, url, ipv4, ipv6, jwt, iban, mac, semver), which lets an agent distinguish it from adjacent siblings like detect_encoding (charset) and script_detect (writing system). It stops short of explicitly naming those siblings, so the differentiation is implied rather than stated.

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 three 'Use case' lines give concrete scenarios ('tell me whether this string is a UUID, an email or a JWT', 'detect the format of a token before parsing it'), which conveys when the tool applies. However, there is no guidance on when NOT to use it or how it differs from script_detect/detect_encoding for overlapping inputs, so the routing guidance is only implicit.

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?

No annotations are provided, but the description adds useful invocation context such as POST endpoint, paid auth mode, and per-call price. It does not describe return type beyond bits per character, error behavior, or whether the operation is deterministic, so it only partially carries the behavioral burden.

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 heavily bloated with origin URLs, hostnames, brand metadata, family keys, endpoint details, repeated keywords, and pricing. The useful purpose statement is buried among metadata, so many 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?

For a simple one-parameter computation tool with no output schema, the description provides enough context: what it computes, the unit of output, use cases, auth mode, and price. Missing edge-case behavior and explicit output format are minor gaps.

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

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

There is one required parameter, text, and schema description coverage is 0%. The description implies the input is a string but does not explicitly document parameter constraints, encoding expectations, or empty-string behavior. With a single obvious parameter, this is minimally adequate rather than compensating fully for the schema 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 clearly identifies the operation as computing Shannon entropy of a string in bits per character. It uses specific keywords and use cases, though it does not explicitly differentiate itself from text-analysis siblings such as detect_encoding or script_detect.

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 use case lines give clear contexts for when to use it: measuring randomness, scoring password/token entropy, and checking whether an identifier looks machine-generated. It does not provide explicit exclusions or name alternative tools, so it falls short of a 5.

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

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

With no annotations, the description must carry behavioral burden; it usefully discloses 'Auth mode: paid' and the exact price ($0.003/call via x402/MPP), which an agent genuinely needs. However it says nothing about the output/return behavior of the transform, so the disclosure is partial.

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

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

The text is a metadata dump (origin URL, hostname, brand, family key, endpoint, repeated keywords) with the actual purpose appearing late as 'Summary'. The summary is duplicated verbatim as 'Source description', and keywords/use cases are itemized redundantly.

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

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

For a single-parameter text transform with no output schema, the description covers purpose, triggering scenarios, auth, and cost, which is most of what an agent needs. It omits the return value and any parameter format detail, leaving gaps.

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

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

There is 1 required parameter ('text') at 0% schema description coverage, so the description must compensate. It only implies the input is a Persian/Arabic string mixing scripts, giving no format, length, or encoding guidance for the parameter.

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

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

The embedded summary states a specific verb and resource: 'Fix bidirectional text rendering in Persian/Arabic strings by isolating LTR runs.' This is distinct from siblings like persian_normalize or persian_digits, though the meaning is buried under origin/endpoint metadata rather than stated up front.

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?

Three explicit 'Use case' lines give concrete scenarios (mixed English/Persian strings, numbers/Latin appearing out of order, repairing text before display), which is strong when-to-use context. No when-not or named 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?

With no annotations, the description carries the full burden. It does disclose genuinely useful behavioral facts – auth mode is paid and each call costs $0.003 via x402/MPP – but never states the return format (hex string? both bit widths? how a width is selected) or any limits, which matters for a tool with no output schema.

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

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

Badly bloated: origin URL, hostname, brand, aliases, family key, endpoint, five keyword lines, and three use-case lines precede/pad the one substantive sentence. The lead is provider boilerplate instead of the tool's purpose, so the reader must scan to find 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?

For a one-parameter hash tool this is only partially complete: cost and auth are covered, but with no output schema and no annotations the description should explain what is returned and how 32- vs 64-bit output is chosen. It leaves those gaps.

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

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

The single 'text' parameter has 0% schema description coverage, so the description must compensate. It implies the input is the content to fingerprint, but it adds no format detail, and the '(32 and 64 bit)' claim references a choice that no parameter exposes, creating ambiguity rather than clarity.

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 core line 'Compute a stable FNV-1a content fingerprint (32 and 64 bit)' gives a specific verb and resource, and 'fnv_hash' is clearly distinguishable from siblings like entropy or detect_format. However, the purpose is buried under provider metadata and SEO keywords rather than stated up front.

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?

Three use cases are listed (cache keys, hashing without a crypto dependency, comparing payloads by 32-bit fingerprint), which implies when to reach for it. But there are no exclusions and no routing against siblings such as entropy or detect_format, so an agent still has to infer the boundary.

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 no annotations, the description carries the full burden. It usefully discloses auth mode ('paid') and price ($0.003/call via x402/MPP) plus the POST endpoint, which are real behavioral facts absent from the schema. However it omits error behavior, rate limits, and any explicit statement of the returned fields, so it only partially covers the burden.

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

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

The text is a metadata dump (origin URL, hostname, brand, aliases, family key, repeated keyword lines, price) with the genuinely useful Summary and use cases buried mid-block. Several keyword/value lines are redundant and no sentence beyond the summary and use cases earns its place.

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

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

For a single-argument utility with no output schema or annotations, the description supplies purpose, scenarios, and cost, which is a reasonable minimum. It still leaves the return shape and parameter semantics unstated, so it is complete enough to call but not fully specified.

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 one parameter ('text') with 0% schema description coverage, so the schema gives no semantics. The summary and use cases imply the argument is the string to analyze, so the description adds some meaning, but it never states the parameter's role or constraints explicitly.

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 Summary line gives a specific verb and resource: 'Count user-perceived characters (graphemes) versus code points, UTF-16 units and bytes.' That is far clearer than the tool name alone and tells an agent exactly what distinguishes this from a plain string-length tool. It does not, however, explicitly differentiate itself from siblings like human_bytes, unicode_normalize, or detect_encoding, and the signal is buried under provider metadata.

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?

Three 'Use case' lines indicate plausible scenarios (emoji-containing strings, DB length limits, code-point vs perceived length), which implies when the tool is relevant. But there is no explicit selection guidance versus the many sibling utilities, and no when-not-to-use or alternative 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?

With no annotations, the description carries the full burden. It usefully discloses that the server is paid, the auth mode, and the exact price ($0.003 per call via x402/MPP), which is meaningful behavioral context an agent needs. But it says nothing about input validation ranges, error behavior, or supported date bounds.

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 summary sentence is front-loaded and clear, but the bulk is metadata noise: origin URL, hostname, brand, provider aliases, family key, endpoint, repeated keyword lines, and largely redundant use cases. This bloats a one-line conversion tool's description with low-value content.

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

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

For a simple 3-param conversion tool with no output schema it covers the core operation, direction, and payment requirement. The gaps are the undocumented parameter ranges/format and lack of any statement about the return value's shape, though the use-case examples partly convey the output.

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

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

Schema coverage is 0% and the three required params (year, month, day) have no descriptions. The description only implies format via the example 'convert 2026-03-21 to 1405-01-01', leaving accepted ranges, negative/zero handling, and input format (numeric vs string) 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 summary states a specific verb+resource with an unambiguous direction: 'Convert a Gregorian date to the Iranian Jalali (Solar Hijri) calendar.' The direction inherently distinguishes it from the sibling jalali_to_gregorian without needing to name it.

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 concrete usage context ('Use for any Iranian date, holiday or deadline') and lists four use cases covering today's date, a specific date, a deadline, and a birth date. However, it never states when NOT to use it or explicitly names jalali_to_gregorian as the alternative for the reverse direction.

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

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

No annotations exist, so the description carries the full burden. It usefully discloses auth mode (paid) and cost ($0.005 per call via x402/MPP) plus the ASCII-folding transformation, which the annotations do not cover. It says nothing about the return shape, whether folding is lossy, or error behavior, leaving real gaps for a no-annotation tool.

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

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

The functional Summary is buried under boilerplate that a selecting agent does not need: Origin URL, hostname, brand, provider aliases, family key, and endpoint. Six redundant 'Keyword' lines restate the same concepts. The useful content is present but poorly front-loaded and padded.

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 one-parameter, no-output-schema tool, the description plus use cases adequately explain what the agent gets: ASCII-folded text for spoof detection. It still omits output format and edge-case behavior, which would matter for correct downstream comparison.

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 the single 'text' parameter, so the schema adds nothing. The description partially compensates by showing the expected input form (a domain/username string such as pаypal.com), but never states whether it accepts a bare domain, a full URL, or arbitrary text.

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

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

The Summary line states a specific verb and resource: 'Fold Unicode homoglyphs to ASCII to detect spoofed domains, usernames and handles', with a concrete example (Cyrillic а in pаypal.com). It is clear what the tool does. It does not, however, explicitly distinguish itself from plausible siblings like unicode_normalize or script_detect, so it stops short of a 5.

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

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

Four 'Use case' lines give solid when-to-use context: check a spoofing domain, detect a lookalike username, fold before comparing against a blocklist, and flag an IDN homograph. This is clear contextual guidance. There are no exclusions or explicit routing away from sibling tools, so it is not a 5.

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

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

No annotations are provided, so the description carries the full disclosure burden. It usefully reveals the auth/payment model ('paid', '$0.003 per call', x402/MPP) which an agent needs before invoking, but says nothing about determinism, edge cases (zero/negative bytes), or the return format beyond the one-line summary.

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?

Only one sentence describes the actual operation; the rest is marketplace metadata (origin URL, hostname, brand, provider aliases, family key, endpoint, four keyword lines, price). It is bloated and front-loads provenance and pricing ahead of the functional behavior.

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 one-parameter, no-output-schema utility the description covers the basic contract and adds payment context, so it is close to adequate. The notable gap is byte/unit semantics (decimal MB vs binary MiB, rounding), which is exactly the ambiguity a formatter must resolve.

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 single 'bytes' parameter has 0% schema description coverage, so the description must compensate. The example '1048576 bytes as 1 MB' and the mention of 'mebibytes' faintly hint at decimal-vs-binary unit behavior, but the description never documents the accepted input format or the choice between MB and MiB.

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 core sentence 'Format a byte count as a human-readable size' states a specific verb and resource, and the Source description restates it consistently. It is clear what the tool does, though the definition offers no differentiation from the many other text/number formatting siblings in the list.

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

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

Three concrete use-case lines ('format 1048576 bytes as 1 MB', 'render a file size for a UI', 'convert a byte count into kilobytes and mebibytes') imply when the tool applies. However, there is no explicit when-not guidance and no routing to any of the ~30 sibling tools that overlap in the text-formatting family.

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 no annotations, the description carries the full burden and does unusually well on the operational side: it discloses that the server is paid ('Auth mode: paid') and gives the exact cost and payment rails ($0.005 per call, USDC on Base via x402 or Tempo via MPP). It stops short of describing the returned string format or error behavior for invalid amounts.

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 functional sentence is buried under machine-generated marketplace boilerplate: origin URL, hostname, brand, provider aliases, family key, endpoint, four keyword lines, and three near-duplicate use cases. The leading line is an origin URL rather than the purpose, so the payload is not front-loaded.

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

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

For a simple two-parameter tool with no output schema and no annotations, the description covers purpose, unit choice, and payment/auth requirements, which is most of what is needed. It omits the return shape, the relationship to the sibling number_to_words_fa, and any amount-format constraints.

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. It names the two unit values ('toman or rial') and gives a concrete amount example ('write 125000 tomans'), which loosely mirrors the enum and clarifies the numeric scale, but it never explains whether 'amount' is interpreted in the selected unit or whether fractional/decimal values are acceptable.

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 summary states a specific verb and resource: 'Spell an amount in Persian words with the correct unit (toman or rial).' This is clear enough to distinguish it from generic word-spelling siblings, though it never names the closest sibling (number_to_words_fa) to draw the currency-vs-plain-number 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?

Usage is implied rather than prescribed: 'Use for invoices and payment memos' plus three use cases set context, but there is no when-not guidance and no pointer to the alternative (number_to_words_fa for non-currency numbers, rial_toman_convert for conversions).

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 no annotations, the description carries the full burden. It does disclose a genuine behavioral trait: 'Auth mode: paid' plus the per-call price and payment rails (x402/MPP), which the agent must handle before calling. Beyond that it says nothing about error behavior on an invalid PAN, rate limits, or whether unknown issuers are returned, leaving real gaps.

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 with boilerplate: origin URL/hostname/brand, provider aliases, family key, endpoint, five repeated 'Keyword' lines, aliases that duplicate use cases, and the source description repeated verbatim. The actual purpose is one line buried in noise, so structure is poor and much of the content is redundant.

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

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

For a simple one-parameter validator with no output schema, the description does convey the operation, input format, and that it reports the issuing bank. Missing are return-shape details (e.g. valid/invalid boolean plus issuer name) and error handling, so it is adequate but not 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 the single 'value' parameter, so the description must compensate. It partially does by stating the expected input is a '16-digit PAN', which tells the agent the format. It adds no syntax details (spaces, dashes, Persian digits) beyond that, so it only partially fills the gap.

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

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

The 'Summary'/'Source description' lines state a specific verb+resource: 'Validate an Iranian bank card number (16-digit PAN) with the Luhn checksum and report the issuing bank.' That is clear and distinguishes it from sibling validators like iran_sheba or iran_national_id. However, the signal is buried inside a large metadata dump rather than front-loaded, so it is not a clean 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?

Three 'Use case' lines describe the scenario (validate a card, run Luhn, identify issuer), giving implied context for when to use it. But there is no explicit contrast with siblings (e.g. when to prefer this over iran_sheba) and no exclusions, so guidance stops at implied usage.

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 no annotations, the description carries the full burden. It does disclose genuinely useful behavioral facts: 'Auth mode: paid' and a price of $0.003 per call via x402/MPP, plus what the response contains (province and region). It says nothing about miss behavior (unknown city), match semantics, 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 payload is buried under boilerplate: origin URL, hostname, brand, aliases, family key, endpoint, four keyword lines, three use-case lines, then the same summary sentence repeated as 'Source description'. The one useful sentence appears three times, and front-loading is destroyed by metadata scaffolding.

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 one-parameter, no-output-schema lookup, the essentials are present: input language flexibility, returned fields, and the payment requirement. Missing are not-found behavior and matching rules, which an agent would need to interpret results correctly.

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

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

Schema coverage is 0% on the single 'name' parameter, so the description must compensate. It does add real meaning — the name may be Persian or English — but omits exact-vs-fuzzy matching, case handling, and diacritic/normalization expectations, leaving the lookup contract partially undefined.

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 summary sentence states a specific verb and resource: 'Look up an Iranian city by Persian or English name and return its province and region.' The keyword 'which province is this city in' and the use cases separate it from iran_province and iran_provinces_list, though no sibling is ever named 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?

Three concrete use cases ('find which province Shiraz belongs to', 'look up by Persian name', 'get the region') imply when to call it, but there is no explicit when-not or routing to iran_province / iran_provinces_list for province-level queries.

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 no annotations, the description must carry the full behavioral burden. It does disclose that the endpoint is paid, the auth mode is paid, and the price is $0.003 per call, which is useful behavioral context. But it does not explain return values, side effects, rate limits, or error behavior for a validation operation.

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 bloated with origin URL, hostname, brand, family key, endpoint, repeated keywords, and pricing metadata. While some information is useful, much of it does not help an agent select or invoke the tool, and the core summary is not front-loaded.

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

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

For a simple one-parameter validator with no output schema, the description should explain what the tool returns and how the input should be formatted. It provides use cases, auth, and pricing, but omits return values and parameter syntax, leaving key invocation details incomplete.

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

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

There is one required parameter named 'value' with 0% schema description coverage. The description implies that 'value' is the Iranian company registration id, but it provides no format details, length constraints, digit rules, or examples to compensate for the empty 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: 'Validate an Iranian company registration id (شناسه ملی اشخاص حقوقی).' It also lists aliases and keywords that clarify the resource. However, it does not explicitly contrast the tool with nearby siblings like iran_national_id or iran_economic_code, so sibling differentiation 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?

Three concrete use cases are provided: supplier forms, checking a شناسه ملی for a legal entity, and merchant onboarding. This gives clear usage context, but the description does not state when not to use the tool or explicitly name alternative sibling tools for related identifiers.

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 no annotations, the description does add some real behavioral context beyond the schema: 'Auth mode: paid' and the $0.003/call pricing over x402/MPP, which an agent needs to know before invoking. However, it says nothing about the validation result semantics (what a pass/fail looks like) or any error behavior, leaving the core behavior undisclosed.

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 bulk is machine-generated boilerplate — origin URL, hostname, brand, provider aliases, family key, endpoint — that is irrelevant to selecting or invoking the tool. The actual purpose sentence is buried in the middle under 'Summary' rather than front-loaded.

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

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

There is no output schema and no annotations, so the description should explain what validation returns (valid/invalid, normalized value, control-digit detail), and it does not. For a tool whose entire value is a boolean-ish check, that omission leaves the agent guessing at the result shape.

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 bare 'value' string with no constraints. The description only indirectly implies that 'value' is an economic code; it adds no format, length, or digit rules to compensate for the schema 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 Summary line gives a specific verb+resource: 'Validate an Iranian economic code (کد اقتصادی) with its control-digit check,' and the use cases reinforce the exact resource. It is distinguishable from sibling validators like iran_company_id and iran_national_id by naming the economic code, though that differentiation 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?

Three use cases (tax form validation, control-digit check, vendor tax identifier verification) give context for when to call it, but there is no guidance on when to prefer this over sibling Iran validators such as iran_company_id or iran_national_id, 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?

With no annotations, the description carries the full burden. It usefully discloses that this is a paid endpoint ($0.003 per call via x402/MPP) and the transport (POST /api/iran/iran_holiday_check), which is genuinely valuable operational context. It says nothing about rate limits, error behavior for malformed dates, timezone handling, or whether a non-holiday date returns a negative flag or an error.

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 entry is dominated by boilerplate metadata (Origin URL, origin hostname, brand, provider aliases, family key, endpoint) while the actually useful sentence is repeated verbatim under both 'Summary' and 'Source description'. The functional content is not front-loaded and the payload is roughly 80% infrastructure noise.

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

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

For a simple three-parameter read-only tool, the definition covers auth mode, price, endpoint, calendar system, and example uses, which is the minimum an agent needs to invoke it. It remains incomplete on the return shape ('name it if so' is vague) and on invalid-date handling, and there is no output schema to fill that 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 all three required numeric params (year, month, day), so the description must compensate. It does clarify the one ambiguity that matters most by specifying these are Gregorian date components rather than Jalali, but it adds no ranges, validation rules, or format guidance, leaving the rest 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 functional summary states a specific verb and resource: check whether a Gregorian date is an Iranian public holiday and name it. That is clear and actionable, but the definition never distinguishes itself from the near-identical sibling iran_holidays, nor from business_days or gregorian_to_jalali, leaving overlap unresolved.

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 'Use case' and 'Keyword' lines imply when the tool applies (e.g. checking the status of 2026-03-21), which is better than nothing. However, there is no explicit when-to-use vs the sibling iran_holidays, no statement about valid date ranges, and no exclusions, so selection between the two holiday tools remains a guess.

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 no annotations, the description carries the full burden, and it does disclose material operational facts: 'Auth mode: paid' and exact pricing ($0.005 per call via x402/MPP). However, it says nothing about return format, whether holidays include Gregorian dates, caching, or failure behavior.

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

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

The payload is dominated by auto-generated boilerplate — Origin URL, hostname, brand, endpoint, six keyword lines, and duplicated source description — before and around a single functional sentence. The useful summary is present but buried under low-value metadata.

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 one-parameter read tool with no output schema, the description covers purpose, a Jalali-year example, and the paid auth requirement. It still leaves the return shape (holiday names, Gregorian equivalents, whether Nowruz spans multiple days) 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% for the single 'year' parameter, so the description must compensate. It partially does, by framing the value as a 'Jalali year' and the example 'Jalali year 1405' implying the number format (no 1xxx ambiguity resolution beyond that), but the accepted range and boundaries are never stated.

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 summary states a clear verb and resource: 'List the official Iranian public holidays for a Jalali year, including Nowruz and religious occasions.' It is distinguishable from the singular sibling iran_holiday_check (which checks one date), but it never names or routes to that sibling explicitly.

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

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

Three 'Use case' lines give context (list holidays for Jalali 1405, check whether Nowruz is a working day, get the yearly calendar), but all three restate the same retrieval scenario rather than differentiating from iran_holiday_check or business_days. No when-not guidance or exclusions 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?

With no annotations, the description carries the full burden, and it does disclose non-obvious behavior: paid auth mode and exact cost ($0.003/call via x402 or MPP), plus the POST endpoint. However, it says nothing about behavior on invalid input, error responses, 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 text is dominated by machine-generated metadata (origin URL, hostname, brand, family key, repeated 'Keyword:' lines that restate the same concept five times). The one sentence an agent actually needs is the Summary, which appears mid-block rather than first.

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

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

For a single-param validator with no output schema, the description does state what is returned (area code and city) and covers cost and transport. It stops short of describing error/invalid-number behavior and the exact response shape, which is the main remaining 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?

One required parameter ('value') with 0% schema description coverage, so the schema explains nothing. The description compensates partially by implying the expected input is a landline number in 0xx format, but gives no length, digit-set, or accepted-separator details.

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

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

The Summary line states a specific verb and resource: 'Validate an Iranian landline number (0xx) and report its area code and city.' That is clear and distinguishable from sibling iran_mobile by the 'landline' scope, though the useful sentence is buried under origin/hostname/brand metadata rather than front-loaded.

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

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

Three 'Use case' lines give concrete scenarios (validate a landline, map 021 to a city, check a region-prefixed fixed line). That is implied usage context, but there is no explicit guidance on when to prefer this over iran_mobile or iran_city, 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?

No annotations are provided, so the description carries the full burden. It usefully discloses that the tool is paid, the auth mode, and the price ($0.003 per call via x402/MPP), which is real behavioral context. However it says nothing about failure behavior for malformed numbers or what the response shape looks like beyond the operator.

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

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

The definition is dominated by boilerplate metadata: origin URL, hostname, brand, provider aliases, family key, endpoint, seven redundant keyword lines, and a source description that repeats the summary verbatim. The one functional sentence is not front-loaded, and the repeated keywords earn no space.

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

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

For a single-parameter validator with no output schema, the description covers the input format, the output (operator), and the cost/auth model, which is enough for an agent to call it correctly. Only edge-case behavior for invalid input is missing.

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

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

Schema description coverage is 0% with a single undocumented 'value' string parameter. The description partially compensates by specifying the expected format (09xxxxxxxxx), but adds no constraints on length, digit-only content, or whether the +98 prefix is accepted.

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 'Summary' line gives a specific verb and resource: validate an Iranian mobile number and report its operator (MCI, Irancell, MTN, Rightel). This clearly separates it from the iran_landline sibling, though the actual purpose is buried beneath a metadata dump of origin URL, hostname, brand and family key.

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?

Three 'Use case' lines imply when to reach for it (validate a number, identify the carrier, sanity-check before SMS), but there is no explicit when-not guidance and no sibling alternative is named (e.g. iran_landline for landlines). Usage is implied rather than directed.

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 no annotations, the description carries the full burden. It does add real behavioral facts beyond the schema: paid auth mode ($0.005 per call via x402/MPP on Base or Tempo) and the POST endpoint. But it never states the return shape (presumably a validity boolean) or what happens on an invalid input, leaving the core outcome opaque.

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?

Heavily bloated with SEO metadata: origin URL, hostname, brand, family key, five redundant keyword lines, and a duplicated summary/source-description pair. It opens with an irrelevant origin URL instead of the purpose, and the same sentence appears twice, wasting an agent's context budget.

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 one-parameter validator with no output schema and no annotations, the definition covers what it does, when to use it, and the payment model. It is still missing the return-value semantics and input format, which an agent needs to interpret results 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%, so the schema offers only 'value: string'. The description implies the parameter is the national ID / code melli, which is some added meaning, but gives no format guidance (digit count, Persian vs Latin digits, hyphens). 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?

The Summary line gives a specific verb+resource ('Validate an Iranian national ID (کد ملی) with the official checksum algorithm'), which is enough to separate it from siblings like iran_company_id, iran_mobile, or iran_sheba. However, this is buried under an origin-URL/hostname/brand preamble, so the agent must dig for the actual 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 description supplies concrete when-to-use context ('Use for identity forms and KYC checks', signup-form validation, pre-onboarding checks). It does not name alternative siblings or state exclusions, but the use cases are specific enough that an agent can route here confidently.

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?

No annotations are provided, so the description must carry the full behavioral burden, and it does disclose auth mode (paid) and price ($0.003/call via x402 or MPP), which are important pre-invocation facts. 'When recognised' also signals that unrecognized codes may yield only a validity result, though error/rate-limit behavior remains unstated.

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 entry is bloated with origin URL, hostname, brand, provider aliases, family key, endpoint, and four keyword lines, and the Summary/Source description repeat each other verbatim. The actual purpose is not front-loaded but buried after infrastructure metadata.

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

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

For a single-parameter validation tool with no output schema and no annotations, the description covers purpose, input format, payment/auth, and the general shape of the result (province and city on success). Only edge-case return behavior is left implicit, which is a minor 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?

With 1 parameter at 0% schema description coverage, the description must compensate and does add the key constraint ('10 digits') beyond the bare string type. However, it gives no example format and doesn't say whether Persian digits are accepted, so coverage is partial.

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 Summary line states a specific verb and resource: 'Validate an Iranian postal code (10 digits) and, when recognised, report the matching province and city.' That is specific enough to separate it from siblings like iran_city or iran_province, though the useful statement is buried under origin/hostname/family-key metadata.

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?

Three concrete use cases ('validate a postal code and tell me the province', 'check a کد پستی before shipping', 'confirm a 10-digit postcode is valid') give clear context for when to call it. There is no explicit exclusion or named alternative versus sibling tools, so it stops short of a 5.

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

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

No annotations are provided, so the description bears the full behavioral burden. It usefully discloses the auth mode (paid) and price ($0.003/call), which is genuinely behavioural context, but says nothing about name matching semantics (exact vs fuzzy, case sensitivity, Persian vs transliteration) or failure behavior for unknown provinces.

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 actual purpose sentence is one line buried after origin URL, hostname, brand, provider aliases and family key. Keyword and use-case lists repeat the summary instead of adding information, so much of the text 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?

For a one-parameter lookup with no output schema, stating the return fields (code, capital, region) and the accepted name forms covers most of what an agent needs. Only the matching semantics and the direct contrast with iran_provinces_list are 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 0% and the single 'name' parameter is a bare untyped string in the schema. The description partially compensates by saying the name may be Persian or English, but gives no guidance on accepted spellings, transliteration, or whether partial names match.

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: look up an Iranian province by Persian or English name and return its code, capital and region. However, one use case ('list the regions of Iran') blurs the boundary with the sibling iran_provinces_list, so it is not fully differentiated.

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?

Three use cases give implied usage context, which is more than nothing. But there is no explicit when-to-use/when-not guidance and no mention of iran_provinces_list for enumerating all 31 provinces, an obvious alternative an agent would need to choose between.

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 no annotations, the description carries the full burden and does disclose meaningful behavioral context: this is a paid call at $0.003 via x402/MPP and requires 'Auth mode: paid', which directly affects whether an agent should invoke it. It also names the return fields (codes, capitals, regions). It omits any note on output format or error behavior, keeping it short of a 5.

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

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

The actual summary is buried beneath boilerplate (Origin URL, hostname, brand, provider aliases, family key, endpoint) and five redundant 'Keyword' lines that merely restate the same intent. The core sentence is repeated three times (Summary, use cases, Source description), so much of the text 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?

For a zero-parameter, read-only list tool with no output schema, the description supplies what the agent needs: the exact cardinality (31 provinces) and the returned attributes (codes, capitals, regions), plus auth and cost. Only a note on output shape/ordering is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The schema is an empty object with no properties to document.

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 Summary and Source description both state a specific verb and resource: 'List all 31 Iranian provinces with their codes, capitals and regions.' That is far more precise than the name alone. It does not explicitly name the sibling iran_province (singular lookup) as its counterpart, so sibling differentiation is only implicit in the word 'all'.

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?

Two 'Use case' lines give implied context ('list every Iranian province', 'get a full province reference table'), which tells the agent roughly when this fits. However, there is no explicit when-not guidance and no reference to the iran_province sibling that would cover single-province lookups.

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 no annotations, the description carries the full burden. It usefully discloses the paid auth mode and exact price ('$0.005 per call ... via x402 or MPP') and the two validation algorithms applied, but it says nothing about the return format, error/invalid-input behavior, 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?

Heavily bloated with provider metadata (origin URL, hostname, brand, aliases, family key, endpoint, keyword lines), and the 'Summary' and 'Source description' sentences are verbatim duplicates. The actual purpose is buried after boilerplate rather than front-loaded.

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

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

For a simple one-parameter validator with no output schema, the definition conveys function, use cases, and cost, but it never explains what the validation result looks like. Since no output schema exists, that gap should have been filled by the description.

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

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

The single parameter 'value' has 0% schema description coverage, so the description must compensate and does not. It implies the input is a SHEBA/IBAN number but gives no format guidance (IR prefix, length, spaces, digits), leaving the agent to guess.

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 Summary states a specific verb and resource: 'Validate an Iranian SHEBA (IRAN IBAN) account number with both IBAN mod-97 and Iran-specific checksum checks.' This distinguishes it from sibling validators like iran_bank_card or iran_national_id, so an agent can pick it 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?

Three explicit use cases are given ('before a bank transfer', 'check for a valid mod-97 checksum', 'confirm a bank account number is well formed'), which clearly frame when to invoke it. There are no exclusions or named alternatives, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden and does disclose genuinely important behavior: 'Auth mode: paid' with a per-call price and payment rails (x402/USDC, MPP), which an agent must know before invoking. However, it says nothing about error handling for invalid dates, output format, or rate limits, so the behavioral picture is only partially covered.

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 body is dominated by machine-generated boilerplate — Origin URL, Origin hostname, Origin brand, Provider aliases, Family key, Endpoint — that has no bearing on tool selection, plus four repeated Keyword lines that restate the summary. The one useful sentence (Summary) is buried mid-block rather than front-loaded.

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

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

For a simple three-parameter conversion with no output schema, the description covers purpose, examples, and billing. It omits parameter bounds and, because there is no output schema, never states what the return value looks like (e.g. an ISO Gregorian date), which is the main remaining 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% for three required numeric parameters (year, month, day). The example '1404-12-29' implicitly maps to year=1404, month=12, day=29, which is modest help, but no ranges, bounds, validation rules, or note on whether year is a full Jalali year are given. The description does not compensate for the total schema-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 Summary line states a specific verb and resource: 'Convert a Jalali (Solar Hijri) date to the Gregorian calendar.' The direction is unambiguous even without an explicit contrast to the sibling gregorian_to_jalali, so the agent can distinguish them by the stated direction. It is clear but not actively differentiated from siblings.

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

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

Three use cases are given ('convert a Persian date such as 1404-12-29', 'find what March date a Persian date falls on', 'convert a Jalali lease expiry'), which implies when to reach for this tool. There is no statement of when NOT to use it, no mention of the inverse sibling, and no input-validation guidance (e.g. valid Jalali month range), so usage 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?

With no annotations, the description must carry the load, and it does disclose operational traits beyond the schema: auth mode is 'paid' and each call costs $0.005 via x402/MPP on Base or Tempo. That is genuinely useful cost/auth context rarely found in descriptions. It still does not say what happens at numeric limits or whether the operation is purely deterministic, which keeps it below a 5.

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

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

The payload is dominated by SEO/registry metadata (origin URL, hostname, brand, family key, endpoint, five keyword lines) and the Summary is duplicated verbatim under 'Source description'. The actual purpose is buried mid-block rather than front-loaded, so much of the text 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?

For a one-parameter pure text transformation with no output schema, the description supplies the example output, use cases, and pricing/auth — enough for an agent to call it correctly. The remaining gaps (numeric bounds, error behavior) are minor for a deterministic formatting utility.

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?

One parameter with 0% schema description coverage, so the description has to compensate and only partially does: the example conveys the intended numeric input, but there is no guidance on integer vs decimal, negatives, rounding, or an upper bound (relevant for very large amounts). Marginal value over the type-only 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 Summary states a specific verb and resource ('Spell a number out in Persian words') with a concrete input/output example (125000 -> "صد و بیست و پنج هزار"), so the transformation is unambiguous. However, it never differentiates itself from the near-identical sibling `iran_amount_to_words`, leaving the agent to guess which one applies to cheques/invoices.

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?

Three use cases are listed (cheque, invoice, contract), which gives implied context for when to call it. But there are no when-not conditions and no mention of the obvious alternative tool (`iran_amount_to_words` or `rial_toman_convert`), so routing guidance is incomplete.

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?

There are no annotations, so the description carries the full burden. It does disclose important operational facts — auth mode is paid and pricing is per call — plus the round-trip behavior of each direction. It says nothing about error handling, mixed-content input, or rate limits, leaving meaningful behavioral gaps for a no-annotation tool.

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

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

The payload is a metadata dump: origin URL, hostname, brand, aliases, family key, endpoint, and a Source description that verbatim duplicates the Summary. Keywords and use cases are also repeated in near-identical form. The actual functional content is buried well after six lines of registry bookkeeping, and every 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?

For a simple two-parameter, no-output-schema tool, the conversion semantics for `direction` are complete. The `text` parameter and any failure modes remain undocumented, and no output format is described, so an agent still has to guess at input handling — adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It thoroughly explains `direction` with worked examples for both enum values, but the required `text` parameter is never described — its expected shape, whether it accepts non-digit characters, or handling of mixed scripts is left entirely to inference.

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 Summary states a specific verb and resource — 'Convert digits between Persian/Arabic-Indic and ASCII' — and pins it with concrete examples (1405 → ۱۴۰۵, ۱۴۰۵ → 1405), which cleanly separates it from generic text tools in the sibling list. It does not explicitly differentiate itself from close siblings like persian_normalize or script_detect, so it stops short of a 5.

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

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

Three 'Use case' lines give contextual scenarios (Persian form filling, DB columns, script detection), which implies when to reach for it. However there are no exclusions or named alternatives, and the third use case ('detect which numeral script a number uses') overlaps with the sibling script_detect, which is potentially misleading rather than guiding.

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 no annotations, the description carries the burden and does disclose genuine behavioral context: 'Auth mode: paid' plus exact pricing ($0.005 per call, USDC on Base via x402 or Tempo via MPP) and the POST endpoint. However it says nothing about output shape, limits, rate limits, or error behavior for a tool that has no output schema.

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

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

The content is heavily padded with origin URL, origin hostname, brand boilerplate, provider aliases, family key, repeated keyword lines, and a 'Source description' that duplicates the Summary verbatim. The one actionable sentence is buried, so the reader must scan past noise to find it.

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

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

For a tool with no annotations and no output schema, the description covers the commercial/auth dimension well but leaves the functional contract thin: the undocumented 'limit' parameter and unknown return format are gaps an agent needs filled before invoking it 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 2 parameters, so the description must compensate but does not. 'text' is only implied by the task, and the 'limit' parameter (default 10) is never mentioned, nor is the input format or how many keywords come back.

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 Summary states a specific verb and resource – 'Extract the most frequent meaningful keywords from Persian text, with stopwords removed' – which clearly identifies the operation within a large sibling set dominated by Persian text utilities. The purpose is unambiguous, though scoping or removal of the metadata padding would sharpen it further.

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?

Three concrete use cases are given ('pull the main topics out of a Persian article', 'extract keywords from a Persian product description', 'summarise what a Persian document is about'), which tell the agent the situations this tool fits. No when-not-to-use or alternative tools are named, so it stops short of a 5.

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

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

No annotations are present, so the description carries the full burden. It does disclose genuinely useful non-obvious behavior — 'Auth mode: paid' and '$0.003 per call (USDC on Base via x402, or USDC on Tempo via MPP)' — which an agent must know before calling. It says nothing about idempotency, reversibility, or output shape, leaving gaps for a transformation tool with zero annotation coverage.

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 payload is heavily padded with SEO-style metadata: origin URL, hostname, brand, provider aliases, eight keyword lines, and a 'Source description' that verbatim repeats the Summary. The actual purpose is buried after boilerplate instead of front-loaded, and the repetition costs readability.

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

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

There is no output schema or annotation coverage, so the description should be doing more. It covers scope, use cases, and cost, but omits the return format and whether normalization is lossy — details an agent needs for a text-transformation call. Adequate but with clear gaps.

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

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

Schema coverage is 0% and the single 'text' property is undocumented, so the description bears the load. It implies the input is 'a Persian string' to clean, which is adequate given the obviousness of the parameter, but it adds no format, length, or encoding constraints.

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 Summary states a specific verb and resource plus the concrete operations performed: 'unify Arabic/Kaf Yeh variants, remove tatweel and zero-width characters, fix spacing around ZWNJ.' That is far more useful than the bare name. It does not, however, distinguish itself from close siblings such as unicode_normalize or fix_rtl, which an agent could reasonably confuse it with.

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

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

'Use for any Persian text cleanup' plus four use-case lines give implied context (pre-indexing cleanup, invisible-character fixing), but they largely restate the operations rather than say when this beats unicode_normalize or fix_rtl. No exclusions or alternative-routing guidance are 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?

With no annotations, the description carries the full burden, and it does disclose genuine behavioral context: the operation is paid, the endpoint is POST, and the price is $0.003 per call via x402/MPP. It does not describe the return format, handling of empty/malformed input, or idempotency, so it is not complete.

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 dominated by SEO/boilerplate metadata (origin URL, hostname, brand, aliases, family key, repeated keywords), and the actual purpose is repeated five-plus times. The single meaningful fact is buried and not front-loaded.

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

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

For a simple one-parameter text-splitting tool with no output schema, the description covers auth and pricing but omits any indication of what the split result looks like or how sentences are delimited. Adequate but with a clear gap.

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

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

Schema coverage is 0% for the single 'text' parameter, so the description must compensate. The use-case lines imply the input is Persian text, which is marginal added meaning, but there is no format, length, or encoding guidance for the parameter.

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

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

The description states a clear verb+resource multiple times ('Split Persian text into sentences'), so an agent knows exactly what it does. However, it does nothing to distinguish this from Persian-script siblings like persian_normalize, persian_keywords, or persian_similarity, which the agent must disambiguate on its own.

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?

Two 'Use case' lines imply when to reach for it ('split a Persian paragraph into sentences', 'break a Persian text into sentences for processing'), giving implied usage. But there is no explicit when-not guidance and no named alternative among the many Persian 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?

No annotations are provided, so the description carries the burden. It usefully discloses that the tool is paid, the price per call, the auth mode, the endpoint, and the underlying Jaccard algorithm. It does not explicitly state read-only/no-side-effect behavior, but the compute nature is strongly implied.

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 heavily bloated with origin metadata, aliases, family keys, repeated keywords, repeated use cases, endpoint details, and payment information. The core summary appears late and is repeated, so the useful information is not front-loaded.

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

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

The description explains the output as a 0-1 similarity score and names the scoring method, which partially covers the absence of an output schema. However, it leaves the two input parameters under-specified and does not explain edge cases such as empty strings or tokenization behavior.

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 schema only defines required string parameters 'a' and 'b'. The description says the tool compares two Persian strings but does not map 'a' and 'b' to first/second text, give examples, or clarify tokenization or whitespace handling.

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

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

The description clearly states a specific verb and resource: compute a 0-1 similarity score between two Persian strings using Jaccard token overlap. This is specific enough to distinguish it from most sibling tools, though it does not explicitly contrast itself with tools like persian_keywords or persian_normalize.

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

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

The description lists use cases such as measuring similarity, detecting duplicate Persian product descriptions, and scoring sentence overlap, which implies when the tool is useful. However, it gives no explicit when-not guidance and does not name alternative tools for related tasks.

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 no annotations, the description carries the burden and discloses paid auth mode, pricing per call, endpoint method, and the conversion ratio. It could say more about output shape or failure behavior, but the key behavioral traits are present.

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

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

The definition is padded with origin URL, hostname, brand, family key, repeated summary/source text, and multiple keyword lines. Useful information exists but is not front-loaded and the repeated metadata harms 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?

For a two-parameter conversion tool without annotations or an output schema, the description covers auth, price, endpoint, ratio, and use cases. However, it still leaves parameter direction and return behavior under-specified.

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

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

Schema coverage is 0%, so the description must explain the two parameters. It gives examples that imply amount and direction, but it never explicitly defines the `from` parameter, its default, or whether `amount` is in the `from` unit, leaving some ambiguity.

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

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

The description states a specific verb and resource: convert between Iranian rial and toman, with the exact conversion ratio (1 toman = 10 rial). This clearly distinguishes it from sibling utilities like number_to_words_fa or iran_amount_to_words.

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 use cases and keywords such as converting 125000 rials to tomans and converting a toman price back to rials. It does not explicitly exclude alternatives, but the context is strong enough for an agent to select it correctly.

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?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses paid auth mode and the exact price per call, but it does not describe the return shape, output format, or error behavior for a detection tool.

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

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

The description is heavily padded with origin URL, hostname, family key, provider aliases, endpoint, repeated keywords, and pricing metadata. Useful content exists, but it is not front-loaded and much of the text does not help an agent invoke the tool correctly.

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

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

For a simple one-parameter detection tool with no output schema and no annotations, the description covers purpose, use cases, and payment requirements. However, it omits output details and parameter constraints, and does not help route between this and related text-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 description coverage is 0% for the single required parameter 'text'. The description implies a string input through use cases but does not document format, length, encoding, or any constraints, so it only partially compensates for the missing schema documentation.

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

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

The summary states a specific verb and resource: 'Detect which Unicode scripts a string uses and flag mixed-script spoofing.' It is clear what the tool does, but it does not distinguish itself from closely related siblings like detect_encoding or homoglyph_fold.

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

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

The description gives explicit use cases: detecting Latin+Cyrillic mixes, finding the minority script in an identifier, and flagging mixed-script brand spoofs. It does not state when not to use the tool or name alternative siblings, so it lacks 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?

No annotations are provided, so the description must carry the full behavioral burden. It discloses important operational context like paid auth mode, price, and endpoint, but it does not state side effects, return format, or whether the operation is purely read-only. The cost/auth disclosure is useful, but core behavioral transparency remains limited.

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 heavily bloated with origin URL, hostname, brand, aliases, family key, keywords, repeated summary text, and pricing metadata. The useful tool summary is buried after machine-generated fields and repeated in 'Source description.' It is not front-loaded or concise.

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 four-parameter text-transform tool with no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It gives a functional summary and use cases but omits parameter semantics, defaults, and return-value expectations. An agent would need schema inference to call it correctly.

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

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

Schema description coverage is 0%, so the description needs to compensate, but it only vaguely references an optional length limit and accent stripping behavior. It does not explain the required 'text' parameter, or the 'lowercase' and 'separator' parameters and their defaults. The schema is left largely 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 summary states a specific verb and resource: 'Convert a title into a clean URL slug with accent stripping and optional length limit.' The purpose is clear and distinct from text-normalization or detection siblings. It does not explicitly differentiate against sibling tools, but the operation itself 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?

Three 'Use case' lines provide clear contexts for when to use the tool, such as turning Persian or accented titles into URL slugs and generating permalinks. There are no exclusions or sibling alternatives, but the intended usage context is explicit enough for an agent.

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

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

No annotations are supplied, so the description carries the full disclosure burden, yet it says nothing about how tags are handled (script/style contents? attribute preservation? whitespace collapsing?) or what the decoded output looks like. The only real behavioral facts given are registry metadata — paid auth mode and $0.003/call pricing — which is cost context, not tool behavior.

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

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

The payload is dominated by registry boilerplate — origin URL, hostname, brand, provider aliases, family key, endpoint, auth mode, price — plus five keywords and three use cases that restate the same idea. The one useful sentence is buried mid-block, and much of the text is redundant rather than front-loaded.

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

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

For a single-parameter utility with no output schema and no annotations, the definition covers the basic purpose and plausible scenarios but omits return shape and tag/entity handling rules. It is minimally workable but leaves the agent to discover output semantics by calling it.

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

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

Schema description coverage is 0% for the single 'text' parameter, so the description must compensate. 'from a string' confirms the input is raw string content rather than a URL or buffer, but it adds nothing about encoding expectations, size limits, or whether fragments are acceptable.

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 Summary line states a specific verb+resource: 'Remove HTML tags and decode entities from a string.' A reader instantly knows what the tool does. However, it does not name or contrast itself against any sibling (e.g., persian_normalize, unicode_normalize) that also mutate text, so differentiation is left to inference.

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

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

Three use cases are provided ('remove HTML tags from scraped text', 'turn a rendered page into plain text', 'decode HTML entities in a string'), which imply when to reach for the tool. There are no explicit exclusions or alternatives, so the agent must still guess at boundaries versus the other text-cleaning 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?

With no annotations, the description carries full behavioral burden. It does disclose real operational context (paid access, $0.003 per call, x402/MPP auth, POST endpoint), which is genuinely useful. But it says nothing about return shape, whether the operation has side effects, or rate/error behavior, and the 'first differing position' claim contradicts the single-input schema.

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

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

Front-loaded content is boilerplate (origin URL, hostname, brand, aliases, family key, endpoint) rather than functional meaning. Keywords are duplicated as separate lines and the price/auth block repeats what the endpoint field already implies, burying the one useful sentence.

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

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

For a two-parameter, read-only normalization call with no annotations and no output schema, the description supplies the valid forms and plausible use cases. It still leaves the return value and the meaning of the required text input unexplained, and the comparison semantics don't match the schema.

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

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

Schema description coverage is 0%, so the description must compensate. It names the NFC/NFD/NFKC/NFKD forms, but those are already the enum values in the schema, and it never states the default (NFC) nor explains the required 'text' parameter at all. Marginal added value over 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 core sentence states a specific verb+resource: normalize text to one of four Unicode normalization forms. It is separable from siblings like persian_normalize or homoglyph_fold in shape, but the description never explicitly distinguishes itself from them. The trailing clause about 'report the first differing position' is confusing since the schema accepts only a single text input.

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 'Use case:' lines give implied contexts (normalize before comparing, fold compatibility characters), which is better than nothing. However, there is no explicit when-not guidance and no routing to any sibling such as persian_normalize, which an agent might wrongly pick for Persian-specific work.

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