Worklittle Jobs

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

Annotations already declare destructiveHint=true and openWorldHint=true, and the description reinforces this by stating it 'submits the application' to an employer by default and explains how to stop before submission. It adds real context (external submission, default-true submission) but doesn't state irreversibility or any rate/company limits beyond what max_per_company's schema covers.

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

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

Front-loaded with the core action, then progressive detail on the review workflow. It is dense and the third sentence packs several conditions, but every sentence carries operational meaning and 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 14-parameter, multi-step, externally-effectful tool with an output schema, the description covers the primary flow and the safe-review alternative well. Minor gaps: the test-mode practice run, batch job_ids, and applicant_id reuse are left entirely to the schema, but the critical decision points are addressed.

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; the description earns above that by explaining the workflow semantics of key flags — auto_submit's default and review state, and that applicant fields are only needed for Worklittle-hosted postings. It doesn't cover test, job_ids batching, or applicant_id reuse, which live only in the schema.

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

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

States a specific verb and resource ('Apply to a job for the user') and immediately clarifies the mechanism: Worklittle fills and submits the application in a browser. This distinguishes it from siblings like submit_application or check_application_status, which operate on an already-created application.

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 explicit routing: 'Pass job_id from search_jobs', and names the review-first alternative path (auto_submit false → check_application_status → submit_application only after user approval). Both the default and the when-not condition are stated, with the sibling tools to use at each step.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description still adds real value beyond that by disclosing the semantics of the returned status — 'Only the status completed means it was submitted' — which prevents an agent from misreading partial states as submission.

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, no filler, with the core purpose front-loaded before the status caveat. The 'Jobs —' prefix duplicates the title and adds nothing, which is the only wasted token.

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

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

An output schema exists, so return values need not be explained. The blocking gap is the undocumented session_id: for a single-parameter tool with 0% schema coverage, an agent has no guidance on how to acquire the required input, which is the one thing it must get right to call the tool.

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

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

Schema description coverage is 0% and the single required parameter session_id has no description in either the schema or the description text. The description never explains what a session_id is, where to obtain it, or whether it is a job-application session or a chat session — leaving the only input undocumented.

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

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

The description names a specific verb (Check) and resource (an application Worklittle is filling out) and enumerates what is returned: status, filled form fields, and a live view link. That scope — a single in-flight application — implicitly separates it from list_active_applications and submit_application, but 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?

Usage is implied by the phrase 'an application Worklittle is filling out,' which suggests polling an application currently in progress. There is no explicit when-to-use statement, no exclusion, and no routing to alternatives such as list_active_applications (for many) or steer_application (to change direction).

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered. The description adds the key non-obvious fact about blast radius: only the main resume is removed and "other saved resumes stay," which is exactly the detail an agent needs before committing a destructive call.

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 short sentences with zero filler, and the scope-limiting clause is front-loaded where it matters most for a destructive operation. Nothing needs trimming.

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 annotations covering destructiveness/idempotency, zero parameters, and an output schema present, the description needs only to convey scope — which it does. Minor residual gap: it doesn't say what happens to in-flight applications tied to that resume, though that may be covered by the output schema.

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

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

