فکرستان (Fekrestan)

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds real context beyond that: the output is Persian (fa-IR, RTL) text from public fekrestan.com pages for parents and teachers, and exercise answers are excluded. However, "Same content limits as the other tools" is a dangling reference that tells the agent nothing concrete, and truncation/length behavior is never stated.

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

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

The opening clause is front-loaded and specific, which is good, but the middle sentence ("Same content limits as the other tools") is an unearned placeholder that adds ambiguity rather than information. The language switches between Persian and English and the final sentence partially overlaps with the opening enumeration, so the content could be tightened.

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

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

For a one-parameter read-only fetch with no output schema, the description covers the essential: what it returns, in what language/direction, from which domain, and one content exclusion. The remaining gaps (truncation, behavior on a URL not obtained from search, relation to the specialized getters) are real but comparatively minor.

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 one parameter and 100% schema coverage, the schema already documents that `id` is a URL returned by search, including the pattern and length bounds. The description's "(id = its URL)" largely restates that. Baseline 3 applies; nothing about error behavior for non-search URLs is added.

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 action and resource: return the text of ONE public page, identified by its URL, and enumerates the page kinds it covers (article, «روش حل», subject, station). It links itself to `search` as the source of the id. It stops short of distinguishing itself from the dedicated getters in the sibling list (get_article, get_subject, get_station_overview, get_how_to_solve), which cover the same page types.

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

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

The phrase "found with search" implies the intended workflow (search first, then fetch by URL), and "No answers to in-app exercises" sets one boundary. But there is no explicit guidance on when to use this generic fetch versus the concrete per-type siblings like get_article or get_subject, which is the main selection decision an agent faces here.

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

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

Annotations already cover read-only, idempotent, non-destructive, closed-world behavior, so the bar is lower. The description still adds real context beyond them: output is Persian (fa-IR, RTL) verbatim text, contains no prices, and is sourced from public fekrestan.com pages — all facts an agent cannot infer from the annotations.

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

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

Three short sentences with the content (cost sentence + contact page) front-loaded, followed by output characteristics and exclusions. Wording like 'The site's own fixed sentence' is slightly awkward but each sentence carries information, so no trimming is clearly warranted.

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 static-read tool with full annotation coverage and no output schema, the description supplies everything needed: what content comes back, its language and direction, and what is excluded. Nothing essential to correct invocation is missing.

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

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

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to disambiguate. Schema coverage is 100% and the empty object schema leaves no 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 identifies the resource concretely: the site's fixed cost sentence (verbatim, no prices) plus the contact page, returned as Persian text. It is clearly a read of static informational content, distinguishable from siblings like get_how_to_solve or get_exam_prep_overview, though it does not explicitly contrast with get_site_overview.

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?

Audience is stated ('for parents and teachers') and one exclusion is given ('No answers to in-app exercises'), which implicitly routes exercise questions to other tools. However, there is no explicit when-to-use statement versus its closest siblings such as get_site_overview or how_to_start.

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

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

Annotations already declare read-only, idempotent, closed-world and non-destructive, so the safety profile is covered. The description adds genuinely new context: content comes from public site pages, is Persian fa-IR RTL, and bundles author, reviewer, dates and cited sources, which tells an agent what to expect from the response shape.

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

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

Three short sentences, front-loaded with what is returned, then locale/provenance, then the exclusion. No filler and nothing repeated from the schema.

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

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

With no output schema, the description compensates by enumerating the return fields (Markdown text, author, reviewer, dates, cited sources, related articles) and the language/format. For a single-parameter read tool this leaves nothing an agent needs missing.

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

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

Schema coverage is 100% and the schema already explains the slug format and that it comes from search_articles. The description adds no further constraint or formatting guidance on the slug, so the baseline 3 is appropriate.

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

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

States a specific resource and cardinality ('One published parent article') plus the payload it returns, which separates it from list-style siblings like search_articles and list_subjects. The closing exclusion ('No answers to in-app exercises') further fences it off from the how-to-solve tools.

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

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

