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

With no annotations, the description carries the full burden and does disclose meaningful behavior: it fills standard fields, uploads a resume, handles platform submission, and prompts for login when the session is missing. It omits important side-effect context for an irreversible external action such as submission failure handling, rate limits, or the fact that this consumes/profile-config state referenced by check_profile_config.

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 primary action and followed by behavioral and edge-case detail. No filler, though the login sentence is slightly redundant with the auto_login schema 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?

For a mutation tool with no annotations and no output schema, the description covers the core flow and the login edge case, which is the right instinct. It stops short of describing failure outcomes or what the agent should expect after submission, leaving a gap an agent acting autonomously would want filled.

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% with four well-documented parameters (including the auto_login default and the platform enum), so the schema does the work. The description adds no parameter-level syntax or format detail beyond what the schema already states. 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 ('Apply') and resource ('a single job') plus the mechanism ('via browser automation'). The scoping word 'single' implicitly separates it from the sibling bulk_apply, though it never names that alternative outright.

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

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

Usage is implied by the 'single job' scoping rather than stated: an agent must infer this is the one-at-a-time counterpart to bulk_apply. No explicit when-to-use, when-not-to-use, or prerequisite guidance beyond the login handling mentioned inline.

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

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

With no annotations at all, the description carries the full burden and does well: it discloses a 10–25s inter-application delay, per-company caps, idempotency behavior (skips already applied), and an auth precondition (validates login sessions). It does not say what happens to a partially-completed run or whether submitted applications are reversible, which keeps it out of the top band for a real-world mutation.

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 tight sentences, front-loaded with what the tool does and the constraints, then the dry_run escape hatch. Every clause carries information; no padding 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?

For a bulk mutation with no annotations and no output schema, the gaps are failure and result semantics: it does not describe what the caller receives, how partial failures mid-run are reported, or how long a capped run takes. Safety and sequencing are covered, so it is adequate but not complete.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters, making 3 the baseline. The description adds only marginal semantic value, mainly reinforcing dry_run as a preview switch and explaining why per-company caps exist; company_window_days and the defaults are left entirely to the schema.

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

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

States a specific verb and resource ('Apply to multiple jobs') and characterizes the scope as sequential bulk submission with rate-limiting, which distinguishes it from the single-job siblings. It never names apply_job or explains the bulk-vs-single boundary, so an agent has to infer the split from the plural 'jobs' parameter rather than from the description.

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 concrete operating context: use dry_run=true to preview, sessions must be validated before real submissions begin, and already-applied jobs are skipped. It stops short of explicit when-not guidance (e.g. 'use apply_job for a single job' or 'do not run while another bulk run is active').

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

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

No annotations are supplied, so the description carries the full behavioral burden. It does disclose the return semantics (per-platform status: logged in, missing session, expired), which is valuable given there is no output schema, but it omits auth requirements, rate limits, whether the check has side effects such as refreshing an expired session, or how long cached status remains valid.

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 core action, then the return states, then the usage rule. The final sentence is guidance rather than repetition of the tool's purpose, though 'before applying' slightly restates the first sentence's framing.

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-annotation read-only check with no output schema, the description covers purpose, return states, and call timing — enough for an agent to invoke it correctly. Gaps remain around the failure/expiry path (what to do when a session is missing or expired) and any side effects of the check itself.

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 sole 'platforms' parameter is fully documented in the schema including the default-all behavior and the valid enum list. The description adds no parameter-level detail beyond what the schema already provides, 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 ('Verify whether login sessions are active for job platforms') with clear scope, and the enumeration of result states (logged in, missing session, expired) pins down exactly what is being checked. This is easily distinguished from siblings like login_account or save_session, which create or persist credentials rather than verifying existing sessions.

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 timing guidance: 'Always check login status before attempting real job applications.' That tells the agent both when to call it and how it relates to apply_job/bulk_apply. It stops short of naming sibling alternatives for the reverse case (e.g., what to do when a session is missing — presumably login_account), so no exclusion routing.

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

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

