UK Parliament MCP Server

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

With no annotations, the description carries the full behavioral burden, but it does establish that this is a static, exhaustive reference set (all possible stages) rather than a per-bill query, which is the key behavioral fact. It says nothing about caching, stability of the list, or how the order of stages relates to the legislative sequence.

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?

Purpose is front-loaded in the first sentence and the description is short with no filler. The trailing 'Returns: All bill stages with descriptions' is mild padding given an output schema already exists, but it costs almost nothing.

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

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

For a zero-parameter lookup with a full output schema, the description is sufficient: purpose, an example of the values, and confirmation that descriptions accompany the stages. The only real gap is failure to disambiguate from get_bill_stages, which sits in the sibling set.

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 parenthetical examples (First Reading, Committee Stage, Royal Assent) give useful flavor about what the returned stage values look like.

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 — 'Get all possible stages a bill can go through' — and the word 'possible' signals this is the reference taxonomy rather than instance data. However, it never names or distinguishes itself from the closely-named siblings get_bill_stages and bill_types, so an agent must infer the boundary.

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 when tracking bill progress' is loosely worded and arguably points an agent at instance-level tools like get_bill_stages; no alternatives, exclusions, or preconditions are stated. The only real guidance is the parenthetical process example, which is illustrative rather than directional.

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

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

No annotations are provided, so the description carries the full load. It notes that all bill types are returned with descriptions, implying this is a complete, safe, reference-style read. But it does not state that the tool takes no parameters or that results are static, which would fully close the behavioral picture.

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

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

Two sentences, front-loaded purpose followed by a usage cue and a Returns block. Slightly more verbose than necessary for a zero-parameter reference tool, but no 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 an output schema present, the description does not need to spell out return fields, and the Returns line covers the shape at a high level. For a simple zero-param reference tool this is close to complete, though it omits any note about the enumeration being fixed/static.

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?