The audience and domain ('public fekrestan.com pages for parents and teachers') and the explicit exclusion of in-app exercise answers give a clear picture of when this tool applies. The schema's 'Article slug from search_articles' implies the search-then-fetch workflow, but the description itself never names an alternative tool for out-of-scope requests.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description earns credit for adding what they cannot: the output is Persian fa-IR RTL text sourced from public fekrestan.com pages, and it deliberately excludes puzzle content and in-app exercise answers. That language/directionality and source detail is genuinely useful for an agent assembling a response, though it does not address response size or structure.

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?

Four short sentences, front-loaded with the content inventory before the constraints. The standalone 'No puzzles.' slightly duplicates 'No answers to in-app exercises.' and could be merged, but no sentence is wasted.

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

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

With no parameters and no output schema, the description carries the burden of describing the payload, and it does enumerate the sections returned plus the language and source. An agent knows what it will get and what it will not, though nothing is said about volume or pagination of the returned text.

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 no parameters, so there is nothing for the description to disambiguate beyond noting that the result covers both entry tracks (grade 7 and grade 10) without a selector argument. Baseline 4 applies for a zero-parameter tool.

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

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

The description names a specific resource (exam-prep overview) and enumerates exactly what it contains: unit families, what each unit trains, verified puzzle counts, and the FAQ. It also scopes it to entry-to-grade-7 and grade-10 tracks, which separates it from generic siblings like get_site_overview or get_subject. It stops short of naming a sibling tool it should be preferred over, so a 4 rather than a 5.

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

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

'The optional exam-prep sections' hints at context (optional supplementary material for parents/teachers) but never states when to call this versus get_station_overview or get_roadmap. The negative scoping ('No puzzles', 'No answers to in-app exercises') functions as a partial exclusion, steering the agent away for exercise content, but no positive trigger conditions or 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?

The description offers critical behavioral details beyond annotations, specifically mentioning that the content is in Persian (fa-IR, RTL) and what parts of the page it includes (e.g., worked examples). It also sets clear boundaries by excluding in-app answers.

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 information is dense and packed with value, but it is structured logically by first detailing the content provided and then the technical constraints (language, source, exclusions).

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

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

Given the lack of an output schema, the description is extremely complete, detailing not just what the tool fetches, but the specific internal components (strategy, mistakes, links) found on the resulting page.

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

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

The schema only defines 'slug' as a string, but the description adds semantic value by explaining that the slug is from the specific 'list_how_to_solve' collection. This helps the agent understand the nature of the requested input.

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 defines this tool's purpose as retrieving a structured 'how-to-solve' page, distinguishing it from general article retrieval tools. It specifies the exact educational content returned, like 'short answer' and 'common mistake'.

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

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

The description provides excellent context by specifying the target audience (parents and teachers) and the type of content (Persian educational strategy). While it doesn't explicitly name alternatives, its highly specialized nature for 'how-to-solve' pages implies clear usage boundaries.

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

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

Annotations already declare read-only, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds genuinely new context: the output is Persian (fa-IR, RTL) text sourced from public fekrestan.com pages, and it explicitly excludes exercise answers — both material for an agent deciding whether the returned content is usable.

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

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

Three tight sentences: the first front-loads the content scope, the second the format and audience, the third the exclusion. Every sentence earns its place; the only minor cost is that the opening sentence packs a long topic list, making it slightly dense to scan.

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

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

With no parameters and no output schema, the description carries the burden of describing the return value, and it does: language, script direction, source domain, and topical coverage. It stops short of noting size/truncation characteristics of the returned text, a small remaining gap for a content-dump tool.

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

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

The tool takes zero parameters, so there is no parameter meaning to convey and the baseline applies. The description correctly spends no words on arguments and instead describes the payload, which is the right emphasis for a no-arg fetch.

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

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

The description gives a concrete verb-and-resource statement: it returns page text explaining how fekrestan's lessons are written and checked, including the review pipeline and privacy facts. It also marks the boundary with exercise-solving content ("No answers to in-app exercises"), which implicitly separates it from get_how_to_solve, though it never names that sibling outright.

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?

Audience is stated ("for parents and teachers") and the negative scope is explicit (no exercise answers), which implies this is the trust/methodology tool rather than a solving tool. However, it never says when to call this versus get_site_overview, get_access_summary, or how_to_start, nor lists any preconditions, so the routing decision is left to inference.

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

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

