ATSPrep

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

Annotations already declare readOnlyHint/idempotentHint/destructiveHint=false, so safety is covered, and the description goes beyond them by disclosing output behavior per input: direct swaps plus a rationale, matched verb groups with example bullets, or every group when query is empty. Return format details (structure, count) remain unspecified.

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

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

Front-loaded with the usage trigger, then the core action, then the input-mode guidance; no sentence is filler. It is dense with quoted examples, but each clause carries distinct instruction rather than repeating the title.

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

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

With only one optional parameter, no output schema, and rich annotations, the description covers what to pass and what comes back for each mode. It would be fully complete if it clarified the shape or volume of the returned groups, 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?

Schema coverage is 100%, so the baseline is 3, but the description adds real semantics the schema does not: a weak opener yields direct swaps, plain work wording yields matched verb groups, and leaving query empty returns all groups. That mapping meaningfully improves the agent's ability to fill the parameter correctly.

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 clear verb+resource ("Suggest resume action verbs" / "stronger verbs or synonyms for resume wording"), so an agent knows exactly what it returns. It does not differentiate itself from related siblings like improve_bullet or check_bullets, which also touch resume wording, 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?

"Use this when the user wants stronger verbs or synonyms for resume wording" is a concrete trigger condition, and the description further splits usage into two input modes plus the empty-query case. No exclusions or named alternatives are given, so an agent can't tell when a sibling is the better pick.

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, and the description goes well beyond them: input limits (30 bullets, 600 chars each), skip-and-report semantics for blank items, the scoring model (score + verdict + fixes), the stable problem-code taxonomy, and a pinned rules version. That is substantive behavioral context an agent could not derive from the structured fields.

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

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

The routing condition is front-loaded and nearly every sentence carries new information (limits, skip behavior, scoring, codes, version). The middle sentence is a dense comma-list of problem categories that is slightly harder to parse than a bulleted enumeration would be, but nothing 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 two-parameter, non-destructive check tool with no output schema, the description covers inputs, limits, skip handling, scoring model, and the code taxonomy. The remaining gap is the exact response shape (per-bullet objects, whether an aggregate score is returned), which the agent must infer from the check_resume analogy.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning beyond the schema: it explains that blank items are skipped and reported by index, which is non-obvious input-handling behavior. It says nothing about the language parameter (the English-rule skip is only in the schema), which keeps it from a 5.

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

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

The first sentence names a specific verb and resource ("resume bullet points checked") and immediately scopes it against the alternative of sending a whole resume. Combined with the explicit reference to check_resume scoring, an agent can distinguish this from check_resume, improve_bullet, and the LinkedIn check siblings without opening a schema.

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

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

"Use this when the user wants a few resume bullet points checked without sending the whole resume" gives a clear selection condition, and "Scored as check_resume scores bullets" positions it relative to the full-resume tool. It does not explicitly name improve_bullet as the alternative when the user wants rewrites rather than checks, so one obvious 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 declare this a safe, read-only, idempotent, closed-world operation, so the safety profile is covered. The description adds genuine context beyond that by disclosing the analysis dimensions the tool evaluates, which tells the agent what kind of feedback comes back, though it never states the response format or whether a score is returned.

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: the first front-loads the usage condition, the second enumerates the checks. Every clause carries content and nothing is padded, though the long comma-separated checklist is slightly dense.

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 must carry the burden of explaining what comes back; listing the check dimensions partially does this, but the agent still cannot tell whether the result is a pass/fail, a score, or rewritten text. It also omits how the optional role parameter changes the review, leaving the picture 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?

Schema description coverage is 100%, so both parameters (about, role) are already documented in the schema, and the baseline is 3. The description adds the 2,600-character LinkedIn limit as useful context but never mentions the optional "role" parameter or how it shapes the check, so it does not exceed the schema.

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

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

The description names a specific verb and resource ("Check a LinkedIn About section") and enumerates the exact checks performed: the pre-"see more" preview on phone vs. computer, opening identity statement, quantified results, buzzwords, next step, and the 2,600-character limit. That is far more concrete than a generic "review" tool, though it never contrasts itself with near-neighbours like check_linkedin_headline or write_summary.

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 this when the user wants their LinkedIn About or summary section reviewed" gives a clear triggering condition tied to the user's intent. There is no when-not guidance and no named alternative (e.g., for drafting rather than checking an About section), so it stops short of the top band.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description earns credit by disclosing the substantive analytical dimensions (character limit, SERP truncation, title placement, buzzword flagging), which is real behavioral context beyond the annotations, though it says nothing about the output/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?

