Winquill

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

Adds substantial context beyond the annotations: the created automation is inert until enabled via turn_on_automation, its rules should be read back to the user for confirmation, and there are hard safety boundaries ("never submit a bid, write to a buyer or email anyone outside the team"). These details directly address the risk profile of a non-destructive but state-creating 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?

Front-loaded with the trigger condition, which is good, but the five-item example list ("add strong fits to the pipeline, remind people of sprint steps, check a bid...") largely restates the template enum descriptions already in the schema, spending words on redundancy rather than new 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?

An output schema exists, so return-value explanation is unnecessary, and the description covers activation state, safety limits, account prerequisite, and confirmation behavior. An agent has everything needed to call this correctly, including the follow-up turn_on_automation step.

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 template enum itself carries per-template explanation, so the schema does the heavy lifting. The description contributes only a minimal invocation example ({"template":"morning_shortlist"}) and the idea that changes are deltas from the library version, adding little beyond the structured 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 the trigger condition clearly ("when the user wants Winquill to do something on its own, again and again") and the action ("Makes one from the library, saved off"), which is a specific verb+resource. It is distinguishable from turn_on_automation and list_automations, though the core verb "add" is only implied rather than stated.

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

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

Gives an explicit trigger scenario with several concrete examples of what users ask for, and names the sibling that follows: the automation "runs only once turned on with turn_on_automation." It also states a prerequisite ("Needs a Winquill account"), 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?

Going beyond the annotations, it discloses sign-in requirements, that fetching published files pulls up to a limited set of external documents, and that scored questions only appear when the workspace has AI enabled and consume usage. It does not explain the persistent side of the operation implied by destructiveHint=true (that readings are stored and later reused), leaving the mutation profile partly implicit.

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 a 'Use this when' trigger, followed by return content and an exclusion, ending with a compact example. The middle sentences are long and stack several conditions at once, but no sentence is filler.

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

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

With an output schema and annotations already carrying safety signals, the description covers triggers, return content and the AI-conditional path. The one material gap is the persistence/overwrite behavior implied by destructiveHint=true, which the agent would need to warn the user about.

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; the description adds real value by showing a worked example object and tying read_published to its behavioral consequence ('signed in'). It still does not clarify the relationship between providing text and read_published (mutually exclusive vs additive) 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?