Annotations already establish that this is a safe, read-only, idempotent, closed-world lookup, so the description's job is to add context — and it does: source pages are public fekrestan.com content, output is Persian (fa-IR, RTL), and the audience is parents/teachers. It adds the useful caveat that pacing is mastery-based rather than age-based, framing what the roadmap actually means.

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?

Four short sentences, front-loaded with the resource definition and its contents, followed by filter behavior, interpretive note, output locale, and a scope exclusion. Every sentence carries distinct information with no repetition of the schema or annotations.

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-optional-parameter read tool with full annotation coverage, the description covers contents, audience, source, output language, and scope boundaries. Return-format detail is partial (it says Persian RTL text but not structure), though no output schema exists, so a small gap remains.

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

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

Schema coverage is 100% and the single 'grade' parameter is documented in the schema as school grade 3–9. The description only restates that the filter is optional, contributing nothing beyond the schema; with one optional parameter this is the expected baseline.

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

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

The description names the resource (multi-year roadmap) and enumerates its contents — phases with grades, stations, duration, focus, plus milestones and track outcomes — so an agent knows exactly what it retrieves. It does not name a sibling to contrast with, leaving the distinction from get_station_overview and get_site_overview to be inferred.

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

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

Usage context is clear: for parents and teachers seeking long-term planning, with an explicit negative scope ('No answers to in-app exercises') that steers exercise-solving requests toward get_how_to_solve or get_exam_prep_overview. It stops short of naming those alternatives directly, so the routing is implied rather than stated.

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

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

Annotations already declare read-only, idempotent, closed-world and non-destructive, so the safety profile is covered. The description still adds real context beyond them: output is Persian (fa-IR, RTL) text scraped from public fekrestan.com pages, aimed at parents and teachers. The one added restriction (no answers to in-app exercises) pre-empts a likely wrong expectation.

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

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

Two sentences, front-loaded with what the resource is and who it serves, then the return format and the boundary. Some clauses are dense with parentheticals, but each one adds distinct information (audience, language, scope, exclusion) rather than padding.

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

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

For a zero-parameter, read-only tool with no output schema, the description carries the necessary load: it explains the content, the language and direction of the returned text, the intended audience, and one important limit on what the content covers. Only the sibling routing is left implicit.

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; the baseline for a no-param tool applies. Nothing in the description misleads about inputs, and it correctly implies the tool is callable with no arguments.

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 concretely enumerates what the tool returns: the site's purpose, target audience (grades 3–9 and parents), lesson mechanics, privacy facts, learning tracks and links to public pages. That is far more specific than a restatement of the name, and the closing exclusion ('No answers to in-app exercises') draws a clear line. It stops short of naming which sibling it replaces (e.g. get_how_we_work, get_roadmap, how_to_start), which keeps it from a 5.

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

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

Usage is implied rather than stated: an orientation/entry-point tool aimed at parents and teachers, sourced from public pages. The negative constraint ('No answers to in-app exercises') usefully signals one thing it is not for. However, with siblings like get_how_we_work, get_roadmap, get_access_summary and how_to_start, the agent gets no explicit rule for choosing between this overview and those narrower pages.

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

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

Annotations already cover read-only, idempotent, non-destructive, closed-world behavior, and the description adds meaningful context on top: output is Persian (fa-IR, RTL), sourced from public fekrestan.com pages, safety notes are verbatim, and unavailable stations are excluded. It does not describe error behavior when a station lacks a public page, which is the one remaining gap.

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

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

The resource and its payload are front-loaded in a single sentence, followed by three short scoping sentences covering availability, locale, and exclusions. No filler and nothing restated from the schema or annotations.

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 tool with no output schema, the description covers content scope, audience, language/encoding, and exclusion rules. Only the failure mode for stations without a public page is left unspecified.

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

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

Schema coverage is 100% with both parameters documented (track enum with example, n as station number 1–30), so the schema carries the load. The description adds only marginal meaning via the availability caveat that some track/n combinations have no public page.

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?

"One public station page" names the resource precisely, and the colon list (wonder question, usual grade, concepts, lessons and minutes, idea cards, prerequisites, next stations, safety notes) makes the payload concrete. It is clearly differentiated from sibling tools like get_subject or get_roadmap by being a single station, though no sibling is 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?