Two sentences, front-loaded with the usage trigger followed by the specific checks. Every clause carries information; no filler or repetition of the name/title.

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

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

For a read-only analysis tool with no output schema, the description adequately conveys what the review covers, and the optional parameters are fully documented in the schema. It is nearly complete; only the shape of the returned review is left unspecified, 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?

Schema description coverage is 100%, so all four parameters (headline, role, focus, skills) are already documented in the schema. The description adds no syntax, format, or usage detail for these parameters, so the baseline 3 applies.

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

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

The description states a specific verb+resource ('Check a LinkedIn headline') and then enumerates exactly what it checks: 220-character length, search-result cut-off, leading job title, and buzzwords. This distinguishes it clearly from siblings like check_linkedin_about and generate_linkedin_headline without needing to open any schema.

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

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

It gives a clear usage trigger ('when the user wants their existing LinkedIn headline reviewed'), and the word 'existing' implicitly routes away from the generate_linkedin_headline sibling. However, it never names that alternative or states a when-not condition explicitly, 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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description layers on real behavioral context: how the score is computed (AI line judge against a published rubric plus fixed maths), versioned-rule fallback, the 30,000-character ceiling, and the rule that the returned metrics must never be averaged. That is substantive disclosure beyond what the annotations provide.

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

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

The trigger condition is front-loaded and nearly every clause carries information (metric aliasing, non-averaging rule, character limit, rules version). However, it is delivered as long semicolon-chained sentences, so the return-value contract is harder to scan than it needs to be.

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, so the description must carry the return contract — and it does, enumerating resumeQuality with a 0–100 range and its score alias, jobFit, keywordCoverage, legacy job_fit/job_match, stable issue codes with locations and fixes, and import counts. For a four-parameter scoring tool this is sufficient to call and interpret it correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds outcome semantics the schema cannot: job_description is a secondary lens that does not replace resumeQuality, target_role only refines advice, and language should be set when the resume is not English. These are effects on scoring, not restatements of parameter types.

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

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

The opening clause names a specific verb and resource ('when the user shares a resume ... wants it checked, scored, reviewed for ATS problems') and immediately scopes it away from job-fit tools by stating that job_description 'never replaces' the headline score. An agent can distinguish this from match_job or check_bullets without opening a schema.

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

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

It gives a clear trigger condition (resume shared as pasted text or file text) and lists the intents it serves — check, score, ATS review, fixes. It also clarifies that job_description/target_role refine advice without changing the headline, but it never names the nearest siblings (check_bullets, keyword_scan, match_job) as alternatives for narrower jobs.

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

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

Annotations cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description goes well beyond them: it discloses the fixed rule set for what gets included, the [square-bracket] gap convention with an explicit 'never stand-ins' guarantee, and the three return artifacts (letter, gaps, checklist).

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 trigger and immediately followed by behavior and return values. No filler, no repetition of schema fields.

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

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

For a no-output-schema, 12-parameter generative tool, the description covers the trigger, required inputs, deterministic generation rules, missing-fact handling, and the return payload — everything an agent needs to call it correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning by explaining how inputs are consumed — up to two resume results, job title and top keywords from the posting — which tells the agent what each input actually drives in the output.

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

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

States a specific verb+resource (draft a cover letter) plus the exact sources it draws from — the user's resume and the job posting. This clearly distinguishes it from nearby siblings like tailor_resume, draft_resignation_letter, and write_summary.

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

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

Gives an explicit trigger: 'Use this when the user wants a cover letter for a job,' and routes link-based input to fetch_job_post. It does not state when NOT to use it or contrast it against similar siblings such as tailor_resume, so alternative selection is left to inference.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and nothing in the description contradicts them. The description adds real behavioral context the annotations cannot: missing facts surface as [square-bracket] gaps, and the response bundles a letter plus last day plus a self-check checklist. It stops short of 5 only because it doesn't say what the checklist does with failures or how tone/notice conflicts resolve.

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 trigger, then the action, then the return shape and gap behavior. No repetition of the title, no filler, and every sentence carries distinct information.

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

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

With 12 all-optional parameters and no output schema, the description correctly compensates by naming the three return artifacts (letter, last day, checklist) and how missing inputs are rendered. What remains thin is the interaction between notice and notice_days and the checklist's pass/fail semantics, though the schema largely covers the former.

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% across 12 parameters, so the schema already carries the per-parameter semantics (defaults, enums, date format, working-days toggle). The description adds only the high-level hint that the last working day is derived from the notice period; that is marginal value over the schema, matching the baseline 3.

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

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