Parameter count is 0, so the baseline is 4. Schema coverage is 100% and there is nothing for the description to disambiguate; no evidentiary basis to deduct.

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 ('Get') and resource ('types of bills'), with concrete examples (Government Bill, Private Member's Bill) so the agent knows exactly what is returned. Distinguishes itself from siblings like get_bill_by_id or search_bills by being a reference/enumeration lookup.

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 usage context: 'Use when you need to understand different categories of legislation.' This tells the agent when to reach for it, though it doesn't name an alternative or note when not to use 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?

No annotations are provided, so the description carries the full burden. It does disclose pagination mechanics (skip/take) and the shape of the return, which is useful, but says nothing about permissions, rate limits, or that the operation is a safe read.

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 pipe-delimited summary followed by Args/Returns. Efficient, though the Returns line is somewhat redundant given an output schema exists and repeats the purpose statement.

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

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

For a simple paginated browse tool with an output schema, the description covers parameters and behavior adequately. It need not explain return values since an output schema exists, and nothing essential to invocation 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 0%, so the description must compensate, and it does: start_letter is documented as A-Z or None for all, skip as pagination offset with default 0, take as result count with default 30. All three parameters gain meaning beyond the bare 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 (browse) and resource (Erskine May index), plus the alphabetical scope, which distinguishes it from search-style siblings. It does not explicitly name search_erskine_may_index as the contrasting tool, but the 'browsing alphabetically' framing makes the purpose legible.

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 to discover topics by browsing alphabetically' gives implied context for when this tool is appropriate versus a search. However, it never names the obvious alternative (search_erskine_may_index) or states an exclusion, so the guidance stays at the implied level.

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

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

With no annotations provided, the description carries the full burden, and it does disclose the return shape (list of matching parent/child locations). However, it says nothing about read-only semantics, permissions, pagination, or result limits, which is a meaningful gap for a browse 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 core sentence is front-loaded and useful, but the pipe-delimited keyword string ('location browse, constituency type, country region') is filler, and the 'Returns' line duplicates the opening sentence's return description.

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

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

An output schema exists, so the description need not detail return values, and it covers both required parameters with examples plus the hierarchical scope. Adequate for a two-parameter browse tool; only behavioral caveats (limits, matching mode) are 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?

Schema description coverage is 0%, so the description must compensate, and it does: location_type is given concrete example values ('Constituency', 'Country', 'Region') and location_name is identified as the name to browse. The only omission is whether matching is exact or partial.

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 (browse) and resource (locations) and describes the return shape ('parent and child locations'). It is distinguishable from sibling location tools such as get_constituencies or get_calendar_locations, though it never names an alternative explicitly.

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

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

'Use when exploring the location hierarchy (e.g. countries, regions, constituencies)' gives a clear triggering context. It stops short of stating when NOT to use it or which sibling to prefer for flat lookups, so it is clear but not exhaustive.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the tool composes get_member_by_id with the House-appropriate voting-record call, and that Lords votes return Content/Not Content rather than Aye/No. It omits error/edge behavior (e.g., unknown member_id, no matching divisions) and any rate-limit or auth notes, 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?

Content is front-loaded: purpose, then trigger, then composition, then args, then returns. It is efficient, but the keyword-stuffed synonym line ('MP voting stance, how did MP vote, voting record on topic, division lookup, aye or no') is redundant padding that does not aid selection.

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

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

For a composite tool over three parameters with an output schema present, the description covers what the tool does, when to use it, how it resolves the member's House, and what the caller must supply first. 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?

Schema description coverage is 0%, so the description must compensate, and it does: member_id is explained as a Parliament member ID obtainable from member search with a concrete example (4514), topic is defined as a keyword matched against division titles with examples, and take is given a default and a max (25/100) that the bare schema lacks. Every parameter gains meaning beyond the schema.

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

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

The description names a specific verb and resource ('Check how an MP or Lord voted on a topic') and immediately clarifies scope: it combines member lookup with division votes, covering both Houses. The 'See also' clause names compare_member_votes and search_commons_divisions, letting an agent distinguish it from the closest siblings 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 a clear trigger condition ('Use when you need to know how a specific member voted on a particular issue') and points to alternatives via 'See also'. It does not state when NOT to use it or when compare_member_votes/search_commons_divisions would be the better pick, so it falls short of explicit routing.

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

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

With no annotations, the description carries the full burden and does well: it discloses the composite implementation (combines get_member_by_id x2 and the voting-record calls x2), the same-House constraint on member_id_b, and the full return shape (agreement counts/rate, shared divisions, single-member divisions). It omits read-only/permission context and any rate-limit or cost notes, keeping it short of a 5.

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

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

The purpose sentence is front-loaded and the Args/Returns sections are well organized, but the keyword block ('compare voting records, do they agree, voting similarity, rebels, party loyalty, head to head') is SEO-style padding that restates the same idea several times without adding selection signal.

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 comparison tool whose output schema already documents the return values, the description supplies everything an agent needs to call it correctly: both IDs, the same-House constraint, topic filtering, and the take window, plus the composite-call behavior. Nothing material 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 0%, so the description must compensate and it does fully: it explains member_id_a's source and gives a concrete example (4514), states member_id_b's same-House requirement, defines topic with matching examples, and specifies take's default (50) and max (100).

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 ('Compare how two MPs ... voted - lines up their votes division by division') and names the sibling tools it is not (check_mp_vote, get_commons_divisions_grouped_by_party). An agent can distinguish this from the single-member voting-record tools without opening a schema.

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

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

Gives an explicit trigger ('Use when asked whether two members vote the same way, overall or on a topic') and routes to related siblings via 'See also'. It stops short of stating when NOT to use it or listing alternative tools the agent should prefer in edge cases, so it is clear but not exhaustive.

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

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

No annotations are provided, so the description carries the full burden. It discloses the shape of the result ('List of Early Day Motions signed by the member') and the 'all' scope, implying an exhaustive read, but says nothing about pagination, result limits, session coverage, or whether the MP must be current all relevant for a signatures listing.

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 and routing sentence are front-loaded with zero waste. The trailing 'Returns' block is mildly redundant given an output schema exists, but the overall block is short and readable.

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

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

For a single-parameter read tool with an output schema present, the description covers purpose, use case, alternative, parameter meaning, and result type. The remaining gap is how the caller sources member_id and whether results are scoped to a session or all time.

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 compensate for the single member_id parameter. It identifies the parameter as a 'Parliament member ID', which is better than raw schema, but gives no format hint or pointer to a lookup tool (e.g., get_member_by_name / search_members) for obtaining the ID.

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 (Get), resource (Early Day Motions), and scope (signed by a specific MP), which is exactly the discriminating detail against the sibling search_early_day_motions. An agent can tell what this returns 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?

Explicitly frames the use case ('when you want to see what issues a particular member has supported or their political priorities through EDM signatures') and points to the alternative, search_early_day_motions. It stops short of stating when NOT to use it (e.g., no per-member filtering needed, or wanting EDM text rather than signature lists).

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

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

No annotations are provided, so the description carries the full burden, and it discharges almost none of it: no indication of error behavior for an unknown ID, no permission/auth requirements, no note on whether the returned detail set is stable. 'Returns Act details' is a restatement, not disclosure.

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 same idea is restated four times across the description ('Get Act details', 'Get full details of an Act of Parliament', 'Returns Act details', 'Full Act details') against a one-line tool. Keyword-stuffing for search rather than front-loaded 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 one-parameter read tool with an output schema that already defines return values, the description plus schema cover the mechanics adequately. It is still missing sibling routing and error semantics, but those are not fatal here.

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 compensate — and it does partially, telling the agent the act_id is an 'alphanumeric string from search results', which supplies both format and provenance. It stops short of a format example or a pointer to the exact search tool that yields it.

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

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

States a specific verb and resource ('Get full details of an Act of Parliament'), so the agent knows it retrieves a single Act by ID. However, it never distinguishes itself from the sibling search_acts_of_parliament, leaving the agent to infer the lookup-vs-search split.

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

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

No when-to-use guidance, no prerequisites, and no mention of the sibling search tool that produces the act_id. The only hint is the parenthetical '(alphanumeric string from search results)', which implies a search-then-fetch flow but never states 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?

No annotations are provided, so the description carries the full burden. 'Get RSS feed' implies a read-only operation, but the description does not explicitly state that it has no side effects, nor does it disclose caching, format, or authentication behavior.

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

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

The description is short and front-loads the purpose. However, the 'Returns:' section repeats the first sentence nearly verbatim, adding redundant text without 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?

Given the simple no-param shape and the existence of an output schema, the description covers what the tool does. But in a toolset with several similar RSS siblings, it fails to help an agent choose this one over get_public_bills_rss, get_private_bills_rss, or get_bill_rss.

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

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

The tool takes zero parameters and the input schema is empty. Per the rubric, zero parameters yields a baseline of 4; the description does not need to add parameter semantics.

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

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

States a specific verb and resource: 'Get RSS feed of all bills.' The scope 'all bills' implicitly distinguishes it from public, private, and per-bill RSS siblings, but it does not name or explicitly contrast with those alternatives.

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?

Provides a generic use condition: 'Use when you want to stay updated on all legislative activity through RSS feeds.' It does not say when to choose this over get_public_bills_rss, get_private_bills_rss, or get_bill_rss, nor does it provide any exclusions.

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

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

No annotations are supplied, so the description carries the burden; the 'Get' verb implies a read-only operation, but the definition never states permissions, that it is non-mutating, or any error/not-found behavior. It does add the field inventory of the response, which is modestly useful context.

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

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

Front-loads the purpose well in one sentence, but the Args/Returns boilerplate largely duplicates the input schema and the existing output schema, so it does not fully earn its space.

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 detailed; the description adequately conveys that this is a single-item detail fetch. However, with zero annotation and zero schema description coverage, the definition leaves the agent under-informed about the three required parameters and read-only safety.

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 all three integer parameters, and the description only restates names ('bill_id: Bill ID', 'bill_stage_id: Bill stage ID') without explaining how to obtain a stage id or how bill/stage/amendment ids relate. It adds essentially no meaning beyond the identifiers themselves.

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

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

States a specific verb and resource ('Get detailed information about a specific amendment') and enumerates the fields returned, which separates it from the list-style sibling get_bill_stage_amendments. The 'by_id' retrieval scope is clear, 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?

'Use when you need complete amendment details including text, sponsors, decision, and explanatory notes' gives contextual usage, but there is no when-not guidance and no alternative tool is named despite several amendment/bill-stage siblings.

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

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

No annotations are provided, so the description carries the full burden. It is a pure calculation, so the main behavioral question is whether the day count includes sitting days, recesses, or is calendar-only, and whether the calculation accounts for treaty-specific rules. The description hints at treaty handling via is_treaty but does not disclose the calculation basis, leaving a meaningful gap for a date-sensitive 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 opening line duplicates the same information three times ('Get annulment date | ... | Calculate the annulment date ... | Returns annulment date'), and the Returns line restates what the Args section already implies. The Args block itself is well-structured, but the redundant front matter and pipe keyword stuffing waste space.

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-value detail is unnecessary, and the description adequately documents all three parameters for a low-risk calculation. The main missing piece is the behavioral basis of the calculation (calendar days vs sitting days, treaty handling), which matters for trusting the result.

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 compensate, and it does: it defines date_laid as the laying date with a YYYY-MM-DD format, days_in_future as the number of days from date_laid with an example (40), and is_treaty as whether the SI is a treaty/agreement with a default of false. This is solid compensation for the empty 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: 'Calculate the annulment date for a negative statutory instrument', which is distinct from sibling SI tools like get_si_procedures or get_si_timeline_business_items. The pipe-separated keyword prefix ('SI annulment, negative SI, scrutiny period, 40 days') is noisy but reinforces the domain. It does not explicitly contrast itself with any sibling, 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?

Usage is only implied through the domain context ('negative SI', 'scrutiny period', '40 days'), which tells an agent this is for the negative-SI annulment calculation. There is no explicit statement of when to use this versus related SI timeline tools, and no exclusions or prerequisites are given.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it adds almost nothing: it does not state that this is a read-only operation, what happens when no message exists for the date, or any auth/rate considerations. For a tool with zero annotation coverage, this is a notable 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 core purpose is front-loaded, but the intent is restated three times ('Get annunciator message...', 'Retrieve what was displayed...', 'Returns annunciator message data...') and the keyword string 'annunciator, chamber display, historical activity' adds filler. Tighter phrasing would lose no 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 the description needn't detail return values, and both parameters are documented with examples. Given the simplicity of a two-param readonly lookup, coverage is nearly complete; only edge-case behavior (empty results, pagination) is unaddressed.

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

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

With schema description coverage at 0%, the description compensates well: it gives concrete annunciator values ('CommonsMain' or 'LordsMain') and specifies the date format (YYYY-MM-DD), which the schema does not. It stops short of 5 only because it doesn't say whether the annunciator value is case-sensitive or validated against a fixed set.

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 ('Get') and resource ('annunciator message') scoped to a chamber and date, so the resource and operation are unambiguous. It does not distinguish itself from related siblings like happening_now_in_commons/happening_now_in_lords, which cover similar annunciator-board content, 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?

The phrase 'historical activity' and 'what was displayed on the annunciator board for a given date' implies this is for retrospective lookups rather than current display, but no when-to-use/when-not guidance or named alternative is given. Usage is inferable but not spelled out.

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

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

With no annotations, the description carries the full burden. It does disclose a meaningful behavioral constraint ('Commons only') and the return value, but says nothing about error behavior when a non-Commons house is passed (despite the house param accepting 'Lords'), permission needs, or how deadlines are computed.

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 Args/Returns structure is readable and front-loads the purpose, but the opening pipe-separated keyword line ('PQ answer date, response deadline, when answers due') is search-bait that duplicates the purpose statement without adding meaning. Trimming it would tighten the definition.

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 low-complexity, 3-required-param tool with an output schema present, the definition covers purpose, all params, and the return value, so an agent can call it correctly. The only gap is the unresolved tension between 'Commons only' and a house parameter that accepts 'Lords'.

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

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

Schema coverage is 0%, so the description must compensate, and it does: it documents all three parameters, gives accepted values for house ('Commons'/'Lords', 1 or 2 also accepted), enumerates question_type values ('NamedDay'/'Ordinary'), and specifies the tabled_date format (YYYY-MM-DD). This is exactly the detail the schema omits.

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

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

States a specific verb and resource ('Get the earliest answer date for a written question') and adds a scope constraint ('Commons only'). The keyword line ('PQ answer date, response deadline, when answers due') reinforces the resource domain, making it easy to separate from siblings like get_written_question or search_written_questions.

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

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

Usage is implied rather than stated: you use it when you have a house, question type, and tabled date and want the deadline. There is no explicit when-to-use vs when-not-to-use guidance or pointer to a related tool (e.g. get_written_question, get_tabling_deadline). The 'Commons only' note is a partial scoping hint.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses return content (names, abbreviations, policy responsibilities) and filter behavior, but says nothing about pagination, permissions, or result size limits for a governance-lookup 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?

Front-loaded with the core action, but the pipe-separated keyword block is keyword stuffing and the return contents are stated twice (in the body and again under 'Returns'). The Args/Returns scaffolding adds length without 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?

For a single-optional-parameter lookup with an output schema present, the description covers purpose, usage context, filter semantics, and return content. Missing only operational details like pagination, which is a minor gap given the output schema exists.

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

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

Schema description coverage is 0% and there is only one parameter, so the description must supply the semantics itself. It does: 'Filter by partial name match' plus concrete examples ('Treasury', 'Health') clarify match behavior and expected values beyond the bare schema type.

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

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

States a specific verb and resource — 'Get government departments and their parliamentary responsibilities' — and clarifies the ambiguous term 'answering bodies' via keyword context. However, it does not differentiate itself from the closely-related sibling get_departments, which is named in 'See also' without saying how the two differ.

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

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

Explicitly says 'Use for understanding government structure, finding responsible departments, or determining who answers questions on specific topics' and names two alternatives (get_departments, search_written_questions). No when-not guidance is given, and it never explains when to prefer it over get_departments.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only notes that results are 'grouped by type'; it says nothing about what 'archived' means versus live publications, permission/auth requirements, pagination, or the read-only nature of the call.

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

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

The front-loaded pipe-separated keyword list plus an Args/Returns block restates the same information multiple times, and the 'Returns' line duplicates what the output schema already conveys. It is readable but not waste-free.

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 not strictly required, and the tool takes only one parameter. However, with no annotations and no guidance on the archived-vs-current distinction or the committee_id source, the definition is only minimally sufficient.

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

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

Schema description coverage is 0% and the description only repeats 'committee_id: Committee ID.' — a tautology that adds no format, source, or lookup guidance. With a single required parameter and no schema documentation, 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 description states a specific verb ('Get'), resource ('archived publication links') and scope ('for a committee'), which lets an agent distinguish it from generic siblings like get_publications. It does not, however, explicitly contrast itself with get_publications or get_committee_publications_summary, leaving the boundary inferred.

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 phrase 'Use to find archived publications linked to a committee' gives implied usage context, but there is no guidance on when to prefer this over get_publications or other committee publication tools, 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?

No annotations are provided, so the description carries the full burden, yet it only says 'Get... Returns: Comprehensive bill details.' Read-only nature is implied by the verb and the output schema covers the return shape, but nothing is said about error behavior for an unknown ID, whether the ID must come from a search call, or any access constraints.

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?

Purpose is front-loaded, followed by the usage trigger and sibling pointers; the Args/Returns blocks are lightly redundant but standard. Overall tight and easy to scan.

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 an output schema already documenting the return shape, the description is close to sufficient. It omits, however, the practical detail of how an agent obtains a valid bill_id and what happens on a miss, which is the main remaining gap.

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

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

Schema description coverage is 0% and there is one required parameter, so the description must compensate. Its 'bill_id: Unique bill ID number' line adds essentially nothing beyond the property name and type — it does not say where to obtain the ID (e.g., from search_bills or get_recently_updated_bills) or what form it takes.

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

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

States a specific verb and resource ('Get detailed information about a specific bill by ID') and enumerates the content it returns (title, sponsors, stages, summary, status). It names related siblings (get_bill_overview, get_bill_stages, get_bill_committees), which helps an agent see it as the comprehensive bill getter, though it never says explicitly how it differs from get_bill_overview.

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 when you need comprehensive bill details including title, sponsors, stages, summary, and current status' gives a clear positive trigger and the 'See also' list surfaces the alternatives. No when-not guidance is offered, so it stops short of a full routing rule.

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

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

With no annotations, the description carries the behavioral burden and does well: it discloses that this is an aggregator ('Combines: get_bill_by_id, get_bill_stages, ...'), what the return contains (committee stages with sitting dates, select committee business with the examining committee), and a data-quality caveat ('items whose linked_bill_ids include the bill are confirmed links'). It does not mention permissions, rate limits, or pagination, so it falls short of a 5.

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

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

Front-loaded with purpose and trigger before the pipe-separated synonym keywords and the aggregation notes. The keyword list is somewhat stuffed and the separate 'Returns' section partly duplicates the body, but nothing is disorganized or buried.

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

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

An output schema exists, so return values needn't be spelled out, yet the description still summarizes the shape usefully. For an aggregator of five underlying tools, it explains the combined provenance and the confirmed-link caveat; only auth/limits and the merged-item ordering are left unaddressed.

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

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

Schema coverage is 0% (the only param has a bare title and no description), so the description must compensate, and it does: 'Bill ID. Get from search_bills or get_bill_overview. Example: 3764' supplies both provenance and format. It adds real value beyond the schema, though it doesn't state the type or invalid-ID behavior.

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 ('Find') plus resource ('the committees that examined a bill'), with a synonym line and an explicit sibling disambiguation ('See also: get_committee_bills (the reverse)'). An agent can separate this from the reverse lookup and from get_bill_overview 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?

States the trigger explicitly ('Use when asked which committees looked at a bill, or to find committee evidence and reports on it') and names the complementary/alternative tools (get_committee_bills as the reverse, get_bill_overview). Both when-to-use and the alternative routing 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?

No annotations are provided, so the description carries the full burden. It says nothing about ordering, result limits, date filtering, or what the article records contain, leaving the agent with only the bare assertion that news articles are returned.

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

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

The core purpose and usage condition are front-loaded in the first two sentences, and the Args/Returns block is compact. The Returns line is largely redundant with the output schema, but overall the structure is 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?

For a simple read tool with an output schema present, the definition covers the essentials. It is missing details such as result ordering or default page size behavior, which matter for correct pagination usage given take/skip defaults of null.

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 compensate, and it does document all three parameters. It clarifies that skip is for pagination and take is the record count, adding meaning beyond the bare integer types in the schema.

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

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

States a specific verb and resource ('Get news articles related to a specific bill'), which is clear and distinct from generic siblings. It does not explicitly distinguish itself from adjacent bill tools like get_bill_publications or get_bill_overview, so it falls short of a 5.

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

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

Provides clear usage context ('Use when researching media coverage, press releases, or official communications about legislation'), which tells the agent the research intent. However, it names no alternative tools or exclusions, so it stops short of full when/when-not guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose that the tool aggregates four other calls into one, which is genuine value-add context. However, it says nothing about read-only nature, rate limits, auth requirements, or how the search matches, so the disclosure is only partial.

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 and usage condition are front-loaded efficiently, and the combiner list is concrete. The pipe-separated keyword dump ('complete bill info, legislation overview, bill progress, full bill details') is somewhat redundant tag-spam that duplicates the later Returns line.

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 a single required parameter, an existing output schema, and no annotations, the description covers purpose, aggregation behavior, usage condition, and alternatives. Return-value detail is legitimately omitted because an output schema exists. Only minor behavioral gaps remain.

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

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

Schema description coverage is 0% and the schema only defines 'search_term' as a bare string, so the description must compensate. It does: 'Search term for bill title or content' clarifies the matching semantics and adds three concrete examples, which meaningfully exceeds 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 ('Get comprehensive bill overview') and explicitly names what it aggregates: search_bills, get_bill_by_id, get_bill_stages, get_bill_publications. An agent can distinguish this aggregator tool from the individual sibling tools 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?

'Use when you need complete information about a bill without multiple tool calls' gives a clear selection condition versus the single-purpose siblings it names. The 'See also' routing to get_bill_committees and get_member_bills is helpful, but no explicit when-NOT-to-use (e.g. when only one aspect is needed) is stated, so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a real behavioral trait — the show_on_website_only filter and its default — which is useful, but says nothing about permissions, visibility rules for non-website petitions, or rate limits.

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

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

Front-loaded with the core action, but the pipe-delimited keyword list plus the redundant 'Returns petition details' / 'Returns: Detailed bill petition record.' duplication costs space without adding 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 need not be spelled out. For a simple get-by-id tool this is adequate, but it omits the get-vs-search routing guidance that would make it complete alongside search_bill_petitions.

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 compensate, and it does document both params ('Bill petition ID.' and the website-visibility filter with its default). The petition_id explanation is thin and adds little beyond the parameter name.

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 ('Get a specific bill petition by ID') and adds domain keywords ('bill petition, private bill, hybrid bill petition'). The 'by ID' phrasing implicitly distinguishes it from search_bill_petitions, though the sibling is never 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?

'Use to get full details of a petition submitted on a Private Bill' gives implied usage context. However, it never states when NOT to use it or points to the sibling search_bill_petitions for discovery-style lookups, leaving the get-vs-search distinction to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Get' implies a read, and the mention of 'document versions' hints at versioned content, but nothing is said about permissions, pagination, or result volume for a list-returning tool. An output schema exists, so return shape needn't be described, but the retrieval profile is thin.

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 and usage sentences are front-loaded and efficient, but the trailing 'Args' and 'Returns' blocks duplicate information already carried by the input and output schemas, diluting an otherwise tight definition.

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 sibling alternatives are named. The remaining gap is the absence of any behavioral detail for a tool with zero annotations, though for a simple read-only bill listing that omission is not severe.

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

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

Schema description coverage is 0% and the description's 'bill_id: Bill ID to get publications for' merely restates the parameter name/title without adding format, validation, or sourcing guidance. With a single self-evident integer parameter the gap is small, but no value is added 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 with clear scope: 'Get all publications for a specific bill.' The 'See also' line naming get_bill_stage_publications and get_publication_document lets an agent separate the bill-level listing from the stage-scoped and single-document siblings.

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

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

'Use when researching bill documents, impact assessments, explanatory notes, or tracking document versions' gives concrete research contexts. It points at alternatives via 'See also' but never states the condition that selects one over another, so routing still requires inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says nothing about what the RSS feed actually is (a URL, XML payload, or metadata), whether any authentication or subscription is required, or any rate/refresh characteristics of a feed endpoint.

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

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

Front-loaded with the core purpose in one sentence, which is good. The Args/Returns block then restates the same information ('RSS feed for the specified bill'), which is boilerplate rather than added value.

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 not required. However, with no annotations and zero schema description coverage on the only parameter, the definition leaves the agent without enough behavioral or parameter context for a feed endpoint.

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?

One parameter with 0% schema description coverage. The description's 'bill_id: Bill ID to get RSS feed for' merely restates the name, adding no format, source, or valid-range detail to compensate for the schema gap.

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

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

States a specific verb and resource ('Get RSS feed for a specific bill by ID'), which is clear on its own. It does not, however, distinguish itself from the closely related siblings get_all_bills_rss, get_public_bills_rss, and get_private_bills_rss, so an agent must infer the scoping difference.

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 when you want to track updates and changes to a particular piece of legislation' gives implied context for the single-bill case. It never names or contrasts with the sibling RSS tools, and gives no exclusions or prerequisites, so routing guidance is only partial.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that results are stage-scoped and that skip/take enable pagination, but says nothing about permissions, result ordering, or volume, and the return statement is a bare restatement ('Amendments for the specified bill stage'). Adequate for a read-only list tool but not rich.

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

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

Purpose sentence comes first, usage guidance second, sibling pointers third, then a compact Args/Returns block. Every line earns its place and nothing is buried; the docstring format keeps it scannable.

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 8 parameters, 2 required, 0% schema coverage, and an output schema present, the description covers the parameters and correctly leaves return-value detail to the output schema. It does not explain how filters interact (e.g., search_term with amendment_number) or pagination defaults, which keeps it just short of 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 0%, so the schema only exposes titles like 'Skip' and 'Member Id'. The description compensates by labeling every one of the 8 params, marking which are optional, explaining skip/take as pagination, and clarifying that amendment_number targets a specific number and member_id identifies the proposer. That is meaningful semantic lift 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+resource: 'Get all amendments for a specific bill stage.' It also names the two nearest siblings (get_amendment_by_id, get_bill_stage_ping_pong_items), which helps an agent separate this scoped list from the single-item lookup and the ping-pong variant. It stops short of explicitly contrasting scope with those siblings, so a 4 rather than 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 three concrete use cases ('researching proposed changes to legislation, tracking amendment activity, understanding what modifications are being suggested') and a 'See also' pointer to alternatives. It does not state when NOT to use it or the precise condition that selects get_amendment_by_id over this tool, so it lacks explicit routing rules.

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

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

No annotations are provided, so the description carries the burden. It discloses what the response contains (timings, committee involvement, related activities) and the name implies a read-only lookup, but it never explicitly states read-only semantics, permissions, or any rate/scope limits. For a low-risk getter this is adequate but thin.

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 sentence is front-loaded and useful, but the boilerplate Args/Returns sections are largely redundant — the Returns line merely echoes the opening sentence, and the Args lines restate the schema titles. Some trimming would improve signal 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?

An output schema exists, so the return format needn't be explained, and for a simple two-parameter read this is nearly sufficient. The remaining gap is parameter documentation (0% schema coverage) that the description fails to meaningfully fill.

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 compensate, yet its Args block only restates the parameter names ('bill_id: Bill ID', 'bill_stage_id: Bill stage ID to get details for'). It adds no format, source, or constraint information (e.g., where to obtain stage IDs via get_bill_stages) beyond what the titles already convey.

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 clear verb+resource: 'Get detailed information about a specific stage of a bill.' The word 'specific' implies a single-item lookup, distinguishing it from the list-style sibling get_bill_stages. However, it does not explicitly name its closest alternatives (get_bill_stages, get_bill_stage_amendments, get_bill_stage_publications).

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 phrase 'Use when you need complete details about a particular stage' gives an implied context, and it enumerates the content types (timings, committee involvement, related activities). But it names no alternative tool and gives no when-not-to-use guidance, leaving sibling selection to inference.

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

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

No annotations are provided, so the description carries the burden. The 'Get' verb and the Returns line imply a safe read returning a list, which is adequate for a low-risk retrieval tool, but it says nothing about permissions, rate limits, filtering behavior, or pagination defaults even though skip/take exist.

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 sentence is well front-loaded, but the Args block largely restates the input schema and the Returns line is redundant given an output schema exists. Several sentences do not earn their place against the structured data already available.

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 exists, the description need not explain return values, and its purpose, usage context, and parameter list are sufficient for an agent to call it correctly. The absence of any behavioral notes on filtering or pagination is the only material 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 0%, so the description must compensate, and it partially does with an Args block covering all 8 parameters. However most entries are tautological ('bill_id: Bill ID'), and only skip/take ('for pagination') and decision/member_id add any real meaning beyond the property names.

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

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

States a specific verb and resource ('Get ping pong items') and defines the jargon inline as 'amendments and motions for a bill stage,' which an agent could not infer from the name alone. It does not explicitly name or exclude sibling tools like get_bill_stage_amendments or get_ping_pong_item_by_id, so a 5 is not warranted.

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 when researching the final stages of bills passing between Commons and Lords, including disagreements and agreements on amendments' gives clear situational context for calling it. It lacks explicit when-not guidance and does not route the agent to alternative tools for the same data, so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full behavioral burden. Beyond the implied read-only 'get', it discloses nothing about pagination, ordering, response size, authentication, or failure modes when stage_id is invalid, which is a meaningful gap for a tool with zero annotation coverage.

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

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

The opening sentence is front-loaded and efficient, but the Args block duplicates the schema and the Returns line ('Publications for the specified bill stage') is tautological, especially since an output schema already exists. Some sentences do not 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?

The output schema removes the need to explain return values, and the two-parameter surface is simple, so the description is minimally sufficient. However, it omits sibling differentiation and any meaningful parameter semantics, leaving gaps for an agent choosing among the many bill/publication tools.

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 compensate, but it merely restates the schema titles: 'bill_id: Bill ID' and 'stage_id: Stage ID to get publications for'. It adds no format, validity, or relational meaning (e.g. that stage_id must belong to bill_id).

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: retrieving publications scoped to a specific bill stage. It clarifies the stage-level scope, but never distinguishes itself from the very similar sibling get_bill_publications (bill-level) or get_bill_stage_amendments, leaving the agent to infer the boundary.

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 sentence 'Use when you need documents related to a particular stage of legislation, such as committee reports or stage-specific amendments' gives concrete context and examples of what qualifies. It stops short of naming alternatives or stating when-not-to-use, so it reaches solid context without exclusion guidance.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only listing and mentions pagination via skip/take, but discloses no permissions, rate limits, or result characteristics beyond the terse 'Returns: All stages for the specified bill.' Adequate but thin for a definition with zero annotation coverage.

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

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

Front-loads the purpose and usage before the Args/Returns boilerplate. The Google-style Args/Returns blocks are somewhat redundant with the schema and output schema, but the prose is tight and earns its place.

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

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

An output schema exists, so return values needn't be explained. For a simple read tool with one required parameter, the description plus structured fields cover what an agent needs to call it correctly, though behavioral details remain sparse.

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 compensate. It names and briefly explains all three parameters ('bill ID to get stages for', 'number of records to skip', 'number of records to return'), which is helpful but minimal and adds little beyond the parameter names themselves.

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 with scope: 'Get all stages of a specific bill by bill ID.' It also names the relevant sibling tools (get_bill_stage_details, get_bill_stage_amendments, get_bill_committees), letting an agent distinguish it from neighboring stage-related tools without opening a schema.

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

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

Gives concrete when-to-use triggers ('tracking a bill's progress', 'understanding its legislative journey', 'finding specific stages like Committee Stage'). The 'See also' list points to alternatives, though it doesn't state when to prefer those over this tool, so no explicit exclusions.

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

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

No annotations are provided, so the description carries the full burden, and it discloses essentially nothing beyond the fact that a list is returned (which the output schema already covers). For a zero-argument read-only enumeration there is little risk to disclose, but the description does not even confirm it is a safe, side-effect-free, no-auth lookup.

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 same fact is restated four times: the title line, a pipe-separated keyword soup, a 'list all categories' sentence, and a 'Returns' block that duplicates the existing output schema. The pipe-delimited keywords are not front-loaded information but noise, and roughly half the text is redundant.

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

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

For a trivial no-arg enumeration with an output schema, the description is minimally sufficient. But against a sibling set crowded with near-identical calendar taxonomy endpoints, it omits the one thing that would make it complete: how categories differ from types, tags, and locations.

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

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

There are zero parameters, so the baseline is 4. Nothing in the description could add parameter meaning, and it correctly refrains from inventing filters that do not exist.

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?

It states a specific verb and resource (list all parliamentary calendar event categories), so an agent knows exactly what it retrieves. However it gives no differentiation from the near-identical siblings get_calendar_types, get_calendar_tags, and get_calendar_locations, and the keyword 'event types' actively blurs the line with get_calendar_types rather than sharpening it.

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 taxonomy siblings, and no prerequisites or exclusions. The agent must infer from the name alone that this is an enumeration/lookup endpoint rather than a filtered search.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only says it 'Returns event details' and does not disclose permission requirements, error behavior for an invalid/nonexistent ID, or any other operational trait an agent would need.

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 is front-loaded, but the same idea is repeated four times ('by ID | specific event, event details | Use to get full details | Returns event details'), and the Args/Returns block duplicates both the description and the existing output schema. Redundant rather than tight.

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

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

For a simple single-parameter getter with an output schema present, the description covers the basics without needing to explain return values. It is minimally viable but omits error/failure semantics and any differentiation from the numerous similar event tools.

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 compensate for the lone parameter, yet it only repeats 'event_id: The calendar event ID' — a restatement of the property name with no added format, range, or sourcing detail. It fails to add meaning beyond the schema.

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

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

The description states a specific verb+resource ('Get calendar event by ID') and clarifies it returns full details of a specific event, so the agent knows exactly what it does. However, it never distinguishes itself from the many similar siblings (get_event_by_id, get_events, search_calendar), so an agent cannot tell which sibling to pick from the description 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?

'Use to get full details of a specific calendar event' implies the use case (single event, full detail) but gives no when-not guidance and names no alternatives among the crowded calendar/event sibling set. Usage is inferable but not explicit.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does not state that this is a read-only, no-parameter listing operation, nor anything about ordering, pagination, or size of the result set; 'Returns list of locations' merely restates the obvious.

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 core sentence is front-loaded, but the opening pipe-delimited keyword dump is noisy and the return value is stated twice ('Returns list of locations' followed by a 'Returns:' block) with no added information in the second statement.

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

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

An output schema exists, so the description is not obliged to explain return values — yet it redundantly does so. The main completeness gap is the lack of differentiation from 'browse_locations' and other calendar listing tools, which is the one thing an agent actually needs here.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The keyword string ('venues, committee rooms, locations, where') adds a little vocabulary context but no parameter meaning.

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 clear verb and resource: 'List all locations used for parliamentary calendar events', which is more specific than the tool name alone. However, it never distinguishes itself from the sibling 'browse_locations', which appears to cover overlapping territory, so an agent cannot confidently choose between them from the text.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternatives are named. Given the presence of 'browse_locations', 'get_calendar_types', and 'search_calendar' among siblings, the absence of any routing signal is a real gap.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only list operation through 'Get' and 'List all tags', and an output schema covers return shape, but it does not explicitly confirm read-only safety or any other trait. For a zero-parameter lookup this is minimally adequate.

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 first purpose sentence is efficient and front-loaded, but the return information is duplicated: 'Returns list of tags' is immediately followed by 'Returns: List of calendar event tags.' The pipe-delimited keyword line also adds length without value, so the description wastes space.

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

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

With no parameters and an output schema present, the description need not explain return values. It states that the tool lists all calendar event tags, which is sufficient for an agent to invoke it correctly. The main missing element is sibling differentiation, which is a usage gap rather than a completeness 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?

There are zero parameters, so the baseline is 4. The schema has 100% description coverage and no parameters to document, meaning the description has no parameter semantics to add or omit.

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 ('List') and resource ('tags used to label parliamentary calendar events'), making the general purpose clear. However, it does not distinguish itself from sibling tools like get_calendar_types or get_calendar_categories, and the pipe-delimited keyword line adds no differentiation.

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

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

The description gives no when-to-use guidance, no circumstances for choosing this tool, and no alternatives. An agent cannot tell from this text whether to call get_calendar_tags instead of get_calendar_types, get_calendar_categories, or get_calendar_locations.

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

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

With no annotations, the description carries the full behavioral burden and mostly fails: it does not state that this is a read-only reference lookup, whether the list is static or session-scoped, or anything about caching/rate behavior. 'List all event types' is essentially the only behavioral claim, and it is a tautology of the name.

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 says the same thing three times ('Get calendar event types | event types, calendar classification | List all event types ... | Returns list of event types | Returns: List of ...'), a pipe-delimited keyword dump rather than front-loaded prose. None of the repetitions adds 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 values need no explanation, and the zero-parameter surface is simple. But the absence of any differentiation from the many sibling type/category/metadata lookups leaves a real gap in a crowded namespace.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate. No parameter-level information is expected or missing.

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 clear verb and resource: it lists the event types used in the parliamentary calendar. However, it never distinguishes itself from close siblings such as get_calendar_categories, get_calendar_tags, or especially get_event_type_metadata, so an agent cannot tell from this text which of the four to call.

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 at all — no prerequisites, no statement of when to prefer this over get_event_type_metadata or get_calendar_categories. The repeated keyword phrases ('event types, calendar classification') read as search optimization rather than usage instruction.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the response shape and that it is a read-only reference ('Returns JSON with command groups, names, descriptions, and parameters'), which is useful. It omits any note on pagination, rate limits, or auth, though for a static reference tool the risk is low.

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 leading pipe-separated keyword string ('cli commands, terminal, command line, parliament command') is keyword-stuffed filler, and the return-shape sentence is duplicated between the top line and the 'Returns' block. The Args section is efficient, but the overall payload has 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, return values needn't be spelled out, yet the description still summarizes them. Both optional parameters are documented with defaults and examples, making it complete enough for an agent to call 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 0%, so the description must compensate, and it does: 'group' is explained as a filter with concrete examples ('members', 'bills', 'votes') plus the default behavior when omitted, and 'search' is defined as a keyword match across command names and descriptions. This meaningfully exceeds the bare 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 clear verb+resource: 'Get comprehensive CLI command reference' with explicit scope ('CLI commands... in the parliament command-line tool'). It distinguishes itself conceptually from the MCP data tools it complements, though it never names a specific sibling (e.g. parliament_guide) to route the agent.

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 to discover available CLI commands and their parameters' gives an implied use case, and 'complementing the MCP tools' hints at when it is relevant. However, it never states when NOT to use it or how it differs from related meta-tools like parliament_guide or parliament_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?

With no annotations, the description carries the full burden and does well: it discloses ordering ('newest first'), the matched-by mechanism ('committee link or title'), that the bill's current stage is included, and that the result is a composite ('Combines: get_committee_by_id, get_committee_business, get_committee_business_by_id, get_bill_by_id'). It does not mention permissions, rate limits, or failure behavior for an unknown committee_id.

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 pipe-delimited preamble is front-loaded and dense, then Args/Returns are cleanly separated; nearly every clause adds routing or parameter value. Minor waste in the 'Returns:' line, which largely restates what the output schema already conveys.

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 0% schema description coverage, the description documents both parameters with sources and constraints, explains the return shape's ordering and matching semantics, and names the composed sub-tools. With an output schema present, no further explanation of return values is required, so nothing an agent needs 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 0%, so the description must compensate fully, and it does: committee_id is explained with a source ('Get from search_committees or get_committee_summary') and a concrete example ('172 (Lords Constitution Committee)'), and take is explained with both a default and a cap ('default 10, max 20') — the max is not 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?

States a specific verb and resource ('Find the bills a committee has examined') and immediately scopes what is returned (legislative-scrutiny business, not all committee business). It explicitly differentiates itself from siblings by naming get_bill_committees as 'the reverse' and pointing to get_committee_summary, so an agent can route without opening any schema.

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

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

Gives an explicit trigger ('Use when asked which bills a committee has looked at') plus two named alternatives with their relationship ('get_bill_committees (the reverse)', 'get_committee_summary'). The when-to-use condition and the alternative-selection logic are both present.

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

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

No annotations exist, so the description carries the full behavioral burden. It usefully discloses pagination controls and limits (skip, take, default 30, max 100), but never states that this is a read-only operation, nor any auth needs or result-count constraints. It partially compensates but leaves the safety profile implicit in the word 'Search'.

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 a pipe-delimited keyword line, then usage, siblings, args, and returns. Mostly every element earns its place, but the return statement is duplicated verbatim ('Returns committee business items matching the criteria' appears in both the body and the Returns block), and the keyword pipe line reads as search-engine padding.

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

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

For a 10-parameter, annotation-free search tool, the description covers purpose, usage, sibling routing, and every parameter, and an output schema exists so return-shape detail is not required. The main residual gap is the absence of any read-only/permission framing, but overall it is sufficient to call the tool correctly.

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

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

Schema description coverage is 0%, so the description must document all ten parameters — and it does, in a structured Args block. It adds real meaning beyond the schema: 'YYYY-MM-DD format' for dates, take default/max, status examples ('Open', 'Closed'), and the provenance of business_type_id ('from get_committee_business_types'). A few entries (e.g. show_on_website_only) stay thin, keeping it from a 5.

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

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

States a specific verb and resource — 'Search for committee business (inquiries, investigations)' — with a clarifying parenthetical. It explicitly names siblings ('See also: get_committee_business_by_id, get_bill_committees'), which helps an agent separate list/search from single-item lookup, though it doesn't spell out the exact boundary condition with each.

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 a concrete use case — 'Use to find committee inquiries by topic, status, or whether accepting evidence' — which maps directly onto search_term, status, and currently_accepting_evidence. No explicit when-not guidance or negative routing is provided, so it stops short of a 5.

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

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

No annotations are present, so the description carries the full burden. It does disclose the return composition ('evidence calls and reports'), which is useful, but says nothing about authorization requirements, behavior on an invalid/unknown business_id, or rate limits. Notably it never mentions that show_on_website_only defaults to true, a behaviorally significant filter.

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

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

Front-loaded with purpose, then usage, then alternatives, then params. The only soft spot is the trailing 'Returns: Detailed information about the committee business', which largely restates the opening, but the definition is still tight overall.

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 enumerated, and the description correctly avoids that. For a two-parameter read tool with one required ID this is largely sufficient, with the main gap being the undocumented default filtering behavior of show_on_website_only.

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 compensate, and it does define both parameters in plain language ('Committee business ID', 'Show only items visible on website'). However it adds no format, type, or edge-case meaning (e.g. that the boolean defaults to true and thereby filters results by default).

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 ('Get detailed information about a specific committee business item') and narrows scope with 'inquiry details, investigation details', which separates it from the plural listing sibling get_committee_business. It is clear what it does, though 'committee business item' itself is a domain term the description never defines.

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 condition: 'Use when you need complete details about a specific inquiry or investigation,' and it names two siblings under 'See also'. It gives when-to-use but no when-not-to-use or routing rule for choosing among those alternatives.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return shape ("publication groups with counts", "grouped by type"), which is genuine behavioral context, but says nothing about permissions, pagination, or whether it is a pure read. For a no-annotation tool this is adequate but not rich.

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

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

The purpose is front-loaded, which is good, but the pipe-delimited keyword run ("inquiry publications, report groups") duplicates what the surrounding sentences already say. The Args/Returns block is boilerplate that partly repeats the opening line.

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

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

The tool is simple (one required integer parameter) and an output schema exists, so the description need not explain return values in depth. It covers purpose, parameter meaning, and the shape of the result, which is enough for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It only restates the schema label as "Committee business ID," adding no format, provenance, or lookup guidance. It is not wrong, just minimal for a single required parameter.

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

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

States a specific verb and resource ("Get publication summary for an inquiry") and scopes it to a committee business/inquiry rather than a whole committee. It does not name the near-identical sibling get_committee_publications_summary, so the agent must infer the difference from the phrase "for a committee business/inquiry."

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 to see publication types for a committee business/inquiry" gives an implied when-to-use, but there are no exclusions and no named alternatives. With siblings like get_committee_publications_summary and get_committee_publication_types in the set, the description should have said when to pick this one over them.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that the result is a list of business types with descriptions, and 'Get' clearly implies a read-only lookup, but it does not state that this is a static reference enumeration or note anything about caching/completeness.

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 header is front-loaded and useful, but 'Returns list of business types with descriptions' and 'Returns: All committee business types with descriptions' say the same thing twice, adding redundancy with no 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?

For a zero-parameter lookup tool with an output schema already present, the description covers what is needed. Since the output schema exists, the repeated return-value sentences are unnecessary rather than missing information.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a no-param tool is 4.

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

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

States a specific verb and resource ('Get all types of committee business') and names the concrete examples (inquiries, debates) it enumerates. However, it does not distinguish itself from the similarly named sibling get_committee_types (types of committees) or get_committee_business, so an agent could plausibly confuse them.

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 to understand different types of committee work' gives an implied purpose but names no alternatives and no conditions for when-not to use it. With get_committee_types and get_committee_business in the sibling list, the absence of routing guidance is a real gap.

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

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

With no annotations, the description carries the full burden and does reasonably well: it discloses the returned payload ('purpose, members, departments scrutinized, and contact information'), warns that include_banners 'May increase response size', and notes the public-only default. It says nothing about permissions, behavior on an invalid/nonexistent committee_id, or error cases, which a zero-annotation tool ideally would cover.

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 Args/Returns structure is clean and front-loaded, but the keyword-list sentence is pure redundancy with the surrounding text and adds no information for an agent. Removing that clause would lose nothing, so the definition is not tight.

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 the Returns restatement is harmless redundancy rather than a gap. Parameters, defaults, prerequisites, and sibling routing are all covered, giving an agent enough to call the tool correctly. Only the absence of any exclusion criteria or failure-mode guidance keeps it from 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 description must compensate and it does: committee_id is marked required with an example (739) and instructions to obtain it from committee search first; include_banners is given its default (false) and the consequence of enabling it; show_on_website_only is given its default (true) plus a usage recommendation. All three parameters carry semantics absent from 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 ('Get comprehensive committee profile and membership details') and names sibling tools (get_committee_summary, get_committee_members, get_committee_bills) so the agent can see it is not the summary or members-only variant. However the keyword-stuffed pipe segment ('committee information, committee members, committee purpose, parliamentary committee, scrutiny committee') muddies rather than sharpens the purpose, and the siblings are listed as links rather than differentiated.

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 use contexts ('understanding committee roles, finding committee members, or researching committee activities') and a prerequisite for the required param ('get from committee search first'). It also advises show_on_website_only is 'Recommended for general use'. No explicit when-not-this-tool condition is given, so it stops short of 5.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses pagination controls (skip, take default 30, max 100) and implies a read-only operation via 'Get', but says nothing about permissions, error behavior on an invalid committee_id, or how the start_date vs end_date filters differ semantically.

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 and usage cue are front-loaded in the first sentence, and the Args block is long only because 14 parameters must be documented from zero schema coverage, so each line earns its place. The 'Returns' line is slightly redundant given an output schema exists but is one sentence.

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

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

For a 14-parameter, no-annotation tool with an output schema, the definition covers purpose, filtering options, pagination and defaults, which is enough to call it correctly. It lacks any disambiguation from the heavily overlapping committee-event siblings, which is the remaining gap.

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

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

Schema description coverage is 0%, so the description is the only source of parameter meaning, and it documents all 14 arguments including the YYYY-MM-DD date format and the max-100 pagination cap, which the schema omits. Some entries are thin or restate the name ('Optional: filter by committee business ID'), keeping it from a 5.

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

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

States a specific verb and resource ('Get events') scoped to 'a specific committee by committee ID', which distinguishes it from the broad get_events sibling. It does not name any alternative sibling (get_events, get_committee_meetings, get_committees_next_events) that an agent must choose between, 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?

The sentence 'Use when you want to see all meetings and activities for a particular committee' gives a clear usage context, but there is no when-not guidance and no routing against the many overlapping committee/event siblings. The agent is left to infer that this is the per-committee variant of get_events.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses scope (Commons and Lords) and return content, and adds a validation rule ('to_date must be after start date'), but says nothing about pagination, result limits, sorting, or read-only nature. Useful context, but not the rich disclosure an un-annotated query tool warrants.

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 is front-loaded, but the pipe-separated keyword block ('committee meetings, parliamentary hearings, committee schedule, committee calendar, when committees meet') is SEO filler, and the return sentence is duplicated verbatim in the Args/Returns section. Some trimming would sharpen 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 spelled out. The description covers purpose, scope, parameters, and validation, which is close to complete for a two-param date-range query; only pagination/limit behavior 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 0% (properties carry only titles), so the description must compensate, and it does: it specifies the YYYY-MM-DD format with a worked example for from_date and the ordering constraint for to_date. This meaningfully exceeds the bare 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 ('Find committee meetings and hearings by date range') and explicitly scopes coverage to both Commons and Lords committees. The 'See also' pointer to get_events and get_committees_next_events lets an agent separate it from closely-named siblings without opening a schema.

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

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

Gives concrete use cases ('finding committee schedules, planning attendance, or researching past committee activity') and names two alternative tools. However, it never states when NOT to use this tool or the routing condition that selects get_committee_events vs get_events, so the alternatives are listed rather than explained.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that both elected and lay members are returned, that membership status can be current or former, and that take defaults to 30 with a max of 100. It never states that the operation is read-only or mentions permission/auth requirements, so it is adequate but incomplete.

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 Args block is front-loaded and each parameter line earns its place, making the docstring scannable. The 'Returns: Members and staff of the committee' line is redundant given the tool has an output schema and merely restates the opening sentence.

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 5-parameter filtered getter with an output schema (so return shape needs no explanation) and no annotations, the description covers the filters, pagination, and population returned. The main omissions are the absence of any read-only assertion and any routing guidance against sibling member-listing tools.

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 compensate, and it largely does: all five parameters are documented, including examples for membership_status ('Current', 'Former'), the pagination role of skip, and the default (30) and ceiling (100) for take. It does not restate the default value of show_on_website_only, though that is 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?

States a specific verb and resource: 'Get members and staff of a specific committee by committee ID.' It also scopes the output (elected members plus lay members, roles, current/former status). It does not differentiate from close siblings such as get_committee_staff or get_member_committee_memberships, which an agent could easily confuse it with.

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 when you need to know who serves on a committee, their roles, and membership status' gives implied usage context, which is better than nothing. However, it names no alternative tool and gives no exclusion conditions, even though get_committee_staff and get_member_committee_memberships overlap in scope.

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

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

No annotations exist, so the description carries the burden; it does disclose that the output is aggregated counts grouped by type rather than raw records, which is useful behavioral context. It says nothing about scope limits, permissions, or whether the counts are scoped to a time period, leaving notable gaps for an unannotated 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 scoping sentence is front-loaded, but the description is redundant: the opening clause already says the result is grouped by type, and the trailing 'Returns: Summary of publications grouped by type' repeats it verbatim. The Args/Returns scaffolding adds length without 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 one-parameter read-only aggregation tool with an output schema present, the description tells the agent what it returns and when to use it, so return-value explanation is legitimately omitted. The only meaningful gap is differentiation from the sibling publications-summary tools.

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%, but there is only one required parameter and the description's 'committee_id: Committee ID' merely restates the schema title. No identifier format, source, or lookup hint is added, though the parameter is largely self-evident from its name.

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

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

The description names a specific verb and resource ('Get summary of publications grouped by type') and states that it returns publication counts by type, so an agent can tell it apart from generic list tools. It does not, however, distinguish itself from the near-identical sibling get_committee_business_publications_summary, which is a real ambiguity in this tool set.

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 to get an overview of a committee's publication output' implies the usage context but gives no when-not guidance, prerequisites, or a named alternative. With get_committee_business_publications_summary and get_publications available, the agent must guess which one to pick.

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

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

No annotations are provided, so the description carries the burden, but this is a zero-parameter read-only lookup tool, so the risk profile is inherently trivial. The description confirms it returns a list with descriptions, though it says nothing about pagination or whether the taxonomy is static or mutable—minor gaps for a reference endpoint.

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

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

Front-loaded with the core purpose, but the closing sentence 'Returns list of publication types with descriptions' is immediately restated as 'Returns: All committee publication types with descriptions,' which is pure duplication in an already very short description.

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

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

An output schema exists, so return values need not be spelled out. For a simple enumerated lookup the description is sufficient to call the tool correctly; the main missing element is disambiguation from the many sibling '*_types' endpoints.

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 schema coverage is moot and the baseline of 4 applies. The description correctly identifies the returned fields (types with descriptions), which is the only semantic content available.

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: getting all types of committee publications, and clarifies the scope with 'report types, document types'. It does not, however, distinguish itself from near-name siblings like get_publication_types or get_committee_business_types, so an agent must infer the difference from the word 'committee' 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?

The only guidance is 'Use to understand different types of committee publications,' which restates the purpose rather than saying when to call this versus get_publication_types or get_committee_business_types. No prerequisites, no exclusions, no alternative routing.

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

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

No annotations are provided, so the description carries the burden. It discloses useful operational facts — defaults of today for event_from_date and 30 for take — but says nothing about pagination semantics, ordering, or permissions. It is a read tool, but that is inferred rather than stated.

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 summary before the Args/Returns detail, and each parameter gets one tight line. The 'Returns list of committees with their next scheduled event' statement is duplicated verbatim in the header and the Returns block, a minor redundancy.

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

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

With an output schema present, the description need not explain return values, and it covers all four parameters with formats and defaults. It is nearly complete; only the absence of sibling differentiation and pagination detail keeps it from 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 description must compensate, and it largely does: it gives the accepted values for house (1/'Commons', 2/'Lords'), the date format for event_from_date, and the meaning of skip/take with a default. This adds substantial meaning beyond the bare schema, though it doesn't clarify pagination interaction between skip and take.

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

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

States a specific verb and resource ('Get upcoming events for all committees') and clarifies the payload ('next meetings, upcoming hearings'). It does not explicitly distinguish itself from the closely named sibling get_committee_events, so it falls short of a 5.

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

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

'Use to see what committee meetings are scheduled' implies context but gives no when-not guidance and never names the alternative tools (get_committee_events, get_events, get_committee_meetings) an agent would need to choose correctly among. Usage is implied rather than directed.

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

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

No annotations are provided, so the description carries the full burden. It does disclose meaningful behavioral detail beyond the schema: the default of 30 records for take, pagination via skip/take, and that show_on_website_only filters to publicly visible staff by default. It does not state read-only nature, permission requirements, or error behavior for an invalid committee_id, which is a gap for a zero-annotation 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?

Well front-loaded: purpose and keyword line first, then Args, then Returns. There is some redundancy between the keyword line, 'Returns staff members with their roles,' and 'Staff members of the committee,' which could be trimmed, but the structure is easy to scan.

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