"Only stations that have a public page" and "No answers to in-app exercises" give real when-not constraints, and "without its worked examples" implicitly points to a separate worked-examples tool. However, no alternative tool is named, so the agent must infer routing to get_how_to_solve or get_subject on its own.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld=false, so the safety profile is covered. Beyond that, the description adds genuinely non-structured context: the text is Persian (fa-IR, RTL), it is sourced from public fekrestan.com pages aimed at parents and teachers, and it deliberately omits exercise answers. Those details plausibly change how an agent interprets and presents the output.

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

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

Three sentences, front-loaded with the payload list before the language/source note and the scope caveat. The parenthetical qualification about the public page URL is precise rather than padding. Slightly dense colon-and-list construction keeps it from a 5.

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

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

With one enum parameter, no output schema and full annotation coverage, the description does the work of describing the return shape (goal, phases, pace, 30 stations with fields, milestones). An agent knows what it will get and in what language. It could still be clearer about how this relates to list_subjects or get_roadmap for multi-track needs.

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

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

Schema description coverage is 100% and the single parameter carries an explicit five-value enum plus a description ('Track id, e.g. math'), so the schema does the heavy lifting. The prose only implies that the argument selects one track and adds no format or naming guidance beyond the enum. Baseline 3 applies.

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

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

The description concretely enumerates what the tool returns for a single track: final goal, phases, pace note, the 30 stations (title, wonder question, public page URL) and typical milestones. That is far more specific than a tautology and 'One track' implicitly contrasts with the list-shaped sibling list_subjects. It stops short of naming any sibling explicitly, so it earns a 4 rather than 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?

There is no explicit 'use this when' statement, no prerequisites, and no named alternative such as list_subjects, get_roadmap or get_station_overview. Usage is only inferable from the returned-content list and the single 'track' parameter. The closing scope exclusion ('No answers to in-app exercises') does provide one useful boundary, keeping it at 3 rather than 2.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description still adds real value beyond them: the response is Persian (fa-IR, RTL) text sourced from public fekrestan.com pages, and the server performs no account creation, which is exactly the side-effect clarification an agent needs.

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

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