Specific verb (draft) plus specific resource (a short, professional resignation letter) and a second concrete deliverable (the last working day computed from the notice period). The opening trigger condition, 'when the user wants to resign,' cleanly separates it from the other drafting siblings (draft_cover_letter, write_summary).

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 first sentence gives an explicit when-to-use trigger tied to user intent. However, it names no alternatives and gives no when-not conditions (e.g., distinguishing itself from a general letter tool or when a user just wants notice math), so it stops short of the 5 bar.

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 open-world, so safety is covered. The description goes well beyond that with site-by-site coverage (LinkedIn, Greenhouse, Lever, Ashby, SmartRecruiters, Workable, Workday, careers pages), the concrete failure mode of sites blocking reads, and the guidance that EEO, legal, consent, ai-use and trap questions are left for the user to answer.

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

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

Front-loaded with the trigger and the return shape, then failure handling, then the optional flag. The platform list and question-kind list are the longest stretches, but both are decision-relevant rather than filler; only a slight trim would improve 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?

There is no output schema, and the description fully compensates by naming the returned fields and their format, plus what the optional questions payload contains. Combined with the failure path and downstream routing, an agent has everything needed to call this and to handle a blocked site.

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

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

Schema coverage is 100%, so the baseline is 3, but the description still adds decision-relevant meaning: it clarifies that questions only appear 'where the site publishes them' and that the flag is limited to certain platforms. The added value is real but modest, since the schema already enumerates the question kinds.

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: read a public job posting from a link and return title, company, location and full description as plain text. It also distinguishes itself from the sibling pipeline tools by naming match_job, tailor_resume, keyword_scan and interview_questions as downstream consumers, so an agent knows this is the ingestion step, not the analysis step.

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

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

Gives an explicit trigger ('when the user gives a job posting link instead of its text'), an explicit fallback when the tool fails ('ask the user to paste the text'), and routes the output to specific sibling tools. The implied exclusion is clear too: if the user already pasted text, this tool is unnecessary.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds real behavior beyond that: generation is bounded to the supplied answers, output includes pattern labels, character length, and what shows in search before truncation — useful output-shape context that annotations do not provide.

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

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

Two sentences, front-loaded with the trigger condition before the mechanics. The parenthetical pattern list is slightly dense but earns its place by previewing output variety; nothing is wasteful.

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

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

For a 7-parameter generation tool with no output schema, the description covers the trigger, the input source, and the output format (pattern, length, search truncation). The main remaining gap is the number/format of returned options, but overall this is sufficient to invoke correctly.

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

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

Schema description coverage is 100% and each field's meaning/format is documented in the schema, so the baseline of 3 applies. The description says output derives from the user's answers but adds no per-parameter nuance (e.g. how 'results' or 'skills' shape the generated patterns) beyond what the schema already states.

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

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

States a specific verb+resource: writing LinkedIn headline options from user answers, and names the pattern families used. It reads clearly as the 'generate new' counterpart to the sibling check_linkedin_headline, but that differentiation is only implied by 'wants new LinkedIn headline ideas' rather than stated explicitly.

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

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

The opening sentence gives a clear use condition ('when the user wants new LinkedIn headline ideas') and the last sentence constrains inputs ('uses only the answers given'). No alternatives or when-not-to-use cases 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?

With readOnlyHint and destructiveHint already declaring a safe read, the description still earns credit by disclosing that part of the result comes from an AI model, that a guard drops any figure, name or tool not present in the user's text, and that the rule-based portion still returns with an explanation in ai.message when the model is unavailable. It does not state explicitly that repeated calls may produce different rewrites, which is the remaining gap for a non-idempotent 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 trigger is front-loaded and each sentence carries information, but the parenthetical listing 'Gemma 4, with Llama 3.3 70B as a backup, on Cloudflare Workers AI' is implementation trivia that does not change how the agent calls the tool. Trimming that clause would tighten an otherwise dense but well-structured description.

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

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

There is no output schema, and the description compensates by naming the shape of the result (score, verdict, fixes, up to three rewrites, ask_user, ai.message) plus the degradation path. For a three-parameter read-only tool with annotations covering safety, nothing needed to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so role, company and bullet are already documented in the schema, and the description adds no syntax or usage detail for role/company. The mention of ask_user and 'keep every fact as given' refers to response fields and copy constraints rather than to input parameters, so the baseline of 3 is appropriate.

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

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

