JustBacked Startup Jobs

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

Annotations already declare this is a non-read-only, idempotent, non-destructive operation, so the description only needs to add context. It usefully discloses the side effect that list_name can create a new list and that alert-enabled lists email the user on role posts or funding rounds, but says nothing about auth needs or duplicate-add behavior.

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

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

Three tight sentences, front-loaded with the action, then the parameter guidance, then the side-effect note. No filler; the final sentence about alerts is slightly tangential but still earns its place as behavioral context.

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 3-parameter mutation tool with no output schema and no annotations covering side effects, the description covers the essential targeting logic and the notable list-creation/alert behavior. Remaining gaps (duplicate handling, permission requirements, error responses) are 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?

Schema coverage is only 33% (list_id and list_name have no schema descriptions), so the description must compensate, and it does: it defines the list_id/list_name alternatives and clarifies that list_name doubles as a list-creation mechanism. It does not disambiguate precedence if both are passed, which keeps it short of 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 ("Add a startup to one of the user's lists") that is immediately distinguishable from the sibling remove_from_list and from list_lists. An agent knows exactly what operation this performs without opening the schema.

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

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

Explains the two mutually exclusive ways to target a list (list_id or list_name) and that list_name may name either an existing list or a new one to create. It gives clear usage context but never states when not to use it, e.g. what happens if both are supplied or if the company is already tracked.

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 ownership scope ('one of the user's saved searches'), which is useful, but says nothing about irreversibility, permissions, or error behavior 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?

One short sentence, verb-first, with the selector trailing. No filler or 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?

For a one-parameter delete where annotations already flag destructiveness and idempotency, the description covers the essentials. Missing only a note on permanence and how to obtain a valid id.

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 'id' parameter has no description, so the description must compensate. It does clarify the id identifies a saved search owned by the user, but offers no format, example, or lookup guidance.

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 (delete) and resource (the user's saved search) with an id selector, which clearly separates it from save_search and list_saved_searches. It stops short of naming those siblings or contrasting behavior, so it's strong but not fully differentiating.

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 guidance on when to use this versus save_search/update flows, no prerequisites, and no note that deletion is permanent. The agent must infer all usage context from the tool name alone.

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 and openWorldHint=false, so safety is covered. Beyond that the description adds no behavioral context — no auth requirements, no rate limits, no note on whether counts are cached or real-time, which matters for 'API usage today'.

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 resource first and the returned fields after. Nothing is wasted and there is no padding or repetition of the tool name.

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

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

With no output schema, the description bears the burden of describing the return payload. It lists the top-level contents but not their shape, units (e.g., what 'API usage today' counts or resets on), or ordering, leaving a read tool whose whole value is its output only partially specified.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description correctly adds no parameter detail because none exists.

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

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

The description names a specific resource (the user's account) and enumerates the content it returns: membership, API usage today, and tracker/list/search counts. This distinguishes it from job/application-centric siblings, though it phrases the purpose as a noun list rather than an explicit retrieval verb.

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 or when-not-to-use guidance, and no sibling is named as an alternative. The agent must infer from the sibling list that this is the only account-level tool, but the description offers no routing help.

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 and openWorldHint=true, so the safety profile is covered. The description adds real value beyond that: it states the data is pulled from public third-party job boards, that it never submits anything, and that actual application happens at apply_url — disclosing scope and side-effect boundaries.

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

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

Three tight sentences with no filler, front-loaded with what is fetched before the usage rationale and the read-only constraint. The only mild friction is the dangling 'apply_url' reference, a field not defined in the schema or an output schema.

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

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

With no output schema, the description must convey the return shape, and it does by listing the returned fields. Combined with the source disclosure and the read-only/no-submit guarantee, an agent has everything needed to call it correctly.

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

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

Schema coverage is 100% and the single 'job' parameter is fully documented (slug from search_jobs or a justbacked.com/jobs URL). The description does not elaborate on the parameter beyond the schema, so the baseline 3 applies.

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

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

The description names a specific resource (the role's application questions) and enumerates what is returned (labels, types, required, options) plus the upstream source (Greenhouse/Lever/Ashby public job board). This clearly separates it from siblings like get_job or list_applications, though no sibling is named explicitly.

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

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

It gives a concrete use context ('so you can draft answers for the user to review') and a workflow boundary ('The user applies at apply_url'), which tells the agent this tool is for preparation, not submission. It stops short of naming an alternative or an explicit when-not condition.

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 and openWorldHint=false, so the safety profile is covered. The description usefully discloses the scope of returned data (including 'every open role'), hinting at a potentially broad payload, but says nothing about freshness, rate limits, or behavior for unknown companies. Adequate but not rich.

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 with every clause carrying content; no wasted words. It loses a point for being a fragment that front-loads a bare noun phrase rather than an action, though the enumerated fields are informative.

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

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

With no output schema, the description carries the return-value burden and does so credibly by listing the profile fields. For a one-parameter read tool with annotations covering safety, the remaining gaps (pagination, data freshness, error handling) are minor.

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

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

With 100% schema coverage, the single 'company' parameter is fully documented, including the accepted formats (company_slug or name). The description adds no further parameter meaning, so the baseline 3 for high-coverage schemas 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 enumerates the exact content of a startup profile (round, amount, investors, headcount, HQ, hiring velocity, open roles), making it clear this is a company-profile retrieval tool. It is a noun phrase rather than a verb phrase, and it does not explicitly differentiate itself from siblings like search_jobs or get_job, 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 contains no guidance on when to use this tool, when not to, or which alternative to pick when the agent wants job-level or listing-level data. The only workflow hint ('company_slug from search_jobs') lives in the schema, not the description, so no usage guidance is provided here.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description goes further by disclosing exactly what data comes back, which is valuable because there is no output schema; it does not, however, describe behavior for an unknown/expired job slug or any auth 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?

One dense sentence with no filler, front-loaded on the object of the call (a single role) and then the payload. The run-on list is efficient though slightly unpacked, keeping it just short of a 5.

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

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

With no output schema, the description usefully enumerates the returned fields, which is exactly what an agent needs to decide whether to call it. It is a read-only, single-parameter getter, so gaps around error behavior and rate limits are 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?

There is a single parameter with 100% schema description coverage, and the schema already explains that it accepts a slug from search_jobs or a justbacked.com/jobs URL. The description adds nothing about the parameter, so baseline 3 applies.

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

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

States a specific verb and resource (full detail for one role/job) and enumerates the exact payload: description, pay, funding round and investors, hiring velocity, apply URL, ATS, and tracker status. This clearly separates it from list-oriented siblings like search_jobs and from get_company's company-level scope.

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

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

Usage is only implied: the returned fields (apply URL, tracker status) suggest it is the drill-down after search_jobs, but the description never names search_jobs or get_company as alternatives, nor states when this is preferred over them. No explicit when-to-use or when-not-to-use 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 readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds genuinely useful context by naming the returned fields (status, applied date, notes, and counts by status), but says nothing about ordering, pagination behavior, or how the aggregate counts relate to the filtered rows.

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 tight sentence that front-loads the resource and enumerates the payload. No filler, though the fragmentary phrasing skips the verb.

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

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

For a simple read-only, 2-parameter list tool with no output schema, describing the returned fields and counts is close to sufficient. Missing only ordering and whether the counts are global or filtered, which are minor gaps.

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

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

Schema description coverage is 100%, so both the limit and status filter are already documented in the schema. The description adds no additional meaning about how the status filter interacts with the counts or whether limit truncates the aggregate.

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

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

The description names the specific resource (the user's application tracker) and its contents, making it clearly a read/listing tool distinct from mutation siblings like track_application and update_application. It could be sharper about the 'list' verb and scoping, but the intent is unmistakable.

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 mention of alternatives (search_jobs, get_application_form), and no statement of prerequisites. The agent must infer usage purely from the resource name.

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 and openWorldHint=false, so the safety profile is covered. The description adds useful return-content context (open roles, roles added this week) but says nothing about ordering, freshness, pagination, or what an empty list means. Adequate but not rich.

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 resource and its payload are front-loaded, and the integration hint is deferred to the second sentence where it belongs.

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

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

With no parameters and no output schema, the description carries the burden of explaining what comes back, and it does so reasonably well by naming the roles content. Minor gaps: nothing about result ordering, list count, or whether lists can be empty.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The mention that a list id can be reused as list_id in search_jobs is a genuine bonus that links the output to another tool's input.

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

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

The description names the resource (the user's company lists / target companies) and enumerates what is returned: each company's open roles and new roles this week. It is clearly distinct from sibling list tools such as list_saved_searches and list_applications. It lacks an explicit verb, but the noun phrase plus return contents make the purpose 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?

Usage is only implied. The second sentence ('a list id also works as list_id in search_jobs') hints at a downstream workflow but never states when to call this tool versus list_saved_searches or list_applications, nor any precondition. A helpful cross-tool link, but not explicit when-to-use 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=true and openWorldHint=false, so the safety profile is covered without the description carrying that burden. The description adds useful content context (these are email alerts with filters and board links) but says nothing about ordering, volume, or whether it returns only the current user's data.

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 no filler, and the key content (what the item contains) is front-loaded. It is arguably terse enough to border on under-specification, but nothing is wasted.

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

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

For a zero-parameter read tool with no output schema and annotations already covering the safety profile, the description is nearly sufficient: it tells the agent what the returned records are and what they contain. It could note ownership scope or result ordering, but nothing critical is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to document and the baseline of 4 applies. No misleading parameter claims are made.

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

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

The description names the resource precisely and adds clarifying content ('email alerts') plus what each item carries ('filters and board links'), which distinguishes it from save_search and delete_saved_search. However, it never states the verb (list/returns) and doesn't differentiate itself from sibling list tools like list_lists or list_applications.

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 mention of prerequisites or when to prefer this over save_search/delete_saved_search. Usage is only implied by the tool name and the zero-parameter schema.

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 without the description. The description only adds mild scope context (removal happens within the calling user's own lists), which is useful but thin; it says nothing about whether the underlying company/job data survives or how failures are reported.

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 short, front-loaded sentence with no filler or redundancy. Nothing could be trimmed without losing the core action.

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 mutation with full annotation coverage and no output schema, the description is minimally adequate: the action and scope are clear. It stops short on identifier formats and on the recovery/discovery path (using list_lists to obtain list_id), which a caller genuinely needs.

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

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

Schema description coverage is 0%, so the description carries the full burden and largely fails: it never clarifies whether "company" expects a name, slug, or ID, nor what list_id format is valid. "Startup" in the description also mismatches the schema parameter name "company", creating mild terminology drift.

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

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

Specific verb ("Remove") plus resource ("a startup") and target container ("one of the user's lists"), so the action is unambiguous. It does not explicitly name add_to_list as the inverse sibling, but the verb pair makes the distinction obvious.

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 guidance, no prerequisites, and no mention of the obvious alternative add_to_list or of list_lists (to discover list_id). The agent must infer the workflow entirely from the name.

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 only tell the agent this is a non-read-only, non-idempotent, non-destructive write. The description adds the substantive side effect the agent actually needs: JustBacked will email new matching roles on the chosen cadence, permanently. That is real behavioral value beyond the annotations. It stops short of noting that repeat calls create additional saved searches or what the response contains.

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

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

Two sentences, zero filler, and the core action plus the alert behavior are front-loaded. Nothing is repeated from the title or 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?

For a 24-parameter, zero-required tool with no output schema, the description covers the core action and the alert side effect but omits what the call returns (saved search id/name?), whether any parameters are required, and how it relates to list_saved_searches/delete_saved_search. Adequate but leaves real gaps for an agent wiring the result into later calls.

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

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

Schema description coverage is 100% across all 24 parameters, so the schema already carries the semantics and a 3 is the baseline. The description only adds the 'same filters as search_jobs' equivalence and names the instant/daily/weekly cadences, which lightly reinforces the alert enum but adds no new syntax or constraint detail.

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

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

States a specific verb+resource ('Save a search') and adds the key differentiator that it produces email alerts. It also links the filter set to the sibling search_jobs, so an agent can tell this apart from a one-off search. It does not explicitly contrast with list_saved_searches or delete_saved_search, but the create/save framing 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?

The description implies the use case (a persistent recurring alert rather than a one-time query) via the email-alert sentence, and it points at search_jobs for filter semantics. However, it never states when to prefer this over search_jobs, nor any precondition such as having an account or existing filters. Usage is inferable but not spelled out.

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 and openWorldHint=false, so safety is covered; the description adds genuine value on top by enumerating the returned fields (title, company, location, pay, latest round, investors, apply link, total matches, board_url) and by noting the freshness/membership behavior ('Members see roles the day they are posted'). It stops short of covering paging/rate behavior, but thanks to the annotations that gap is not fatal.

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

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

Four sentences, front-loaded with the core purpose and scope, then results payload, then the sharing artifact. Nothing is padded, though the 'justbacked.com board' reference carries meaning only for a human who knows that site and would be better replaced with a concrete statement.

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 25-filter discovery tool with no output schema, the description usefully compensates by naming the returned fields and the paging/matching signals (total matches, board_url), and the per-parameter semantics live entirely in a fully covered schema. Only freshness/permission nuances ('Members see roles the day they are posted') are left under-explained.

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%: all 25 filters, their enums, and defaults are documented inline, and the description adds no parameter-level detail beyond the vague 'Same filters as the justbacked.com board'. Per the rubric this is the baseline 3 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?

The description gives a specific verb (Search) plus resource (open roles) and a sharpened scope: startups that raised venture money within the past six months. That scope immediately separates it from the retrieval siblings (get_job, get_company) and the list/application-management siblings, which do not search role inventories.

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 search framing and the 'Same filters as the justbacked.com board' remark; there is no explicit when-to-use, no statement of when to prefer get_job or list_applications instead, and no exclusions. An agent can infer it is the entry point for discovery, but nothing routes it against 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?

Annotations already declare idempotentHint=true, destructiveHint=false, and readOnlyHint=false, so the safety profile is supplied structurally. The description adds useful behavior (status vocabulary, default status 'applied', tracker destination), but omits the note-replacement semantics of the notes field and the applied_at defaulting behavior.

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

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

Front-loads the core action and destination, then packs status semantics efficiently. The status list is slightly redundant with the schema enum but earns its place by framing the saved/applied distinction; nothing is wasted.

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

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

For a 7-param, zero-required mutation tool with no output schema, the description covers the primary decision points (which status, which input form) adequately. It would be fully complete if it clarified note-replacement and the interaction with update_application.

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 57%, so the description meaningfully compensates by explaining the status enum's intent and the mutually exclusive job-vs-(title+company+apply_url) input mode. It does not explain notes replacement or the applied_at default, leaving a couple of gaps.

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 ('Add a role to the user's JustBacked tracker ... or update its status') and even names the visible surface (justbacked.com/saved). However, it does not differentiate itself from the sibling update_application, which also changes application status, leaving a potential ambiguity an agent must resolve by inference.

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

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

Gives concrete conditional guidance for status choice ('saved' for considering, 'applied' only after confirmation) and explains the alternate input path for externally-found roles (title + company + apply_url instead of job). It stops short of naming when to prefer update_application or add_to_list over this tool.

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

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

Annotations already declare the mutation profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the description needn't restate safety. It does add one useful behavioral detail beyond the annotations — that 'notes' overwrites while 'append_note' appends — but says nothing about how the two interact if sent together, or about partial-update behavior when only some fields are supplied.

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 enumerating the three supported mutations with zero filler. Every clause maps to a capability the tool actually has.

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 write tool with no output schema, the description covers the main mutation paths but leaves gaps: interaction between 'notes' and 'append_note', the purpose of 'applied_at', and what a successful update returns are all unaddressed. Adequate to call the tool, but not complete enough to call it confidently.

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

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

Schema coverage is 60%, so the description must carry some of the burden. It usefully distinguishes 'notes' (replace) from 'append_note' (append), which the bare schema does not, but it never mentions 'applied_at' at all and adds nothing about the 'job' identifier beyond what the schema already documents.

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 ('Change a tracked role's status') and enumerates the mutation surfaces (status, notes, append_note), which an agent can distinguish from siblings like track_application and add_to_list. It stops short of explicitly naming which sibling to use instead when the role isn't yet tracked.

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

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

The three enumerated operations ('change status', 'replace notes', 'append a dated note') imply when each parameter is relevant, giving usable context. However, there is no explicit when-not guidance, no mention of prerequisites (e.g. the role must already be tracked vs. using track_application), and no note about combining status and note changes in one call.

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