With no annotations, the description carries the full burden. It discloses the config file path and what gets validated, which conveys a read-only inspection nature. However, it omits side effects, permission requirements, error behavior, and whether it modifies anything, leaving significant gaps for a tool with zero annotation coverage.

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

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

A single front-loaded sentence that identifies the action, target, and checks with no wasted words. It is appropriately sized for the tool's simplicity.

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?

No output schema exists, so the description should explain what a validation returns (e.g., success/failure, error details). It does not, nor does it provide usage context. The description is adequate for a simple check but leaves meaningful gaps for an agent deciding whether and how to interpret 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?

The tool takes zero parameters and the schema is an empty object with 100% description coverage trivially. Per the rubric, zero parameters yield a baseline of 4, as there are no parameter semantics to clarify beyond what the schema already provides.

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 ('Inspect and validate') and resource (the local configuration at ~/.job-apply-mcp/config.json), and enumerates the checks performed (resume PDF existence, candidate details, autofill fields). This clearly distinguishes it from sibling tools like save_session or apply_job.

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

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

The description gives no explicit when-to-use guidance, prerequisites, or alternatives. It does not say when this check should be run relative to other tools (e.g., before applying for jobs), leaving usage entirely implicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Extract' implies a non-mutating, side-effect-free operation, but the description says nothing about whether it hits the network, requires authentication, rate limits, or what it returns when no contacts are found — all material for a tool whose output drives outreach.

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 sentences, front-loaded with the action and outputs. The second sentence partially restates the recruiter-email output already listed in the first, so it is slightly redundant rather than strictly additive, but nothing is padded.

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

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

For a one-parameter, high-coverage tool with no output schema, enumerating the three returned artifact types compensates well for the missing return definition. The remaining gaps — empty-result behavior and invocation prerequisites — are minor for a straightforward extraction utility.

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

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

There is a single parameter with 100% schema description coverage ('Full job description text or posting content'), so the schema already carries the semantics. The description's phrase 'raw job descriptions' corroborates but adds no syntax, size, or format detail beyond it, which is the expected baseline when the schema does the heavy lifting.

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 (extract) with a precise resource (raw job descriptions) and enumerates the exact outputs (recruiter emails, career application URLs, contact names). No sibling tool in the set does extraction, so the purpose is unambiguous without needing explicit differentiation.

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

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

'Used to find recruiter emails for follow-up outreach via Gmail' gives the downstream intent, which implies when to reach for it, but there is no explicit when-to-use/when-not guidance, no prerequisites (e.g., must be called before an apply or outreach step), and no named alternatives.

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

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

With no annotations, the description carries the full burden, and it does disclose real filtering behavior: hard elimination of over-experienced senior roles and blacklisted titles, which is more than the name conveys. However it omits whether this is purely read-only, what the returned structure looks like (filtered list plus ranks/scores?), and how min_match_score interacts with the hard eliminations.

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 sentences with the core action front-loaded and the elimination rules second. Minor ambiguity in '3+ or 5+ years senior roles' costs a point, since the exact threshold logic is unclear.

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

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

For a 2-param, no-annotation, no-output-schema tool, the description explains what filtering does but not what comes back, how ranking is expressed, or whether the candidate profile must exist first. Minimum viable but with clear gaps.

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

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

Schema description coverage is 100%, so both parameters are already documented, giving a baseline of 3. The description adds the notion that filtering is measured against the candidate profile, but no parameter maps to that profile and no extra syntax or format detail is provided 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 pair (filter and rank) and the resource (jobs), plus the criterion (relevance against the candidate profile). It never names the sibling it complements, search_jobs, so an agent must infer the relationship from the schema's 'jobs returned by search_jobs' hint rather than the description.

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 pipeline (jobs come from search_jobs) but the description never states when to call this versus search_jobs, apply_job, or bulk_apply, nor any prerequisites such as needing a configured candidate profile. Adequate but leaves routing 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?

No annotations are provided, so the description carries the full burden. It mentions the data source ('local SQLite database') but doesn't specify permissions, read-only nature, or what happens if the database is empty. For a read tool with zero annotation coverage, this is a significant 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?

A single, well-structured sentence that front-loads the action and scope. No wasted words.

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

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