The opening sentence names a specific verb and resource ('one resume bullet rewritten or made stronger') and the second sentence clarifies it also scores the bullet the way check_bullets does. An agent can distinguish it from check_bullets (checks only) and from multi-bullet tools without opening a schema.

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

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

The trigger condition ('when the user wants one resume bullet rewritten') is stated up front, and the relationship to check_bullets is made explicit by describing the shared check step. It stops short of an explicit exclusion such as 'for multiple bullets use check_resume', so the routing is clear but not fully closed.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower. The description still adds real value: the output includes 'what the interviewer is listening for, plus STAR answer tips', questions are derived from job-description skills/duties or the user's own roles, and it is 'Rule-based' (deterministic, not free-form generation).

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 trigger condition is front-loaded in the first clause, and the remaining sentences each add distinct information (output shape, input-dependent behavior, determinism). It is somewhat dense but every sentence earns its place.

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

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

With no output schema, the description carries the return-value burden and does so ('each with what the interviewer is listening for, plus STAR answer tips'). Trigger, both input modes, and output composition are all covered, leaving nothing an agent needs to call it correctly.

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

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

Schema coverage is 100%, so baseline is 3, but the description goes beyond the schema by explaining the causal effect of the optional inputs: job_description drives questions from its skills and duties plus research pointers, and resume_text drives questions from the user's roles. The enum values and limit are left to the schema.

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

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

The description states a specific verb+resource ('interview questions to practise') and its scope ('for a specific job or in general'). It implicitly distinguishes itself from the sibling review_interview_answer by generating questions rather than critiquing answers, but never names or contrasts a 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?

'Use this when the user is preparing for an interview and wants likely questions' gives a clear triggering context, and it explains the two operating modes (with job_description vs with resume_text). It stops short of stating when NOT to use it or naming an alternative tool for adjacent needs.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuine behavior beyond that: the ranking signals used (repetition, position, required/preferred headings), that high-priority items are flagged, the accepted input size, and a rules version pin. It does not say what happens on invalid or too-short input, which keeps it short of a 5.

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

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

Front-loaded with the use condition, then the output, then routing to the sibling — a sensible order. Slightly dense as a single block, and the 'Rules version 2026-11-05.2' suffix is noise for an agent deciding whether to call 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?

With one parameter, no output schema and full annotation coverage, the description supplies the output shape (ranked list with flags) and the input constraint, which is what an agent needs. Only error/edge-case behavior is unaddressed.

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

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

Schema description coverage is 100% and the single parameter already documents the 120–20,000 character range and the fetch_job_post fallback for links. The description restates the length bound and adds no new meaning about the parameter, so the baseline 3 applies.

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

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

States a specific verb and resource ('List the skills, tools and requirements a job posting asks for') plus the ranking logic, and explicitly contrasts itself with match_job. An agent can distinguish it from check_resume or tailor_resume without opening any schema.

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

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

Gives an explicit trigger ('when the user has only a job posting (no resume yet)') and a named alternative for the adjacent case ('Use match_job to see which a resume already shows'). The when-to-use and when-to-use-something-else are both stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds real behavioral value beyond that: it discloses that each item carries a Studio link and that example resumes also carry a preview image, telling the agent this is a discovery/navigation result rather than a payload.

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, zero filler, with the usage trigger front-loaded before the output description. The phrase "each with a link that opens Studio" is repeated twice, a minor redundancy that keeps it just short of ideal.

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 explaining what comes back, and it does: two result groups (designs, example resumes) and the fields on each (Studio link, preview image). Nothing an agent needs to call or interpret this tool is missing.

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

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

The tool takes zero parameters, so per the baseline the schema carries no semantics for the description to compensate for. The description correctly adds nothing about inputs and stays focused on output content.

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 ("List ATSPrep's resume designs" plus example resumes by role) and enumerates what each entry contains. No sibling tool lists templates, so an agent can distinguish this from open_in_studio or tailor_resume without opening a schema.

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

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

"Use this when the user asks for resume templates, designs or example resumes for a role" gives an explicit triggering intent, which is unusually clear. It does not name a sibling as an alternative or add exclusions, but no sibling is close enough to require routing guidance.

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

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

Annotations already establish readOnly/idempotent/closed-world, and the description goes well beyond them: it discloses that three scores are returned and must never be averaged, that quality comes from a versioned judge with rules fallback while keyword coverage uses fixed rules, and it cites a rules version. It also states the posting length envelope, which affects invocation success.

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

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