The tool takes zero parameters, so there is no parameter semantics to document; the baseline for a parameterless schema is 4. The description correctly implies the target is fixed (the user's main resume) rather than selectable.

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 ("Delete the user's main resume from their profile") and narrows the scope to the main resume, which an agent could otherwise confuse with a general resume-deletion. It doesn't explicitly name a sibling (e.g. get_my_resume / upload_my_resume), but the scope qualifier does most of the disambiguating work.

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 agent can infer this is the tool for removing the user's primary resume. There is no explicit when-to-use/when-not, no mention of prerequisites (e.g. whether a main resume must exist), and no routing to alternatives for deleting other saved resumes.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds useful semantic context on what auto_apply/auto_submit/tailor_resume mean, but says nothing about auth/connection requirements, defaults, or behavior for a user with no settings configured.

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?

One front-loaded sentence with the resource first and the three field definitions as compact parentheticals; every clause carries information. Slightly dense but no wasted text.

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

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

An output schema exists, so return values need not be described, and the description still explains the meaning of the three flags. The only gap is the missing pointer to update_apply_settings and any account-connection prerequisite, both minor for a read-only zero-arg getter.

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 schema is trivially complete. Baseline 4 applies for a no-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?

States a specific verb and resource (get the user's apply settings) and defines each of the three settings returned, so the agent knows exactly what this retrieves. It does not name or contrast with the obvious sibling update_apply_settings, so sibling differentiation is left to the tool name.

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 by the getter framing — an agent can infer it should call this before update_apply_settings, but the description never says when to use it versus that sibling, nor any prerequisites. No explicit when/when-not guidance is given.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world. The description adds genuinely non-obvious behavior: query-based resolution silently picks the FIRST matching live listing, which is a caveat an agent would not otherwise know. It stops short of covering ordering criteria or pagination, so not 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?

Two tight, front-loaded sentences with no filler, and the constraint on match selection comes before the fallback path. The 'Jobs — ' prefix merely echoes the title and title field, a minor redundancy.

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

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

An output schema exists and the tool is a simple read with all-optional parameters, so the description only had to resolve which parameter to use — which it does well. The one remaining gap is conflicting-parameter behavior, which is unlikely but not addressed.

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 3 is the baseline, but the description goes further by explaining the precedence relationship between job_id and query and the conditional role of location — relational semantics the schema does not express. It does not clarify what happens if both job_id and query are supplied, preventing 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?

States a specific verb and resource ('Fetch detailed information about a specific job') and enumerates what detail is returned (responsibilities, qualifications, company details). It is clearly distinguishable from search_jobs, which returns listings rather than details.

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

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

Explicitly gives both invocation paths: pass job_id when it came from search_jobs, otherwise pass query plus optional location. It even supplies a concrete example ('first software engineer job in Austin'), leaving no ambiguity about which alternative to 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 readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false. The description adds real value beyond that by describing what comes back for each mode and flagging that salary signals only cover "listings that publish pay" — a meaningful coverage caveat.

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 purpose and followed by the unfiltered-then-filtered call pattern in a logical order. The leading "Jobs —" restates the title in the description field, a minor redundancy.

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

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

An output schema exists, so return values need not be exhaustively explained, and the rich annotations carry the safety profile. The only gap is the unmentioned workplace_type parameter, which the schema covers but the prose ignores.

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

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

Schema description coverage is 100%, so the schema already documents query, location and the workplace_type enum; baseline is 3. The description reinforces query/location with the same examples found in the schema but never mentions workplace_type, adding little beyond structured data.

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

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

States a specific verb and resource: "Returns aggregate job-market statistics from Worklittle." The aggregate/slice framing implicitly separates it from listing-oriented siblings like search_jobs, but no sibling is named explicitly, so it falls 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?

Gives clear conditional guidance: call with no args for the full indexed market, pass query and location when the user names a role and/or city, with a worked example. It does not name an alternative tool or state when not to use this one, so no exclusion guidance.

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

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

Annotations already declare readOnlyHint/idempotentHint, so the safety profile is covered; the description adds the non-obvious behavioral fact that an unlinked account yields connected=false rather than an error. That is real value beyond the structured fields, though nothing is said about caching or scopes.

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 action and payload, followed immediately by the edge-case and fallback. No wasted text.

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

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

With an output schema present, return values need not be spelled out, and the description still summarizes the payload and covers the connected=false case. Slightly incomplete in not stating any precondition about authentication for the success path, but nothing an agent needs to call 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?

Zero parameters, so there is no parameter semantics to explain and the baseline of 4 applies. The description correctly implies the tool takes no arguments and targets the current user implicitly.

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 ("Get the user's Worklittle profile") and enumerates the returned content (name, location, contact details, job preferences). It is clearly distinguishable from sibling readers like get_my_resume, which it explicitly names.

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 failure-case routing: if the account is not linked, use get_my_resume or apply_for_job to sign in. It does not explicitly frame when to prefer this over update_my_profile, but the read-oriented framing plus named alternatives gives clear context.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description earns credit beyond them by disclosing the three-state result model — 'ready, processing or missing' — which tells an agent that a missing resume is a normal state rather than an error and that a processing state may require retry logic.

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 with zero padding. The return shape is front-loaded ahead of the usage advice, so an agent scanning for capability gets it immediately.

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

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

An output schema exists and annotations cover safety, so the description need not re-document the response. What it does add — the tri-state status semantics and a concrete use case — is exactly the gap the structured fields leave open for a zero-parameter read.

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 rubric this lands at the baseline of 4. The description correctly implies a no-argument call by never referencing any input, and nothing is left ambiguous about what the caller must supply.

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 ('Get the user's main resume') and enumerates what the caller receives: status, resume text, and profile details. It implicitly distinguishes itself from upload_my_resume and delete_my_resume via the read verb, but it never names those siblings, so an agent must infer the boundary rather than being told.

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 concrete trigger for use: 'Use it to tailor advice or an application to the user's real experience.' That is a clear context, not just an implied one. It stops short of saying when not to call it (e.g., prefer get_my_profile for profile-only reads) or what to do when status is 'missing' — upload_my_resume is the obvious follow-up but is never mentioned.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is covered; the description adds value by naming the status taxonomy that qualifies as 'active' and the identifiers (job_id, session_id) it surfaces. It does not mention pagination or ordering, leaving a minor 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?

Two compact sentences, front-loaded with the verb+resource and followed by the actionable purpose. No filler or restatement of 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 an output schema present and no input parameters, the description need not explain return shapes, and it covers scope and purpose adequately. The only thing an agent might still want is ordering/pagination behavior, which is 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?

The tool takes zero parameters, so the baseline is 4. The description correctly implies a no-argument call and instead describes what the result contains, which is the right focus for a parameterless 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?

States a specific verb and resource (list the user's applications) and narrows scope precisely to those 'being filled out right now', enumerating the states queued/running/waiting-on-user. This is clearly distinguishable from siblings like check_application_status or list_recent_chats.

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 it to find which one to stop or check' gives the selecting condition and points at the downstream actions, which map to stop_application/steer_application/check_application_status. It stops short of naming those siblings explicitly or stating when this list is NOT the right tool, so it is clear context rather than full routing.

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

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

Annotations already declare readOnlyHint/idempotentHint, so safety is covered; the description adds genuine semantics by mapping raw status values into pending-vs-finished buckets and explaining what 'completed' actually means (submitted). It says nothing about pagination or result ordering behavior, 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?

Three compact sentences, front-loaded with the resource and its pending/finished split, then the invocation rule, then the filter list. No sentence is filler and nothing is buried at the end.

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

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

The tool has an output schema, so return values need not be described, and annotations cover the safety profile. The description supplies the domain grouping that the schema cannot express; the only meaningful gaps are limit/pagination behavior and the status value example that disagrees with the enum.

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 schema coverage at 25%, the description must do the heavy lifting, and it does list the filterable fields (status, job_id, applicant_id). It adds little beyond the schema, omits limit/pagination entirely, and its example status value 'applied' does not match any enum member (the closest is 'completed'), which could mislead an agent constructing a filter.

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 (list applications) and immediately disambiguates the two result classes: pending (matched, awaiting approval, running, awaiting user) and finished (completed/submitted, failed, stopped). This is enough to distinguish it from siblings like list_active_applications and check_application_status 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 invocation rule — 'Check it before applying so the same job is never applied to twice' — which is real, actionable guidance rather than implied usage. It does not, however, name the sibling tools (list_active_applications, check_application_status) or say when those are preferable, so there is no explicit alternative routing.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so safety is covered. The description adds useful scope (user's own chats) and returned fields, but says nothing about pagination behavior or ordering beyond the bare word "recent".

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?

One efficiently front-loaded sentence with no filler. The only waste is the "Jobs —" prefix, which costs tokens and briefly points toward the wrong domain.

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

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

An output schema exists and annotations are rich, so the description need not explain return values. It is adequate for this simple two-parameter read tool, though a hint about ordering or what "recent" means would close the remaining gap.

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

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

Schema coverage is 100%, with limit and cursor fully documented (default 20, max 50, next_cursor semantics). The description adds no parameter meaning beyond that, 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 user's recent Worklittle chats") plus the fields returned (title and status) and the consumer (app sidebar). It cannot differentiate from a chat sibling because none exists, but the "Jobs —" prefix slightly muddies an otherwise clear purpose.

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

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

Usage is only implied by "for the app sidebar"; there is no explicit when-to-use, when-not-to-use, or alternative routing. "Recent" is never defined, leaving the agent to infer ordering and scope.

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 destructiveHint=true, idempotentHint=true, readOnlyHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description contributes no additional behavioral context such as what session state is invalidated or whether re-authentication is required.

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?

A single front-loaded sentence with no filler. The leading "Jobs —" tag adds little value but the sentence itself is efficiently structured.

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

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

An output schema exists and annotations carry the safety profile, so the description does not need to explain returns. It is minimally complete for a no-param action, but omitting the consequence of logging out (session termination, re-auth needed) leaves a small 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline is 4. No parameter-level semantics are needed.

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

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

States a specific verb + resource ("sign the user out") and names the service (Worklittle), so an agent knows exactly what it does. The odd "Jobs —" prefix is confusing but the core purpose is unambiguous, and no sibling tool competes for this action.

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 guidance on when to invoke this versus when not to, no preconditions (e.g., must a session exist), and no mention of what the caller should do afterward. The agent is left to infer that this is the only logout path.

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

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

Annotations already declare readOnlyHint=false and idempotentHint=false, so the agent knows this mutates state and is not repeatable. Beyond that the description adds nothing: no token lifetime, no auth/permission requirements, no statement about what the session grants or whether prior sessions are invalidated.

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?

A single compact sentence with the action front-loaded, marred only by the redundant 'Jobs —' prefix carried over from the tool group.

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

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

An output schema exists, so return values need not be explained, and a zero-parameter tool has little surface to cover. However, for a credential-minting operation the description omits essential operational context such as the scope and lifetime of the sign-in link.

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 schema needs no description-level compensation; baseline is 4.

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 output artifact ('Create a sign-in link') and adds the purpose ('so the Worklittle app can open the user's chats on worklittle.com'). It is clearly distinct from the job-application siblings, though the leading 'Jobs —' group label is inherited noise that doesn't describe this tool.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. An agent must infer from the phrase 'the Worklittle app can open the user's chats' when this link-minting step is actually appropriate.

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

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

Annotations flag destructiveHint=true and idempotentHint=true, and the description adds the crucial operational context for that destructiveness: the new text 'replaces the old text', so the caller must pass the full merged text to avoid data loss. This meaningfully extends the raw annotation, though it doesn't address auth or rate limits.

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

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

Front-loads the purpose and content enumeration, then closes with the merge and authoring instructions. The opening sentence is dense but every clause carries routing or behavioral payload; no filler sentences.

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

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

For a single-parameter write whose return value is covered by an output schema, the description supplies purpose, triggering context, the destructive-replace warning, the read-merge prerequisite, and authoring constraints. Nothing an agent needs to call it safely 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 baseline is 3, but the description goes further by specifying what the string should contain (standing application facts), how to author it ('in the user's words; never invent facts'), and that it is a full replacement rather than a patch — genuine meaning beyond the schema's terse field description.

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

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

States a specific verb+resource ('Save standing facts about the user') and names the exact target field ('More about you' text in Settings), enumerating concrete content types like work authorization, notice period, and desired salary. This lets an agent distinguish it from the sibling update_my_profile 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?

Explains when the facts are consumed ('on every future application' via Apply with AI) and mandates a pre-step: read get_my_profile first and merge so nothing is lost. It names the alternative read tool and the workflow condition, leaving little 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, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely new behavioral context: ranked typeahead ordering, the returned field set, and an anti-hallucination rule ('do not invent company ids or slugs') plus a documented empty-result path.

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

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

Front-loaded with purpose, scope, and return fields before the usage and fallback sentences. Five sentences is slightly long, but each carries distinct operational value (trigger, fallback, failure messaging), so there is minimal waste.

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

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

An output schema exists, so return values need not be fully explained, yet the description still names the key fields. Combined with annotations covering the safety profile and the description covering trigger, downstream use, and empty-result handling, an agent has everything needed to call this 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%: q (min 2, max 80) and limit (default 5, max 20) are fully documented in the schema. The description restates that lookup is by name or slug but adds no syntax, matching, or formatting detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ('search the Worklittle market company index by name or slug') with the result shape and ranking behavior ('ranked typeahead'). It is clearly distinguishable from the sibling search_jobs, which is referenced by name as the downstream consumer.

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

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

Explicit trigger: 'Use when the user names an employer and you need a real slug/id for search_jobs company= filters, job alerts, or automations.' It also prescribes behavior on zero hits (try alternate spellings, then report the employer is not indexed and offer close matches), which is unusually actionable 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?

Adds real context beyond annotations: 'Search is anonymous. Do not call get_account, apply, or ask the user to Connect,' OAuth only on apply, and the near→country→world widening with search.scope semantics. These are non-obvious behavioral traits the readOnly/openWorld annotations don't 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?

It's a ~500-word wall of run-on guidance that redundantly restates schema descriptions (negation, recency mapping, company slugs). Front-loaded first two sentences are strong, but the remainder is unstructured and many sentences do not earn their place by adding anything beyond 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?

All 19 parameters are documented and it exposes the map-scope default, widening behavior, and anonymous access — enough for correct invocation, and an output schema exists so return values need no explanation. It is arguably over-complete rather than lacking, which keeps it just under 5.

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?

At 100% schema coverage the baseline is 3, but the description adds genuinely additive rules: the 'visa_sponsorship set + no posted_within_days → skip the 7-day default' rule and city radius guidance ('25-50 for a city'). Much of the rest restates schema text (dash-negation, recency mapping), so it lands at 4 rather than higher.

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?

Opening sentence states a specific verb and resource: it 'opens the Worklittle jobs MAP for a place and an optional role,' and explicitly contrasts itself with 'a list of jobs.' The role (map-based job search) is unambiguous versus siblings like get_job_details or search_companies.

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

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

Explicitly says 'Call it whenever they want Worklittle jobs' and how to route multi-metro vs. near_* intent, when to omit place fields, and how to interpret umbrella phrases. It also states a fallback when an include-company filter returns zero. This is about as complete as usage guidance gets.

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 destructiveHint=true, idempotentHint=false, and openWorldHint=true. The description adds genuinely useful behavioral context beyond them: the operation is non-interrupting ('without stopping it'), it applies across multiple application states, and it carries a strong 'never add facts' constraint. It does not address the destructive/mutating nature directly, but the added operational context is substantial.

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

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

Front-loaded with purpose, then usage conditions, then concrete examples, then constraints, then parameter sourcing. Despite its length, every sentence carries distinct, actionable information with no repetition.

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

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

An output schema exists, so return values need not be described. Combined with the annotations, the description covers triggers, state applicability, the session_id dependency, and behavioral constraints – everything needed to invoke the tool correctly.

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

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

Schema coverage is only 50% (session_id has no description), so the description must compensate, and it does: it names the session_id's source ('from apply_for_job or list_active_applications') and elaborates the instructions parameter's intended content ('their wish as plain instructions with their exact facts; never add facts'). This adds real meaning beyond the schema.

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

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

States a specific verb and resource ('Change what an application in progress fills in') with the key differentiator 'without stopping it.' An agent can immediately distinguish this from apply_for_job, stop_application, and submit_application among the siblings.

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

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

Names explicit trigger conditions with user-utterance examples, states the states in which it works (running, ready to submit, waiting for answers), and routes to save_about_me for a related but distinct need. When/when-not and alternatives are all covered.

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 destructiveHint=true, idempotentHint=true and readOnlyHint=false, so the safety profile is covered structurally. The description adds the non-obvious consequence that the cancellation is irreversible and the user must restart the application — genuinely useful context beyond the annotations.

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

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

Three short sentences, front-loaded with the action and immediately followed by the consequence and the required input. No filler or repetition of 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?

An output schema exists, so return values need no explanation, and annotations carry the safety hints; the description fills the key remaining gap (irreversibility plus input source). It is nearly complete, missing only guidance on when another sibling is the better choice.

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

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

Schema coverage is 0% and the single parameter has no description, so the description must compensate. It does so by stating the parameter's provenance (from apply_for_job or list_active_applications), though it gives no format or validity details for the session_id string.

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?

"Stop an application that Worklittle is filling out for the user" names a specific verb and resource, and the scope (an in-progress application) separates it cleanly from siblings like delete_my_resume, steer_application, or submit_application.

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 tells the agent the prerequisite source for the argument (session_id from apply_for_job or list_active_applications), which is real routing guidance. It does not, however, say when to prefer this over adjacent tools such as steer_application, so the alternative-selection guidance is incomplete.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the low-level safety profile is covered. The description adds real behavioral context beyond that — the required status precondition and the human-confirmation gate — but never explains the consequence of the irreversible send or what a failure/idempotent replay looks like.

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, no padding, with the identity/scope statement first and the dependency precondition second. Every clause carries operational meaning.

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 annotations covering safety and an output schema covering return values, the description only needed to supply the workflow gate, which it does well. It stops short of describing what happens to the application record after submission or the failure mode when the status is not awaiting_submit.

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

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

There is one parameter (session_id) with 0% schema description coverage, and the description says nothing about it. The schema does supply its type and the Session-Id header mapping, which makes it largely self-evident in context, so this is adequate but leaves a gap the description should have closed.

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 ('Send an application') plus the precise object and its originating state ('that stopped for review ... status awaiting_submit'). It also contrasts with the sibling apply_for_job by naming the parameter combination (auto_submit false) that distinguishes the two, so an agent can route correctly without opening schemas.

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

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

Gives explicit preconditions: only after check_application_status output has been shown to the user and only after the user affirms sending. This is a genuine when-to-use gate referencing a named sibling tool, not implied guidance.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true and destructiveHint=true. The description adds that this writes to a list and mutates status, but it never discloses the destructive aspect flagged by the annotation — e.g. whether changing status overwrites a prior stage — nor any auth or overwrite semantics, leaving a notable gap for a mutation 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?

A single efficient sentence front-loads the action and outcome with no wasted text. The redundant 'Jobs —' title prefix is the only minor inefficiency.

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

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

An output schema exists, so return values need not be explained, and annotations cover safety. However, for a destructive, idempotent mutation living among closely related job-application siblings, the description does not clarify its boundary versus apply_for_job or submit_application, leaving the agent to infer routing.

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 67%, so the schema documents most parameters (job_id source, method/status enums with defaults). The description mentions no parameters, and the two undocumented fields (job_title, company_name) are self-evident; adds little beyond structured data, so a baseline 3 fits.

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 specific verbs (add to list, change status) and the resource (a job in the user's Applied/Saved list), plus the outcome (so they can find it later). It does not explicitly differentiate from the many sibling job tools (apply_for_job, submit_application, steer_application), so it falls short of a 5.

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

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

The description implies when to call it (when a user applies or saves a job so it can be found later), but gives no explicit when-not guidance and never names the alternative sibling tools it could be confused with, such as apply_for_job or submit_application.

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 idempotent=true, destructive=false and readOnly=false, so safety is covered; the description adds value beyond them with the partial-update contract and the billing prerequisite for enabling auto_apply. It does not say whether disabling auto_apply also disables auto_submit or what an unmet prerequisite looks like as a response.

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 the action, then the payload rule, then the prerequisite. No filler and nothing buried.

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

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

The tool is a simple three-flag mutation, an output schema exists so return values need no explanation, and the description covers the action, the partial-update rule, and the key prerequisite. The remaining gap is inter-flag dependency, which matters for a settings tool.

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

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

Schema coverage is 0%, so the description carries the burden and does name all three parameters plus the prerequisite for auto_apply. However, it never distinguishes auto_apply from auto_submit (does submitting require applying?) or explains what tailor_resume governs, so half the semantics remain inferred from the names alone.

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

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

The description states a specific verb and resource: toggling the three named apply settings on or off. It is clearly distinguishable from get_apply_settings by the 'on or off' framing, though it never names that sibling as the read counterpart.

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 send the settings to change' gives explicit partial-update guidance, and 'Turning auto_apply on needs Instant or a card on file' states a real prerequisite. It stops short of routing to alternatives such as get_apply_settings for reading current values.

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 destructiveHint=true and idempotentHint=true; the description's "only send the fields to change" usefully reinforces patch semantics and does not contradict them. However, it never discloses the genuinely destructive behavior (education and experience wholesale replacement, field clearing) or any auth/permission requirements, which are only visible in the schema.

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

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

Two sentences, front-loaded with the verb and resource, with the operational rule last. The "Jobs —" prefix is marginally wasteful but the body has 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?

Output schema exists, so return values need no explanation, and the schema documents replacement semantics for education/experience. Still, for a destructive 32-param mutation with 28% coverage, the description leaves clearing behavior and permission requirements to inference.

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

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

Schema description coverage is only 28% across 32 parameters, so the description carries most of the burden and mostly does not. "Name, location, phone, links or the kind of job they want" gestures at a handful of fields but says nothing about the replace-vs-merge arrays, profile_clear_fields, needs_sponsorship, work_authorization_countries, or the phone/locale fields.

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

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

States a specific verb and resource ("Update the user's Worklittle profile") and enumerates example field families (name, location, phone, links, desired job), which clearly separates it from the read-only sibling get_my_profile. It stops short of naming that sibling, but the intent is unambiguous.

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

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

"Only send the fields to change" gives real partial-update guidance, which is the key usage rule for a 32-param patch tool. It does not cover when to prefer get_my_profile first, when to use profile_clear_fields versus sending an empty value, or any prerequisite checks.

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 destructiveHint=true and idempotentHint=false; the description goes beyond them by spelling out exactly what is destroyed — the current main resume is replaced — and what survives (the other saved resumes, up to 5 per account). It does not cover failure modes or file-size limits, but the destructive blast radius is clearly communicated.

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 the action, then the replacement semantics, then the parameter directive. Nothing is redundant with 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?

An output schema exists and annotations carry the safety profile, so the description only needs to add the semantics those can't express — replacement of the main resume, retention of the other four — which it does. Minor omissions are what happens on unsupported MIME types or oversized files.

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, and the description adds real value by disambiguating the two input modes: it directs the caller to pass the chat attachment as resume_file rather than content_base64. It does not explain when the base64/mime/filename path applies, which is the remaining gap.

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

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

States a specific verb and resource (save the attached resume as the main resume on the Worklittle profile) plus the purpose (so it can be used to apply). It is clearly distinguishable from siblings like get_my_resume, delete_my_resume and apply_for_job 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?

The trigger condition is explicit: use this when the user has attached a resume in the chat and it should become the main resume. It does not name alternatives (e.g. use get_my_resume to inspect, delete_my_resume to remove), so there is no explicit when-not, but the usage context is unambiguous.

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