The description covers the purpose and returns but lacks behavioral details like read-only status, error conditions, or interaction with other tools. Given no annotations and no output schema, more context would be helpful.

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 single 'days' parameter is fully documented in the schema. The description adds no additional meaning about the parameter 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 (Retrieve) and resource (tracked job applications) and lists the fields returned (application dates, platform breakdown, status). This distinguishes it from siblings like check_login_status or filter_jobs.

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 it's for inspecting the user's application history, but it doesn't explicitly state when to use this tool versus alternatives or any prerequisites. No exclusions or alternatives are named.

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

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

With no annotations, the description carries the full burden and does well: it discloses that a visible browser opens, that login is manual/interactive, and that the resulting session/cookies are persisted for later applies. It omits what happens on timeout or failure and whether it blocks until completion, which is why it is 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 sentences: the action and the auth methods are front-loaded, followed by the session-capture outcome. Every clause earns its place with 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?

For a 2-parameter tool with no output schema, the description covers the interaction model and the side effect (saved session) that an agent needs to sequence later apply_job calls. Missing only edge-case behavior on timeout or failed login.

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 are already documented with enum values and the wait_seconds default. The description corroborates the auth-method context but adds no syntax or behavioral detail 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?

States a specific verb+resource (open a visible browser window to log in) plus the downstream effect (session/cookies captured and saved). An agent can distinguish this interactive login tool from siblings like save_session or check_login_status.

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?

Makes clear this is a manual, user-driven login flow rather than an automated one, and names the supported auth paths (OTP, Google sign-in, password). It does not explicitly route against the session siblings (save_session, check_login_status), so it stops short of naming alternatives.

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

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

With no annotations, the description carries the full burden and does disclose two important traits beyond the schema: it opens a visible, user-facing browser window (requires human interaction/GUI) and it persists authenticated cookies (a durable side effect). It omits what happens on timeout, whether it overwrites an existing session, and any auth/permission requirements.

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 no filler; the alias relationship is front-loaded and the behavioral detail follows immediately. Nothing could be removed without losing 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?

For a two-parameter tool with full schema coverage and no output schema, most needs are met, and the visible-window and cookie-persistence notes are the key behavioral facts. It is still slightly thin on the stateful/interactive consequences (blocking behavior, failure handling) that matter for a login 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 100%, so both 'platform' (with its enum) and 'wait_seconds' (with its default) are fully documented in the schema. The description adds nothing about parameter 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 description states a specific action (open a visible browser window for the user to log in) and names the tool it aliases (login_account), so its function is unambiguous. However, because it self-declares as a duplicate of a sibling, it does not explain what distinguishes it from login_account for selection purposes.

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?

No when-to-use or when-not-to-use guidance is given, and the fact that this is presented as an alias of login_account makes the routing question worse: an agent cannot tell from the text whether to call save_session or login_account. Preconditions (an interactive environment with a visible window) are only implied by the behavior sentence.

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

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

With no annotations, the description carries full behavioral burden. It reveals that the search runs via browser automation and returns profile-matched listings, but says nothing about whether an authenticated session is required, expected latency, rate limits, or failure modes across eight external platforms — critical context for a scraping 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?

Two tight sentences with no filler; the platform list and mechanism come first, and the return content follows immediately. Nothing is redundant or padded.

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

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

For a seven-parameter, zero-required, no-output-schema tool the description covers what is returned and across which platforms. It omits auth/session prerequisites and any note on result volume or pagination, which are material gaps given the browser-automation nature of 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 100%, so every one of the seven parameters is already documented (including the LinkedIn-only fetch_jd nuance), making baseline 3 appropriate. The description adds no parameter detail beyond what the schema 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?

The description states a specific verb ('Search for jobs'), names the eight source platforms, and notes the browser-automation mechanism and match scoring. It is clear on what the tool does, but it never distinguishes itself from the sibling filter_jobs, which an agent could easily confuse with the post-search narrowing 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?

There is no guidance on when to call this versus filter_jobs, or on prerequisites such as being logged in (login_account, check_login_status, save_session are siblings). The only implicit usage signal is the default-all-platforms behavior, which lives in the schema, not the description.

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