Three short sentences with the payload stated first, followed by the negative boundary and the output-format note. No sentence is decorative; each adds a distinct fact (content, no account creation, language/script, excluded 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 zero-parameter, annotation-rich, output-schema-less tool, the description covers audience, content returned, language/encoding and the main exclusion. It stops short of indicating how many steps or links a caller should expect, but nothing needed to invoke it correctly is missing.

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

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

The tool takes zero parameters, so the baseline is 4 and there is no parameter semantics for the description to compensate for. The schema is empty by design and the description correctly implies a parameterless call.

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

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

The description names the concrete payload — onboarding steps plus links to signup, privacy and contact — and identifies its audience (parents, with teachers also served). It draws a boundary against exercise-solving content ('No answers to in-app exercises'), which separates it from get_how_to_solve, though it does not distinguish itself from adjacent orientation tools like get_how_we_work or get_site_overview.

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?

Audience scope (parents/teachers) and a clear when-not ('No answers to in-app exercises') are stated, and the 'never creates an account' caveat steers agents to the signup link instead. However, no sibling tool is named as an alternative, so the routing decision against get_how_we_work, get_site_overview or get_roadmap is left to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the safety profile is free. The description adds real value beyond that: the text is Persian fa-IR RTL, drawn from public fekrestan.com pages, and explicitly excludes in-app exercise answers — a content boundary an agent would not otherwise know. It does not mention list size or pagination.

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

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

Three short sentences, front-loaded with what the pages are, then the return fields, then the language/audience, then the exclusion. No sentence 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 zero-parameter read-only list with no output schema, the description supplies the resource, the per-item fields, the language/locale, and the scope exclusion — enough to call it correctly. Only list cardinality/pagination behavior is left unstated.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description does voluntarily describe the shape of each returned record, which compensates for the absence of an output schema.

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

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

Names a specific resource (the published «روش حل» pages, one per question type) and enumerates the returned fields (slug, title, short answer, URL). It implicitly contrasts with the singular get_how_to_solve by emphasizing 'published pages' as a collection, but never states that contrast outright.

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 only implied: the 'for parents and teachers' audience plus 'No answers to in-app exercises' scopes the content. There is no explicit 'use this to browse all methods, use get_how_to_solve to fetch one page' routing, and no prerequisites are stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior. The description adds meaningful context beyond that: the output is Persian (fa-IR, RTL) text from public fekrestan.com pages, each item has a lead and live station count, and the scope excludes in-app exercise answers. It does not mention pagination or ordering, which would be useful for a list 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?

Three sentences, each carrying distinct information: returned fields, language/source/audience, and an explicit exclusion. It is front-loaded with the resource and payload, though it could state the listing action more directly at the start.

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 list tool with annotations covering safety, the description is largely complete: it explains the returned fields, language, source domain, audience, and one scope boundary. Missing are ordering, pagination, or result-size expectations, which would help an agent decide whether to call this versus search or get_subject.

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 the baseline is 4. The description correctly adds no parameter information because none exist, and the schema is empty as expected.

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 identifies the resource as 'public learning tracks (subjects)' and specifies what each entry contains: a one-line lead, live station count, and subject page URL. It clearly separates this from a single-subject detail tool by emphasizing a list of tracks, though it never explicitly names get_subject as the alternative.

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 by the list framing and the mention of parents and teachers, and the exclusion 'No answers to in-app exercises' rules out one misuse. However, there is no explicit instruction such as 'use get_subject for a single subject' or 'use this to browse the catalog,' leaving sibling selection to inference.

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

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

Annotations already declare read-only, idempotent, non-destructive and closed-world behavior, so the safety profile is covered. The description adds genuinely non-structured facts: the query is not stored (privacy), results are Persian fa-IR RTL text from public fekrestan.com pages, and the audience is parents and teachers. It does not cover result volume or ranking, but that is a minor omission given 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 scope statement is front-loaded and each of the four sentences carries distinct information with no filler. Minor weakness: two consecutive sentences begin with 'Returns' (ids vs. Persian text), which briefly reads as if there are two different return types rather than ids pointing at Persian 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 one-parameter, annotation-covered, no-output-schema tool, the description supplies what an agent actually needs: what is searched, what comes back, and what to do with it next. Missing only secondary details such as approximate result count or pagination 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?

There is a single parameter with 100% schema description coverage ('A few words, at most 80 characters'), so the schema already carries the semantics and the baseline of 3 applies. The description adds no further guidance on query phrasing, language of the query string, or how matching works.

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 (search) and enumerates the exact resource scope: public pages, parent articles, «روش حل» pages, subject and station pages. It also declares the return shape (ids/URLs to pass to fetch), so an agent knows this is a two-step retrieval pipeline. It does not explicitly distinguish itself from the sibling search_articles, which is the one remaining ambiguity.

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

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

Gives clear workflow context ('Returns ids (URLs) to pass to fetch') and an explicit exclusion ('No answers to in-app exercises'). The exclusion functions as a when-not rule. It stops short of naming an alternative tool for the excluded case or for article-specific searches, which is why it is a 4 rather than a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the safety profile is covered. The description adds genuinely new context: the query is not stored (privacy), results come from public fekrestan.com pages, and returns are Persian fa-IR RTL text — none of which is in the annotations.

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

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

Four short sentences, front-loaded with the action and resource, with each sentence adding a distinct fact (fields, privacy, output language/source, exclusion). Only 'for parents and teachers' slightly overlaps with 'parent articles'; otherwise there is no filler.

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

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

With no output schema, the description usefully characterizes the return values (fa-IR RTL text from public pages). It does not cover result ordering, pagination, or what happens at the limit boundary, but for a two-parameter read-only search it is nearly 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 coverage is 50%: the 'query' parameter already documents 'A few words, at most 80 characters', while 'limit' is undocumented in both places. The description compensates somewhat by clarifying what fields the query matches and that Persian or Latin words are accepted, but says nothing about the limit cap of 20 or result-count behavior.

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 ('Search the published parent articles') and names the searched fields (title, description, tags), plus the language/script of the query. It also draws a content boundary ('No answers to in-app exercises'), which helps separate it from exam-prep siblings, though it never names an actual sibling tool.

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

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

Usage is implied by the scope 'published parent articles... for parents and teachers', and the negative scope excludes in-app exercise answers. However, with 14 siblings including 'search' and 'get_article', the description never says when to pick this instead of those, leaving the routing decision to inference.

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