States a specific verb and resource ('read the files the buyer published with the notice', 'text from a tender's documents') and names exactly what comes back: a checklist of bid requirements plus the notice's omissions. An agent can tell this apart from get_tender_details or assess_tender_fit because the output shape (per-item file, page, buyer's words) is spelled out.

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 triggering conditions ('when the user shares text from a tender's documents, or wants Winquill to read the files the buyer published') and an exclusion ('Not for documents unrelated to a tender'), plus a concrete example call. It never names an alternative sibling tool for the adjacent cases (e.g. tender fit or readiness), so routing between siblings is still inferred.

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

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

Beyond the annotations (idempotent, non-destructive, closed-world), the description discloses the initial pipeline state ('Watching'), that the response reports the e-tendering portal, and the follow-up loop when the portal account is unknown (ask, pass the question on, then record_portal_account). It also names the account/workspace prerequisite. It doesn't cover error cases such as an unknown reference, but the added behavioral 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?

It is front-loaded with the trigger condition and tightens toward exclusions at the end, with every sentence carrying routing or behavioral payload. It is dense and slightly run-on across the prerequisites and follow-up sentences, but there is no filler.

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

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

The tool has an output schema, so return values needn't be described; the description instead supplies the prerequisites, the resulting pipeline state, and the portal-account follow-up flow. For a one-required-parameter mutation, nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so all three parameters are already documented with examples of reference formats and the workspace-naming rule. The description adds nothing about parameter syntax or the multi-reference behavior, so the baseline 3 applies.

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

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

The description states a specific verb and resource: save a tender to the team's pipeline for consideration, landing it in the 'Watching' stage. It also distinguishes itself from the nearest siblings by name (watch_tenders for alerts, record_bid_call for decisions), so an agent can route 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?

It gives concrete trigger phrases ("add this to our pipeline", "let's track the Falkirk cleaning framework") plus two explicit exclusions that name the alternative tool for each case. The when/when-not split is unambiguous.

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?

Goes well beyond the annotations: it says the bid is stored in the workspace's Library, that it is used to learn structure/tone/evidence for future drafts, and that it requires an account and workspace. The 'pass text, not a link' constraint is a real behavioral rule. It stops short of saying what happens on duplicate submissions or whether the upload is processed asynchronously.

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

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

Front-loaded with the trigger condition, then effect, then constraint, then exclusions — good ordering. It is a dense sentence chain with several clauses, but no clause is 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?

An output schema exists so return values need not be explained, and the description covers trigger, storage effect, learning behavior, and prerequisites. Minor gap is what the agent should do if the account/workspace is missing, or how to handle content that fails the 200-char minimum.

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 adds genuine meaning by specifying the text must be the bid's own content as the user shared it rather than a URL. The title and workspace params are only covered by the schema, which is acceptable at full coverage.

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 — the user shares a won bid so Winquill can learn from it — and immediately contrasts with the drafting siblings (start_bid_draft / continue_bid_draft). An agent can distinguish this from every other add_* sibling 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?

Gives an explicit trigger (the user shares a winning bid, often after Winquill offers to learn from one), an explicit exclusion (not for buyer questions on a new bid), the named alternatives to use instead, and the prerequisite of a Winquill account and workspace.

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

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

Annotations already cover the safety profile (readOnly, non-destructive, closed-world), and the description adds real behavioural bounds: the comparison basis, the returned judgement categories, and the explicit disclaimer that it does not predict or guarantee an award. It stops short of stating anything about profile prerequisites or latency, so not a full 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?

Four short sentences, front-loaded with the trigger, then the mechanism, then the ranking mode, then the exclusions. Nothing is repeated from the schema and no sentence is 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 and annotations carry the return shape and safety profile, and the description covers what remains: when to select it, the two operating modes, what dimensions are judged, and the limits of the result. Nothing an agent needs to invoke it correctly is missing.

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

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

With 100% schema coverage the baseline is 3, but the description adds cross-parameter semantics the schema only hints at: omitting tender_reference switches the tool from single-tender assessment to ranking, and the 'more_references ... saves a call for each' framing comes from the schema. The profile-vs-company_summary relationship is left to the schema.

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

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

States a specific verb and resource ('assess... fit for a public contract'), enumerates exactly what is compared (turnover, insurance, experience, certifications, location, lot sizes) and what comes back (fit score with reasons, disqualifiers, gaps). This clearly separates it from search_tenders (find) and check_bid_readiness (prepare to bid).

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?

Opens with an explicit user-intent trigger ('when the user asks whether their business should bid... or which open tenders suit them best'), gives the mode switch ('omit tender_reference to rank open tenders'), and states two exclusions ('not for general business strategy or private-sector sales leads'). An agent can route on this without 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 non-read-only, idempotent, destructive, closed-world, so the safety floor is set; the description adds real context beyond that — the account/workspace prerequisite, the role-based permission model, and the fallback behaviour when a role is insufficient. What it leaves unstated is the destructiveHint implication: whether assigning over an existing owner replaces the prior assignee, and that a Slack notification is apparently dispatched (only hinted at via "whether they heard in Slack").

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

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

Front-loaded with the trigger scenario and closed with prerequisites and exclusions, so every sentence carries information. The one flaw is density: "The work is the bid call while a tender waits in Watching or Qualifying, or a sprint step, the next one unless named" is a run-on that takes a second pass to parse.

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 needn't be spelled out, and the description still summarizes the response (who has the work, Slack acknowledgement). Prerequisites, permissions, defaults, alternatives and an example are all covered; only the reassignment/overwrite behaviour implied by destructiveHint=true 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%, but the description still earns credit for explaining the default semantics of the omitted `task` param ("the next one unless named") and for tying the work types to tender state (bid call while a tender waits in Watching or Qualifying). The inline example JSON shows the interplay of tender_reference, person and task in a way the schema does not.

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

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

The opening sentence names a specific verb and resource — giving (or taking) a piece of bid work to a person — and anchors it in an explicit user utterance ("give the Bristol bid call to Sam"). It also names the two nearest siblings it is NOT (update_bid_sprint, record_bid_call), so an agent can discriminate it without opening a schema.

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

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

It states the trigger condition, the scope of "work" (bid call while in Watching/Qualifying, or a sprint step defaulting to the next one unless named), the escalation path when the person's role can't do the work ("the answer says who can: ask the user before choosing one"), and explicit exclusions routing to update_bid_sprint and record_bid_call.

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 destructiveHint=false, so safety is covered; the description still adds real context by disclosing the response shape (held/missing/expiring), the home-country fallback behavior, and the scope caveat 'readiness guidance, not legal advice'. It does not cover auth requirements or rate limits, so it stops short of a full 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?

The trigger condition is front-loaded before the return description, exclusions and example. The first sentence is long and carries a list of country-specific examples that overlaps the schema's own country description, so it is slightly heavier than needed but still efficient.

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 annotations covering the safety profile, the description only needs to supply the trigger, scope and routing caveats — all of which are present. Nothing an agent needs in order to select and invoke this tool correctly is missing.

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

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

Schema description coverage is 100%, so all four parameters (including the sector enum and the country fallback rule) are already documented and the description largely restates them. Its country examples and the illustrative JSON add light invocation value, but not enough to exceed the baseline 3.

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

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

Specific verb+resource (check bid readiness for one tender or in general) with a stated output ('Returns what is held, missing or expiring'). It explicitly carves out what it is not for (Companies House look-ups, tax questions), which separates it from siblings like find_company and avoids collisions with the bid-drafting tools.

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

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

Opens with an explicit trigger ('Use this when the user wants to know what they're missing before bidding'), covers both modes (single tender vs general check) and states that a general check falls back to the home country. It also gives clear when-not guidance ('Not for Companies House look-ups or tax questions'), 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 declare destructiveHint=true and idempotentHint=true, but the description adds the crucial no-op read behavior (with neither send nor stop it changes nothing and reports current routing) and the permission prerequisite that only owners and admins can change alerts. It does not spell out what a 'stop' actually removes or that stopped alerts are reversible, leaving some of the destructive profile unexplained.

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?

Everything is front-loaded: trigger first, then constraints, then exclusions, then an example. It is dense but each sentence carries routing, permission, or precondition information; the quoted user utterance is the only mild 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?

With an output schema present and 100% schema coverage, the description need not explain return values, and it covers what structured fields cannot: the permissions model, account/workspace prerequisite, the no-op semantics, and where to go for adjacent tasks. Nothing an agent needs in order to call it correctly is missing.

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

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

Schema coverage is 100%, so parameter meaning is already documented; the description still adds value by supplying a concrete call example ({"app":"slack","stop":["morning_summary"]}) that shows how app, stop, and channel combine, and by stating the change-only-what-was-asked constraint that governs send/stop usage.

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 (change) and resource (which Slack and Teams channels get Winquill's alerts) and explicitly distinguishes itself from connecting a channel and from email alerts via watch_tenders. An agent can tell it apart from siblings like watch_tenders or turn_on_automation 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?

It gives an explicit trigger (the user wants to change alert destinations or asks where they go), quotes a real utterance, and names two alternatives with routing instructions: the Winquill dashboard for connecting channels and watch_tenders for email alerts. It also states the no-op case when neither send nor stop is supplied.

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

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

Beyond the annotations, the definition says drafting starts only once the questions are answered or draft_now is true, that Winquill marks unanswered gaps as [TO CONFIRM], and that a Winquill account is required. It does not say what happens to answers already sent or whether resuming rewrites existing draft content, which is the notable gap for a destructiveHint=true tool.

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

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

The definition front-loads the purpose and the trigger, and every sentence is on-topic. Slightly repetitive: 'the go-ahead to draft now' and 'Drafting starts ... when draft_now is true' state the same rule twice, and the start_bid_draft exclusion appears at the end after being implied at the start.

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

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

With seven params, an output schema, and full annotations, the definition supplies the trigger logic, the account requirement, the gap-marking behavior, and the sibling boundary. What it leaves out is the state effect of resuming (what is overwritten or locked), the one area not covered by the structured fields.

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 draft_id, tender_reference, workspace, and the answers shape. The definition's 'Pass each answer with the question's number or words' repeats what the schema states. It adds mildly by linking answers, questions_text, and draft_now to the drafting trigger, but doesn't explain how they interact (e.g., answers plus draft_now).

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 definition opens by naming the exact step it covers -- resuming a bid draft created by start_bid_draft -- and tells the agent what to pass (buyer questions, team answers, or a go-ahead). It explicitly distinguishes itself from start_bid_draft, so no schema comparison is needed.

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 covers all three call cases, including the partial-information case, and names the exclusion directly: 'Do not use for a new bid (use start_bid_draft).' The agent knows when to call this vs the sibling.

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, destructiveHint=false and a closed-world scope, so the safety profile is covered. The description adds genuinely non-obvious behavioral context beyond that: this tool does not emit the finished draft, it returns a drafting brief derived from award criteria, word limits and user facts, which is essential to using the result correctly.

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

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

Front-loaded with the trigger scenario, then the return value, then the follow-on instruction, then the exclusions. Every sentence carries distinct information and there is no filler.

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

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

An output schema exists and annotations cover safety, so the description needn't explain the return shape, yet it still summarizes the brief's basis (award criteria, word limits, facts), which is helpful. Coverage of the multi-step draft workflow relative to its sibling tools is the only gap.

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

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

Schema description coverage is 100% with descriptions and an enum for section, so the schema already carries the parameter burden. The description alludes to word limits and the user's facts (word_limit, notes) and lists the section values, adding only marginal meaning beyond the schema — baseline 3 is appropriate.

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

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

States a specific verb and resource — drafting part of a response to a public tender — and enumerates the concrete artifact types (quality answer, social value, method statement, case study, etc.). It clearly separates itself from non-bid tools, but does not distinguish itself from close siblings such as start_bid_draft, continue_bid_draft, or rewrite_bid_answer, which could leave the agent uncertain which of the draft-family tools to pick.

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 'use this when' trigger plus concrete 'do not use for' exclusions (job applications, grant applications, private-sector sales proposals), and hints at the follow-on action ('Write the draft from the brief'). Missing only an explicit routing statement to sibling tools for the alternative steps of the draft workflow.

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, openWorldHint=true and destructiveHint=false, so safety is covered and the bar is lower. The description usefully adds the external data source (Companies House) and geographic scope, but says nothing about what happens with zero or multiple matches, or about external-register rate limits, which matters for an openWorld 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 front-loaded sentence with no filler. It is efficient, though the brevity comes at the cost of the missing behaviors noted elsewhere rather than from ruthless prioritization.

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

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

For a one-parameter read tool with no output schema and full annotation coverage, the essentials are nearly there. The critical gap is return shape: 'Finds a company' does not reveal whether the agent gets one company or a list of candidates to disambiguate, which directly affects how it should call and follow up.

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% for the single required parameter, so the description must carry the meaning. 'By name' merely restates the schema property name 'name'; it does not say whether partial or fuzzy names are accepted, whether it must be an exact registered name, or how the 160-character limit relates to real inputs.

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: 'Finds a UK company on Companies House by name.' The scope (UK register, name-keyed lookup) distinguishes it clearly from siblings like save_company_profile or search_contract_awards, 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?

'for Winquill's setup' implies this belongs to the onboarding flow, so an agent can infer when it is relevant. However, it never says what to do when the lookup fails or is ambiguous, nor points to the natural follow-on tool (save_company_profile) that consumes the result.

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

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

The annotations already declare this is a destructive, non-read-only, open-world operation. The description adds that it creates a workspace and finds tenders, but it does not warn that the action is irreversible or describe what existing data might be overwritten or how matching tenders are selected. With annotations covering the safety profile, a 3 is fair but the destructive side effects remain undocumented.

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

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

The description is a single efficient sentence that front-loads the main action. The phrasing 'what Winquill's setup was told' is awkward and slightly obscures the three distinct effects, but there is 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?

This is a complex mutation tool with 7 parameters, no output schema, and a destructive annotation. The description omits parameter guidance, side-effect details, and return behavior, leaving significant gaps for an agent trying to invoke 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?

The schema has 7 parameters with 0% description coverage, and the description does not explain any of them. It says 'saves what Winquill's setup was told' but never clarifies what `name`, `regions`, `work`, `size`, `market`, `workspace`, or `company_number` mean or how they are used.

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 multi-step effect: saving setup data, creating a workspace, and finding matching tenders. However, it does not clearly distinguish this tool from the sibling `set_up_tenda`, and the phrase 'Winquill's setup was told' is vague about what exactly is being finalized.

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 this is for someone without an existing workspace ('making the workspace for someone without one'), which is a partial usage condition. But it provides no explicit guidance on when to call this versus `set_up_tenda` or other setup-related siblings, nor any exclusions or prerequisites.

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/non-destructive/closed-world, so safety is covered. The description adds real behavioral facts the annotations don't: the result is capped at the last 10 actions, ordered newest first, and requires a Winquill account plus workspace. It's silent on pagination or how to see older activity.

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 tightly packed sentence with the usage trigger front-loaded, followed by the result shape and the prerequisite. No filler, nothing repeated.

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 the description covers scope, ordering, cap, and auth requirements. The only meaningful gap is whether there is any way to retrieve activity beyond the last 10 items.

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 both parameters are already documented, including the 'leave out for all of them' behavior. The description's 'for one automation or all of them' restates what the schema says rather than adding format or edge-case guidance (e.g., ambiguity when a name matches multiple automations). 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?

Names a specific verb and resource ('what Winquill's automations did lately') and pins the shape of the answer (last 10 actions, newest first, scoped to one automation or all). It's clearly a history/activity tool rather than a configuration tool, but it never distinguishes itself by name from siblings like list_automations or get_automation_library.

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

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

'Use this when the user asks what Winquill's automations did lately' gives a concrete triggering intent, which is more than most tools in this family offer. It stops short of naming alternatives or stating when not to use it (e.g., to see what automations exist, use list_automations).

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds real context beyond them: what each result contains (what it does, whether the workspace has it) and the auth prerequisite (Winquill account and workspace). No pagination or response-size notes, 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?

Three tight sentences with no filler: trigger first, relationship to add_automation second, return shape third, prerequisite last. Every sentence carries 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?

An output schema exists so return values needn't be spelled out, yet the description still summarizes them. Prerequisites are stated, and the tool is a simple one-param read. Nothing an agent needs to invoke it correctly is missing.

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

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

Single optional parameter with 100% schema description coverage; the schema already explains that 'workspace' is the name to pass when the user has multiple. The description does not add meaning beyond that, which is acceptable at this coverage level.

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 ('Show the automations library' / 'which automations Winquill can run') and names the sibling it precedes, add_automation. It does not distinguish itself from other close siblings like list_automations or get_automation_history, which keeps it from a 5.

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

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

Gives an explicit trigger ('when the user wants to know which automations Winquill can run') and a clear relative ordering ('before making one with add_automation'). No exclusion against list_automations/get_automation_history, so the agent must guess among the three automation-listing tools.

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

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

Beyond readOnlyHint/openWorldHint, the description discloses that a Winquill account is required, that the Word file link is time-limited to one hour, and that a second link points into Winquill — all operationally relevant facts absent from the annotations. Scope of returned content is also spelled out, though it does not mention whether partial drafts are readable.

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

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

Front-loaded with the trigger, then the payload, then the auth and link constraints, and it ends with a concrete example. One sentence is garbled ('Give question to read that answer in full'), which slightly blunts an otherwise dense, purposeful passage.

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 the description needn't detail return values, and it still summarizes them well. It covers auth, link lifetime, and defaulting behavior context via example; only the relationship to sibling drafting/review tools is left implicit.

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

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

Schema description coverage is 100%, so draft_id, question, workspace and tender_reference are already fully documented. The description only echoes the question-reading behavior and repeats an example tender_reference, adding no new semantics such as precedence between draft_id and tender_reference (that lives 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?

The description names a specific verb+resource ('check on / read a bid draft Winquill is drafting') and enumerates what it returns: step progress, answers with word counts and marks, outstanding team confirmations, and the whole-bid check. It stops short of distinguishing itself from sibling tools like review_bid_draft or continue_bid_draft, which an agent could easily confuse with this read.

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 is given ('when the user asks how a bid is going, or wants to read it'), and the 'once it's ready' condition gates the download link. No exclusion is stated against the nearby review/continue drafting tools, so the agent must infer which one applies.

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

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

Annotations already establish readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful behavioral context about what coverage data includes (countries, sources, open/upcoming/awarded counts, last read timestamps) and how that data should be interpreted for freshness claims.

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

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

The purpose, usage condition, exclusion, and example are front-loaded with no wasted prose. Each sentence contributes to correct tool selection or invocation.

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-value details need not be repeated in the description. With read-only annotations, full parameter schema coverage, and clear sibling routing, the description gives everything an agent needs to select and call this 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 description coverage is 100%, and the country parameter is already documented thoroughly, including the full source list and omission behavior. The description adds only a concrete example, which is helpful but largely redundant with the schema.

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

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

The description states a specific verb and resource: showing where Winquill looks, including countries, sources, notice counts, and last-read times. It explicitly distinguishes this coverage-inspection tool from searching by naming search_tenders as the alternative.

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

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

It gives explicit when-to-use guidance: before saying a tender is not published anywhere Winquill reads, or when reporting freshness. It also gives an explicit when-not-to-use: 'Not for searching (use search_tenders).'

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds real behavioral context beyond that: it requires a Winquill account and workspace, and it scopes the report to the team's own pipeline. It doesn't discuss freshness or empty-state behavior, keeping it just shy of a 5.

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

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

Front-loaded with the use condition and content list, then closes with clear exclusions and alternatives. It is a fairly long multi-clause sentence, but nearly every clause carries distinct information; minor trimming of the return-content enumeration would tighten it.

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

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

An output schema exists, so return values needn't be explained, and the description nonetheless indicates the report's shape. With the only parameter documented at 100% coverage and annotations covering safety, an agent has everything needed to select and 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 description coverage is 100% and the single workspace parameter is fully documented in the schema. The description confirms a Winquill workspace is needed but adds no syntax or selection 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 (pipeline status) and enumerates what it reports: stage counts, running bids with next step and due date, tenders awaiting bid/no-bid call, and bids waiting on a result. This clearly distinguishes it from search_tenders and get_tender_updates named in the same breath.

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 triggers ('when the user asks how their team's bids are going, for a status report, or what is due') and explicit exclusions with the correct alternatives: 'Do not use to find new tenders (use search_tenders) or for alerts from saved watches (use get_tender_updates).'

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, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds context the annotations cannot: a Winquill account is required, and the returned settings are account/workspace-scoped. It stops short of noting whether settings can be absent for non-configured accounts.

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 block that front-loads the trigger condition, then states what is returned, the prerequisite, and the exclusion. Every clause carries distinct information with no restatement of the name or 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 no parameters, full annotation coverage, and an output schema that documents the return shape, this description supplies exactly the missing layer: when to call it, what account is needed, and what it is not for. Nothing an agent needs in order to invoke it correctly is absent.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly does not waste words on inputs.

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 and its constituents: Winquill settings in ChatGPT, the active workspace, and that workspace's countries. It clearly separates itself from save_company_profile, but says nothing about the obviously related sibling update_tenda_settings, leaving the read-vs-write distinction to the tool name alone.

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 triggering condition ('when the user asks which Winquill workspace ChatGPT uses, or which countries' tenders it shows') and an explicit exclusion routing to save_company_profile. The missing piece is guidance against update_tenda_settings, the closest alternative for settings-related requests.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description doesn't need to argue safety; instead it spends its words on what the agent actually receives, including the less obvious competitive-intelligence payload (current holder, prior price paid, bid count). It doesn't discuss missing/not-found references or multi-reference partial failures, which is the only real 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?

Front-loaded with the trigger condition, then the payoff list, then the exclusion, then the example — a sound order. The single long opening sentence carries a lot of enumerations and the phrase "whether the tender is worth chasing" is a touch editorial, but no sentence is 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?

An output schema exists, so return formatting is rightly omitted, and the description covers the trigger, the reference formats and the sibling boundary. The one omission is the batch path via more_references, which matters for the compare-a-shortlist use case the schema explicitly advertises.

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

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

Schema coverage is 100% and the schema already documents both parameters with identical example references, so the description's inline example adds little beyond it. The second parameter (more_references, up to 19 for batch comparison) is never mentioned in the description, leaving batching discoverable only through the schema. Baseline 3 is appropriate.

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

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

States a specific verb (explain/read one tender) and enumerates exactly what comes back: deadline, portal, lots, value, conditions, award criteria, plus incumbent/price/bid-count intelligence. It also names the boundary against search_tenders, so an agent can pick it without opening the sibling 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 explicit triggers (user asks about one tender, framework or standing offer; by notice ID, buyer reference, or from earlier results) and an explicit exclusion with the alternative: "Not for finding tenders (use search_tenders)." Nothing is left to inference.

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

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

Discloses side effects that annotations alone don't convey: without since it marks updates seen, with since it 'marks nothing' and reads oldest first — which explains the readOnlyHint=false / idempotentHint=false pairing rather than contradicting it. Adds the account requirement ('Needs a Winquill account') and the ordering guarantee.

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

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

Front-loads the trigger condition and packs the since/watch_id branches into compact sentences with an example at the end. Slightly dense and run-on, but no sentence is 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 needn't be described, yet the description still explains how to consume nextSince on the next call. Auth requirement, ordering, side effects and the sibling exclusion are all covered for a 2-optional-param read 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 100%, so baseline is 3, but the description adds the chaining protocol (pass the nextSince from the previous answer) and a concrete example value, which is meaningfully more than the schema's per-field docs. watch_id's link to watch_tenders is echoed rather than extended, so not 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 ('what's new from their Winquill watches') and enumerates the update categories (new tenders, pipeline notices, deadline changes, clarifications, cancellations, awards). It explicitly distinguishes itself from search_tenders, so an agent can separate it from the search-oriented siblings 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?

Gives the triggering user question, the with/without-since branches (default marks seen; scheduled agents pass nextSince from the prior answer), the watch_id narrowing case, and an explicit exclusion ('Not for searching (use search_tenders)'). Alternatives and conditions are named rather than inferred.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is clear. The description adds valuable context beyond annotations: it requires a Winquill account and workspace, and it describes the nature of the returned data (rules as sentences, on/off state, last activity, suggested automations).

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

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

The description is three sentences: usage trigger first, then prerequisites, then exclusions. Each sentence earns its place with no filler, and the most important selection guidance is front-loaded.

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

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

Given the tool's read-only nature, full parameter schema coverage, annotations, and an output schema, the description covers all an agent needs: when to use it, what it returns at a high level, prerequisites, and what it is not for with explicit alternatives.

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% for the single workspace parameter, so the schema already documents its meaning and usage. The description mentions workspace scoping but adds no syntax or format details beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb (list) and resource (automations), and enumerates what is returned: rules as sentences, on/off state, last activity, and suggested automations. It also distinguishes from siblings explicitly by naming add_automation and get_automation_history.

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 provides an explicit when-to-use trigger (user asks what Winquill does on its own for their team) and explicit when-not-to-use conditions with named alternatives (not for making one, not for history). Alternatives are routed without ambiguity.

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

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

Annotations already declare read-only, idempotent, closed-world and non-destructive, so the safety profile is covered. The description adds the real prerequisite an agent cannot get from annotations — a Winquill account is required. It does not mention scoping or pagination, but for an account-scoped list that is a minor omission.

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

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

Front-loaded with the trigger condition, then return contents, prerequisite, and the exclusion — in that order of use. Three tight sentences with no filler; even the empty-args example earns its place by confirming the call shape.

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 structure needn't be explained, and annotations carry the safety profile. Purpose, triggering conditions, the alternative tool, and the account prerequisite are all present for a zero-parameter read 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?

Zero parameters, so the baseline is 4; the description confirms this with 'Example: {}', signalling the tool takes no arguments. Nothing further is needed or possible here.

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 ('which Winquill watches they have') and enumerates the fields returned (ID, target, countries, Slack/Teams delivery). It explicitly separates itself from get_tender_updates, so an agent can pick it out of a 40-tool sibling list.

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 both a positive trigger ('when the user asks which watches they have') and a secondary one ('to find the one to stop'), plus an explicit negative case pointing at get_tender_updates. This is the when/when-not/alternative pattern at full strength.

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 that this mutates state, is destructive, and is idempotent. The description adds the account/workspace prerequisite and stage-routing constraints, but it does not explain what the destructive effect is, such as whether the current stage is overwritten or whether the move can be reversed.

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

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

The description is front-loaded with the primary use case, then adds the stage-specific exceptions, prerequisites, and exclusion. It is dense but every sentence contributes routing or constraint 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 three-parameter mutation tool with an output schema and annotations, the description covers the main usage, alternatives, prerequisites, and exclusion. The remaining gap is that it does not explain the practical consequence of the destructive stage change, though annotations signal that behavior.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds lifecycle meaning for stage values, including when qualifying, watching, submitted, won, and lost apply, and routes bidding/no_bid to record_bid_call; tender_reference and workspace are already well documented 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?

The description states a specific verb and resource: changing where a tender stands in the Winquill pipeline. It clearly distinguishes this tool from record_bid_call for bidding/no-bid calls and remove_from_pipeline for removal.

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 explicit when-to-use guidance by mapping stages to user situations, names the alternative tool for Bidding/No bid, and explicitly says not to use this for taking a tender off the pipeline. These are concrete selection rules, not implied usage.

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, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds useful content about what the panel surfaces (steps, questions, scores, in-chat work) and is consistent with a read-only 'open' action, but says nothing about side effects or state.

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 is a single front-loaded sentence with no filler, which is good. But the trailing clauses ('each bid's steps and questions, what scores') are loosely phrased and slightly rambling for the amount of real information conveyed.

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 and 0% parameter coverage, the description should carry more weight. It describes what the panel shows but leaves both parameters undefined and gives no guidance on invocation, so an agent cannot fully 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?

Both parameters (path, workspace) have 0% schema description coverage and the description never mentions either one, so the agent gets no meaning, format, or example for them. The description fails to compensate for the coverage 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?

The verb 'opens' plus the resource 'bid panel' conveys a display action, and 'the team's live bids beside a chat' differentiates it from get_bid_draft or review_bid_draft. However phrases like 'what scores' and 'a way to work on one in the chat' are vague about what the tool actually does in an agent context.

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 gestures at a chat-adjacent context but gives no explicit when-to-use, when-not, or alternatives (e.g., open_tenda, get_bid_draft). The agent has to infer when opening the panel is preferable.

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, destructiveHint=false and closed-world, so safety is covered. The only added behavioral claim is "The app moves between its pages itself", which hints that no follow-up navigation calls are needed, but it is ambiguous and does not say what happens if the app is already open or what the caller receives.

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?

Only two sentences and the action is front-loaded, so it is compact. But the second sentence is vague and the enumeration in the first reads as an unstructured list, limiting how much the brevity buys.

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 two fully undocumented parameters, no output schema, and only annotations for safety, the description should explain what 'path' and 'workspace' select and what opening the app returns or does. Neither is covered, leaving the tool under-specified for correct invocation.

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% for both 'path' and 'workspace'. The description lists page-like destinations that may correspond to 'path' values but gives no format, examples, or defaults, and never mentions 'workspace' at all, so the agent has no way to know what to pass.

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 verb ("Opens") and the resource ("Winquill's own app from ChatGPT's sidebar") are stated, and the enumerations (Today, team board, Find, tenders, bid call) sketch the destinations. However, the naming is inconsistent — the tool is 'open_tenda' but the title/description say 'Winquill' — and there is no differentiation from the sibling 'open_bid_panel', which sounds like it opens a similar surface.

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 statement of when to call this versus the many data-retrieval siblings (get_tender_details, get_pipeline_status, search_tenders, open_bid_panel). The agent must infer that this is for showing the UI rather than fetching data.

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 declare a non-idempotent, destructive mutation, and the description adds real context beyond that: the tender moves to Bidding, a six-step sprint is planned back from the deadline, an off-pipeline tender is added first, and the caller needs a Winquill account with a role that permits bid calls. These are exactly the side effects and auth prerequisites an agent must know before invoking.

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

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

Front-loaded with the trigger condition, then side effects, then the exclusion, then the example — a sensible order with no filler sentences. It runs slightly long, since the six-step sprint detail and the example could be trimmed, but each sentence carries actionable 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 non-idempotent mutation with a nested answers object, the description covers trigger, exclusions, prerequisites, side effects and an example, while annotations carry the safety profile and an output schema handles return values. Nothing an agent needs in order to call this correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds value by including a concrete example payload showing how tender_reference, decision and the nested answers object fit together. It does not, however, add anything beyond the schema for the optional reason or workspace 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 — records the bid or no-bid call plus the team's answers and reason — and names the sibling it is not (assess_tender_fit). An agent can distinguish it from adjacent pipeline tools like add_to_pipeline or check_bid_readiness 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?

Explicit trigger conditions ('when the user's team has decided whether to bid'), an explicit exclusion ('Not for judging fit before the call, use assess_tender_fit'), and a procedural precondition ('Confirm the decision with the user before calling'). Nothing is left to inference.

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

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

The description adds meaningful behavioral context beyond annotations: records are visible to the whole team, Winquill stops asking about that portal, and a Winquill account/workspace is required. It does not explain the destructive/overwrite implication that annotations flag with destructiveHint=true, so it falls short of full behavioral transparency.

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

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

The description is front-loaded with the primary usage condition and stays focused. It is somewhat long and could be tightened, but the extra examples and exclusion earn their place.

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

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

Given an output schema and rich annotations, the description covers when to use the tool, the team-wide effect, account prerequisites, and the sign-in exclusion. It leaves the destructive/overwrite behavior to the annotations, which is a minor gap but not a blocker.

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 baseline is 3. The description reinforces that the portal can be identified by tender reference, portal name, or Winquill portal key, but most of that information is already present 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?

The description names a specific action and resource: noting whether the company has an account on a named e-tendering portal. It is clearly distinguishable from related tools such as sign-in or portal access, and the examples make the scope concrete.

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 explicit trigger conditions, including the user's exact-style statements such as "yes, we have an EU-Supply account" and the context of Winquill having asked after a tender joined the pipeline. It also gives an explicit exclusion: do not use this to sign in to a portal, because Winquill never handles portal passwords.

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, but the description goes further by enumerating exactly what is destroyed — the bid call, the sprint, and the files the team added. It also discloses a non-obvious conditional gate (tenders in Bidding/Submitted/Won/Lost require a second confirmed call) and the account/workspace prerequisite.

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

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

Front-loaded with the usage trigger, then behavior, prerequisites, alternatives, and an example example — a sensible ordering with little waste. It is dense in the middle (the 'for good or until a change brings it back' clause is slightly convoluted), keeping it just short of ideal.

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

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

With an output schema present, the description needn't explain return values, and it covers everything else an agent needs: destructive scope, the confirmation round-trip, workspace/auth requirements, and sibling routing. Nothing required to invoke it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: it explains the conditional semantics of 'confirmed' through the confirmation example and paraphrases return_when as 'remove it until it gets a value', tying the enum to user intent. The inline example invocation shows how tender_reference and return_when combine.

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 ('taken off their team's Winquill pipeline') and immediately clarifies the two modes: permanent removal or conditional return. It explicitly names the siblings it is not (move_in_pipeline, record_bid_call), so an agent can separate it from adjacent pipeline operations 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?

Opens with an explicit trigger ('Use this when the user wants a tender taken off...'), quotes the natural user phrasing ('remove it until it gets a value'), and names two alternatives with the condition that selects them. The confirmation path is spelled out as an instruction ('confirm with the user and call again with confirmed').

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

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

Annotations already establish readOnly, non-destructive, and closed-world behavior. The description adds substantial value beyond that by explaining what the review checks (word limit, question coverage, evidence, commitments, placeholders, section-specific needs) and what is returned (checks, scoring criteria, and a 0-5 rubric).

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

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

The description is front-loaded with the use condition, then the checks, then the return value, then the exclusion. It is dense but every clause contributes to correct selection and invocation.

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 review tool with an output schema and full parameter descriptions, the description is complete enough to call correctly. It covers purpose, routing, checks, and return shape without needing to duplicate schema details.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning by tying parameters to concrete review behavior: word_limit drives a specific check, question enables part-by-part coverage checking, and section determines what requirements are applied. This goes beyond the schema's field-level descriptions.

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: reviewing a draft tender answer before submission, evaluated like an evaluator would. It clearly distinguishes itself from draft_bid_response, so an agent can select it 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?

It gives an explicit when-to-use condition (user has a draft answer for a public tender and wants it checked before submission) and an explicit when-not-to-use with a named alternative (do not use to write a new answer; use draft_bid_response). This is exactly the routing guidance an agent needs.

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

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

Adds real context beyond the annotations: the rewrite happens asynchronously in the background, the answer is re-marked, and the user is told when it's done. It also discloses the commercial model (first ten rewrites included, then draws on the workspace allowance) and the account requirement. It does not say whether the pre-rewrite answer is recoverable, which matters given destructiveHint=true.

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

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

Front-loaded with the trigger condition and a concrete example, then the async behaviour, then cost and prerequisites, closing with the guard rail. Every sentence carries distinct information with no repetition of 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?

An output schema exists so return values need not be described, and the description still covers the async completion signal, the billing implication and the readiness precondition. For a five-parameter mutation tool this is as complete as an agent needs.

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

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

Schema description coverage is 100%, so draft_id, question, workspace, instruction and tender_reference are all already documented, including the fallback behaviour when draft_id is omitted. The description's examples loosely illustrate what belongs in question and instruction but add no new semantics; baseline 3 is appropriate.

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

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

States a specific verb and a tightly scoped resource: rewrite one answer in a bid Winquill drafted. The quoted example utterances ("make Q3 shorter", "use the Glasgow contract as the example in 2.1") make it unmistakable versus siblings like draft_bid_response, continue_bid_draft and review_bid_draft.

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 trigger utterances and an explicit exclusion ("Do not use before the draft is ready"), plus the prerequisite of a Winquill account. It stops short of naming the sibling to use instead when the draft isn't ready or when the user wants a full redraft rather than a single-answer rewrite.

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 mutation (readOnlyHint=false), destructiveHint=true, idempotentHint=true, openWorld=true; the description adds content the annotations cannot: data is written to the user's team workspace, enrichment from Companies House / SAM.gov and won contracts, and an account prerequisite. It does not spell out that existing summary/codes are replaced rather than appended in some cases (the schema does, and it implies confirm-before-write mitigates loss), so it stops short of full transparency on overwrite semantics.

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

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

Front-loaded with the trigger and purpose, then constraints, then exclusions, then an example — a sensible order with no filler. It is a single dense paragraph of ~6 clauses, slightly heavier than needed, but every sentence carries either a rule or a behavioral fact.

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 19-parameter mutation with 100% schema coverage and an output schema, the description supplies exactly what structured fields cannot: the trigger, the confirmation workflow, the account prerequisite, the enrichment behavior, and the scope exclusion. Nothing needed 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 description coverage is 100%, so the baseline is 3; the description adds a cross-cutting population policy ('only company facts the user has told you... leaving out anything unsure and any personal details') plus a worked example object showing which keys a typical call contains. It does not explain individual fields (e.g. the home-currency convention on *_gbp), but the schema already does.

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 company profile') and immediately explains the downstream purpose: 'so Winquill can remember their business for searches, fit and readiness checks and drafting'. It also names what it is not ('Not for personal profiles or CVs') and names the enrichment sources, so an agent can distinguish it from find_company or check_bid_readiness.

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

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

Gives an explicit trigger ('when the user wants Winquill to remember their business'), a data-collection rule ('fill in only company facts the user has told you, leaving out anything unsure and any personal details'), a confirmation step, and a hard exclusion ('Not for personal profiles or CVs'). Requirements are stated ('Needs a Winquill account'), which is the 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 this is a safe, non-destructive read with closed-world scope, so the description focuses on operational traits: the pagination contract (pass nextCursor back as cursor), that summarise spans every match rather than the current page, and the default country fallback for unauthenticated users. It stops short of stating result caps or how filters combine, so a 4 rather than 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 sentences: purpose and coverage first, default scoping second, pagination/summary semantics third, then the single most valuable exclusion. The trailing example encodes a realistic call. No sentence is filler despite the density.

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 12-param tool with a full schema and an output schema, the description covers the decisions the schema cannot: scope defaults, cross-page summarisation, and the sibling boundary. It omits how filters interact (e.g. query plus codes) and paging behaviour under summarise, leaving mild 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 coverage is 100%, so the bar is baseline 3. The description adds value on the two easiest-to-misuse controls: it names the output field (nextCursor) the cursor parameter expects and clarifies that summarise aggregates across all matches, not just the returned page. It also shows a concrete parameter combination in the example.

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 contract awards), the geographic coverage, and the three questions it answers: past winners, last price paid, and contracts ending soon. It explicitly separates itself from search_tenders ('Not for tenders open now').

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 when-to-use framing plus two named exclusions with the alternative tool (search_tenders for open tenders, and it is not for a body's total spending). Also explains the default scope ('Searches the user's own countries unless they name one'), removing the main ambiguity an agent would face with 12 optional filters.

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, openWorldHint=false, destructiveHint=false, so the safety profile is covered. The description adds scope context ('the team's' resources, mentions use case), but says nothing about result limits, ranking, or behavior on no match. Modest added value over the structured fields.

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

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

One tight sentence that front-loads the verb and resource with zero wasted words. Nothing to trim.

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 the single required parameter plus read-only annotations mean little else is needed. The definition is nearly complete, missing only edge-case behavior (empty results, ranking) that would push it to a 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?

Schema description coverage is 0%, so the bare 'query' parameter is undocumented in the schema. The description's 'by name' gives a hint about acceptable input, but does not clarify the maxLength=200 constraint or matching behavior, so it only partially compensates for the coverage 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 ('Finds') and resources ('the team's tenders and people by name'), which is clear and distinct from search_tenders (tenders only). It does not explicitly name a sibling to contrast against, so it stops short of a 5.

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

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

'for @ mentions in ChatGPT' implies the usage context (mention autocomplete), giving the agent a reasonable sense of when to reach for it. However, it never states when NOT to use it or how it differs from search_tenders or find_company, leaving the routing decision to inference.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds real behavioural context beyond that: default country resolution (falls back to the UK when not signed in), a default limit of 8, total count plus nextCursor for paging, and the fact that meaning-based matches are marked match "meaning". It stops short of describing result ordering nuances already handled by the sort enum.

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 scope, then defaults, then pagination, then exclusions to siblings, ending with a compact example. Every sentence carries distinct information; nothing is repeated from the schema.

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

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

An output schema exists, so return values need no explanation, yet the description still flags the total and nextCursor which matter for chaining calls. For an 18-parameter, all-optional search tool, the coverage of scope, defaults, exclusions and pagination is 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 carries the parameter burden and the baseline would be 3. The description goes further by showing a concrete call with query, region and closing_within_days, and by connecting cursor to the nextCursor field in answers, which clarifies the pagination contract in a way the schema alone does not.

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 (find public sector contracts to bid for) plus the exact geographic scope (UK, Canada, US, Germany, France, rest of EU) and the notice types covered (open tenders, frameworks, upcoming notices). It explicitly names the sibling it is not (search_contract_awards) and rules out jobs, so an agent can distinguish it without opening either schema.

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

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

Gives explicit when-to-use and when-not-to-use: past winners go to search_contract_awards, source coverage goes to get_coverage. It also states the default behaviour (searches the user's own countries unless one is named) and how to paginate, leaving nothing to inference.

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

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

Annotations already cover safety (readOnlyHint=true, destructiveHint=false, openWorldHint=false), and the description adds real behavior beyond them: it renders an in-chat form, captures company/location/work, then reports how many open tenders match now, and requires an existing Winquill account. It stops short of saying what state the setup leaves behind or how the flow continues to the sibling finish_setup.

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

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

The trigger, the behavior, the account prerequisite, and the exclusion are all packed into two sentences with no filler, and the trigger is front-loaded. It is dense to the point of being a run-on, which slightly costs scanability.

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-required-parameter, single-param setup entry point with no output schema, the description conveys what the agent and user will see (a form, then a tender count) and the account prerequisite. It leaves the follow-on relationship with finish_setup implicit rather than telling the agent what happens after the form is submitted.

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 single optional `workspace` parameter is fully documented in the schema, including the multi-workspace condition and a naming example, so the schema does the heavy lifting and the baseline of 3 applies. The description never mentions the parameter, adding nothing on top of that.

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 ("set Winquill up for their company") and adds the trigger condition ("just added Winquill and has no workspace yet"). It explicitly distinguishes itself from the closest sibling, save_company_profile, so an agent can tell the two apart without opening either schema.

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

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

Gives an explicit when-to-use clause (new company / no workspace yet) and an explicit when-not-to clause ("Do not use to change one fact the user names, such as a certification") with the named alternative save_company_profile. Both halves of the routing decision are 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?

Goes well beyond the annotations by disclosing that the result is a public, unauthenticated URL, that chat apps generate a preview with name/value/closing date, and that no user or workspace data leaks into the link or page. That privacy/security note is exactly the kind of context an agent needs before generating an externally shareable artifact.

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

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

Four short sentences, front-loaded with the trigger condition, followed by what the link is, how recipients see it, and one usage instruction ('Give the link as it is'). 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?

Despite being a single-parameter tool with an output schema, the description still explains what the returned link contains and who can access it, which is the only thing that could go wrong here. Nothing an agent needs to invoke or relay the result is missing.

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

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

Schema description coverage is 100% and the tender_reference parameter is richly documented with format examples across Find a Tender, CanadaBuys and SAM.gov. The description adds nothing about the parameter, so the baseline 3 applies.

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

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

States a specific verb (share) and resource (tender) and immediately clarifies the actual output: a public link anyone can open without signing in. No sibling tool offers sharing, and the distinction from viewing tools like get_tender_details is implicit in the 'send someone its link' framing.

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

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

'Use this when the user wants to share a tender or send someone its link' gives a clear triggering condition. It does not name an alternative or exclusion, but no sibling competes for this intent, so the guidance is practically sufficient.

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

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

Beyond annotations (destructive/openWorld/non-idempotent), the description discloses the consumption of one monthly full bid, the account and workspace requirement, the two-step confirmation flow, the question-relay behavior, and how notification delivery is chosen. This is precisely the behavioral context annotations cannot convey.

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

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

Front-loaded with the trigger, then quota, alternatives, and notification in a tight sequence. Every clause carries information an agent needs at call time; nothing is redundant with the schema.

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

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

With an output schema and rich annotations already covering safety and return shape, the description fills the remaining gaps: prerequisites, quota cost, confirmation protocol, and question-relay obligation. An agent has everything needed to call it correctly and safely.

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 adds real meaning for 'confirmed' (must be omitted on the first call and supplied only after the quota trade-off is presented), explains how 'notify' signals readiness, and gives a concrete tender_reference example. The gain over the schema is modest but genuine.

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 ('Winquill to write a whole bid for their team') and outlines the full process (asks questions, drafts from evidence, marks and revises). It is clearly separable from siblings like draft_bid_response and continue_bid_draft, which it names or implies.

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 ('when the user wants Winquill to write a whole bid'), explicit alternative ('offer to write it here with draft_bid_response, which uses none'), and an explicit call sequence: invoke without 'confirmed' first, then again with it only if the user picks Winquill.

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, but the description adds real context: what stops is only future discovery, while already-found results remain visible in get_tender_updates. It also discloses the Winquill account requirement. It does not explain reversibility (restarting via watch_tenders), which keeps it below 5.

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

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

Front-loaded with the usage trigger and packs effect, prerequisites, and an example into a few clauses without waste. The semicolon-chained sentence is dense but readable; nothing extraneous.

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?

Covers trigger, id provenance, post-stop behavior, and account prerequisite, and an output schema exists so return values need not be described. An agent has everything needed to invoke 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 schema already documents watch_id's provenance, so the description mostly repeats it. The example {"watch_id":"wch_abc123"} adds a useful format cue, but no constraints or edge cases 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 ("stop one of their Winquill watches") and identifies the exact input key (watchId) plus where it comes from. It is clearly distinguishable from watch_tenders, list_watches, and get_tender_updates, which are all named.

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

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

"Use this when the user wants to stop one of their Winquill watches" gives an explicit trigger, and the provenance hint routes the agent to watch_tenders or list_watches to obtain the id. No explicit when-not is stated, but the note that existing findings still appear in get_tender_updates implies the boundary against continuing to monitor.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful framing that this is a lightweight freshness/polling endpoint used to keep a UI page up to date, but it stops short of disclosing what the response contains or whether calling it has cost/rate implications.

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 is a single well-front-loaded sentence with no filler. The trailing 'for Winquill's app to keep its page up to date' is slightly consumer-centric, but it does add a real hint about the tool's lightweight polling nature rather than being pure 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?

With no output schema and 0% parameter coverage, the description must be self-sufficient and it is not: it never says what 'changes' returns (a timestamp, a diff, a flag) or what tender_reference does. An agent cannot confidently interpret the result or supply the optional parameter from this definition alone.

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 must carry parameter meaning and it largely does not. 'Workspace' is only implicitly referenced ('work in a workspace'), with no guidance on identifier format or scope, and the second parameter tender_reference is never mentioned at all — a significant gap given the tool's apparent tender-centric siblings.

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 conveys that this is a change-detection/polling query scoped to a workspace ('Says when the team's work in a workspace last changed'), which is more than the bare name 'tenda_changes' provides. However, it never states the concrete return substance (timestamp? version token? boolean?) nor distinguishes itself from siblings like get_tender_updates or list_watches, leaving an agent to infer the exact verb+resource.

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 exclusion conditions, and no mention of the obvious alternative (get_tender_updates) for checking recent activity. The only contextual cue — that Winquill's app uses it to keep a page current — describes the consumer, not when an agent should call it.

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?

Goes well beyond the annotations by disclosing what survives the call ('keeps its rules and history, so it can be turned on again') and the authorization profile ('Needs a Winquill account; owners, admins and bid leads turn them off'). The annotations only say non-destructive and idempotent; the description supplies reversibility and role requirements an agent needs before invoking.

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, each carrying distinct information: trigger, effect/reversibility, authorization. The usage condition is front-loaded and there is no filler.

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

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

For a two-parameter mutation tool with an output schema, the definition covers intent, effect, reversibility and permissions, which is essentially everything an agent needs. Only the already-off / idempotent edge case is left implicit (covered by annotations).

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 both parameters (workspace, automation) are fully documented in the schema, including the reference to list_automations for obtaining the identifier. The description adds only the loose phrase 'workspace's automations' and nothing about the name-vs-id or multi-workspace behavior, 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 ('one of the workspace's automations to stop'), which unambiguously separates it from siblings like turn_on_automation, add_automation and list_automations. An agent can pick the correct tool 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 opening sentence gives a clear trigger condition tied to user intent ('when the user wants ... to stop'). It implies the contrast with turn_on_automation without naming it, and gives no explicit exclusion for edge cases such as an automation that is already off.

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?

Goes well past the annotations (which only flag readOnly=false, destructive=true, idempotent=true): it discloses the execution identity (runs as the user), a scheduling constraint (outside quiet hours), a negative capability list (never submits a bid, messages a buyer, declines a tender, emails outside the team, or changes workspace membership), and the authorization model (owners, admins, bid leads). No contradiction with destructiveHint — 'acts on the team's pipeline as its rules say' is consistent with a mutating, enabled-side-effect 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?

Four dense sentences, each carrying distinct load: precondition, runtime behavior, capability limits, auth/alternative. The gating precondition is front-loaded in the very first clause, which is exactly where an agent needs it.

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

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

An output schema exists, so return values need no explanation, and both parameters are covered by the schema. The description covers everything else an agent needs for a mutating, permission-gated tool: consent gate, execution identity, side-effect boundaries, and auth roles.

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 (workspace, automation) are already documented in the schema. The description reinforces that the automation is referenced after having its rules read back, but adds no new syntax or format guidance beyond what the schema supplies. 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 (turn an automation on) and immediately adds what that means operationally: it runs as the user, outside quiet hours, and acts on the team's pipeline. Explicitly names the sibling it is not (turn_off_automation), so an agent can route correctly without opening either schema.

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

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

Gives an explicit precondition ('only after you have read an automation's rules back to the user in plain words and they said yes'), which is a hard gate on when to call it. Also names the exact alternative for the inverse operation (turn_off_automation), covering both when-to-use and when-not-to.

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=false, destructive=true, idempotent=true, but the description adds genuinely new behavioral context: the tool records who did the step and when, returns what comes next plus its due date, and specifically that ticking 'submit' transitions the tender to Submitted. It does not explain what could be lost given destructiveHint=true, which is the remaining gap.

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

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

The usage trigger is front-loaded and every clause carries information (trigger, effect, state transition, prerequisites, exclusions). It is dense and reads as one long sentence, which slightly hurts scannability, but there is no filler.

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

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

An output schema exists, so return values need not be spelled out, and prerequisites plus the submit state change are covered. What is left unaddressed is the destructive framing declared in annotations: an agent is not told what is irreversibly changed or whether reopening a step restores prior state.

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

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

Schema description coverage is 100% and each parameter is documented in-schema, including the done/step/workspace/tender_reference semantics and examples. The description restates step names and scoping but adds no syntax or format detail beyond the schema, 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?

Names a specific verb (update/tick off) and resource (a step of a bid sprint), enumerates the exact six steps it operates on, and states the side effect. It also explicitly distinguishes itself from draft_bid_response and review_bid_draft, so an agent can route correctly 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 explicit trigger phrases (user says a step is done, or was ticked off by mistake), names the two alternatives for the answer-writing path, and states prerequisites: a Winquill account and a bid sprint created via record_bid_call. Both when-to-use and when-not-to-use are 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 and readOnlyHint=false, and the description adds real context beyond them: the workspace's home country cannot be turned off, country changes are restricted to owners/admins, and a Winquill account is required. It does not explain why the operation is flagged destructive (e.g. losing filters or watch state when switching workspaces), which leaves a meaningful 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?

It is a single dense sentence that leads with the use case, which is good, but the phrasing is run-on and drops a fragment ('or stop:') that reads like a truncation. The key information is present but harder to parse than it needs to be.

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

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

An output schema exists, so return values need not be explained, and the description covers permissions, the account prerequisite, and the home-country invariant. However, for a tool annotated as destructive with an opaque free-form parameter, it never states what state is lost or whether changes are reversible, leaving the riskiest aspect undocumented.

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 'set' parameter is an untyped free-form map, so the description carries the entire burden. It does so usefully by naming the 'workspace' key with the workspace name as its value and by explaining that country keys from get_tenda_settings map to true/false. It still doesn't say whether any other keys are accepted or what happens with unknown keys.

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 on a specific resource: switching the active workspace and toggling country visibility of tenders, with an implicit read counterpart via get_tenda_settings. It is somewhat garbled ('or to show tenders from another country or stop:') and mixes the 'Winquill' and 'tenda' naming, but an agent can still tell this is the write/settings tool and not the get_tenda_settings reader.

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 opens with an explicit trigger ('Use this when the user wants ChatGPT to use another of their Winquill workspaces, or to show tenders from another country') and points at get_tenda_settings as the source of valid country keys. Permission scope is also stated (owners and admins change countries). It lacks an explicit when-not clause, e.g. to use get_tenda_settings for reading the current configuration.

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