Front-loads the trigger and the sibling exclusion, then moves to return-shape guidance, which is the right order for an agent deciding whether to call. Slightly dense and mildly redundant in the parenthetical '(also coverage for compatibility)', and the rules-version sentence is useful but tacked on.

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, so the description carries the burden of explaining returns, and it does: headline resumeQuality, separate jobFit, keywordCoverage with alias, plus matched/missing terms, sentences, match types, weights and required/preferred coverage. For a two-parameter read-only tool, nothing an agent needs in order to call or interpret it is missing.

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

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

Schema coverage is 100% and both parameters are fully described, so the baseline would be 3; the description nonetheless adds interpretation the schema cannot, by explaining that scores are reported separately rather than combined, which shapes how an agent should treat the two inputs as independent dimensions. It reinforces the 120–20,000 character posting bound.

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 concrete verb and resource (match a resume to a job posting) and immediately scopes the use cases: match quality, missing keywords, apply/no-apply. It also explicitly distinguishes itself from the sibling tailor_resume, so an agent can route without opening either schema.

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

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

Gives an explicit trigger ('user has a resume and a job posting and asks how well they match...') and an explicit exclusion with the alternative named ('For rewrites, use tailor_resume instead'). The job_description schema also routes link inputs to fetch_job_post, covering the main adjacent case.

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

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

Annotations already declare the safe read-only, idempotent, non-destructive profile, so the bar is lower. The description adds genuinely non-obvious behavior beyond them: the text travels in the link's #fragment and is 'never sent to a server', which is a meaningful privacy trait an agent should convey.

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

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

The when-to-use trigger is front-loaded, and the sentences are short. There is mild redundancy (it restates the template/PDF/download idea twice), but nothing materially wasteful.

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

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

For a one-parameter tool with full schema coverage, annotations covering safety, and no output schema, the description supplies everything an agent needs: the trigger, the resulting link behavior, and the privacy model of the fragment.

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, so the schema already documents resume_text fully. The description references the resume but adds no format, length, or syntax detail beyond what the schema provides, so baseline 3 applies.

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

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

The description states a specific verb and resource ('Make a link that opens this resume in ATSPrep Studio') and names the concrete outcomes (edit, apply template, download PDF). It clearly distinguishes itself from siblings like check_resume or tailor_resume, which analyze or rewrite rather than open an editor.

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

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

It gives an explicit when-to-use trigger ('when the user wants to edit their resume in an editor, apply a template, or download it as a PDF or Word file'), which is clear context. However, it names no alternatives or exclusions, so the agent is left to infer that check_resume/tailor_resume are not this tool.

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

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

Annotations already cover the safety profile (readOnly, non-destructive, closed-world), and the description adds genuinely new behavioral context: an AI portion drafted by named models behind ATSPrep's guard that drops any figure, name or tool not present in the user's text, plus explicit degradation behavior (rule-based portion still returns and ai.message explains why). This is rare, valuable disclosure of processing pipeline and failure modes.

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

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

Front-loaded with the trigger condition, then a dense but purposeful list of what the review returns, then behavioral notes. Every sentence carries information, though the long enumerated second sentence and model-name detail 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?

With no output schema, the description carries the burden of explaining returns, and it does so thoroughly (rating, timings, STAR coverage, fillers, follow-up question, stronger answer). Combined with the fallback explanation, an agent knows what it will get from the four-parameter call.

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

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

Schema description coverage is 100%, so the schema already explains each parameter, including the kind enum and the optional resume_text. The description only obliquely touches parameters ('keeps to the user's own facts'), adding little syntax or format meaning beyond the schema, so the baseline 3 applies.

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

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

The description uses a specific verb+resource ('Review the user's answer to an interview question') and enumerates exactly what the review contains (rating, length/speaking time, STAR coverage, filler words, likely follow-up, stronger version). This clearly separates it from siblings like interview_questions (which generates questions rather than scoring an answer).

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 this when the user gives an answer to an interview question and wants feedback on it' states a clear triggering condition. It does not name a competing alternative (e.g., interview_questions for question generation) or any when-not condition, so it stops short of full routing guidance.

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

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

Annotations already flag readOnly/idempotent/non-destructive, and the description adds substantially: the comparison basis is 60 roles' typical asks phrased by region (Kenya, Gulf, India, UK, US), the results are 'typical asks, not a real posting', and outputs are a count 'never a percent'. That caveat plus the follow-up instruction is exactly the context annotations cannot convey.

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

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

Correctly front-loads the trigger before the mechanics, and every clause is substantive. The second sentence is nonetheless very long, stacking role families, regions, five return fields and a caveat in one breath – readable but denser than ideal.

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 carries the return-value burden and does it: up to 3 roles, the asks-count, strongest matches, first gaps, own-title match, and search links. It also sets the boundary that this is a starting point, not a tailoring target, which is everything an agent needs to call and interpret it correctly.

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

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

Schema coverage is 100%, so resume_text and location are already documented. The description only indirectly adds meaning by saying it returns 'search links for openings near them', implying location drives those links, but gives no format or default detail beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('suggest roles' from a resume) and scopes it to reading the resume against 60 named role families. The opening 'Use this when the user asks what jobs or roles they could apply for' makes it clearly distinct from match_job and tailor_resume, which need a real posting.

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

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

Gives an explicit trigger ('user asks what jobs or roles they could apply for'), names the alternatives to use next ('ask the user for a real opening and run match_job or tailor_resume on it'), and states an explicit prohibition ('Never tailor a resume to the typical asks'). Nothing about when to use or avoid 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?

Beyond the readOnlyHint annotation, it discloses that the tool never applies edits, never averages resumeQuality with jobFit/keywordCoverage, never invents figures/names/tools, and returns confirm_with_user and next_step. It also documents the AI-plus-rule-based fallback path and what ai.message reports when the model is unavailable, which is exactly the kind of behavior an agent cannot infer from structured fields.

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

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

The trigger is front-loaded and every clause carries information, but the middle is a dense run-on ('a probable qualitative outcome is a suggestion to keep only if true' is hard to parse) and naming the exact models and hosting platform is implementation detail that does not help tool selection.

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 carries the full return-value burden and does so: it enumerates the headline metric, the two separate scores, missing posting terms, per-edit borrowed terms, confirm_with_user, and next_step. Combined with the guard and fallback behavior, an agent knows what comes back and how to present it.

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

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

Schema coverage is 100% and both parameters are fully described in the schema (including the 120–20,000 character bound and the fetch_job_post handoff for links). The description adds no parameter-level meaning, so the baseline 3 applies.

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

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

The first sentence names a specific verb and resource ('resume rewritten or tailored') plus the trigger condition ('for a specific job posting'), so the agent can distinguish it from check_resume or match_job. It stops short of explicitly naming which sibling to use instead when the user only wants scoring versus rewriting.

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 a clear activation condition ('when the user wants their resume rewritten or tailored for a specific job posting'), which is stronger than most definitions. It does not state when NOT to use it or name alternatives like match_job/keyword_scan for scoring-only requests, so the routing burden is only partly removed.

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

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

With annotations already declaring readOnly/non-destructive, the description goes well beyond them: it discloses that output is a hybrid of rule-based and AI drafts, names the exact models and backup, explains the ATSPrep guard that drops figures/names/tools absent from the user's text, and states the graceful-degradation path (rule-based part still returns, ai.message explains). This also substantiates the idempotentHint=false annotation.

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 sentences, front-loaded with the when-to-use trigger, and each sentence adds a distinct fact (draft composition, AI/guard behavior, fallback). The model-infrastructure detail (Gemma 4, Llama 3.3 70B, Cloudflare Workers AI) is slightly heavier than the agent strictly needs, but it is not padding.

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

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

With no output schema, the description carries the return-value burden and does so partially: it explains that a rule-based part plus an AI part come back and that ai.message conveys failures, but it does not enumerate the output fields an agent should expect to consume. Adequate for calling the tool; slightly incomplete for interpreting results.

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

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

Schema description coverage is 100%, so both parameters (resume_text, target_title) are already documented in the schema; the description merely alludes to resume structure ('title, skills and the bullets that carry a figure'). Baseline 3 applies when the schema does the heavy lifting and the prose adds no format or constraint detail.

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

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

The description names a specific verb (draft/write) and resource (resume summary or professional profile) and grounds it in the source artifact ('from their resume'). An agent can distinguish it from siblings like generate_linkedin_headline or draft_cover_letter without opening the schema.

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

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

The opening clause gives an explicit trigger: 'Use this when the user wants a resume summary or professional profile written from their resume.' That is clear when-to-use guidance, but it never names an alternative or a when-not condition (e.g., vs. generate_linkedin_headline for a LinkedIn About), so routing still requires inference.

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