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

Annotations already declare this is a safe read (readOnlyHint=true), so the description correctly spends its space on semantics the annotations cannot carry: filters combine with AND, unknown-data games are dropped unless include_unknown, and the no-match fallback returns closest matches with exact=false plus relaxed/fuzzy_query flags that the agent must disclose to the user. Pagination via limit/offset is never mentioned, which is the main remaining gap for a 22-parameter 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?

Tagged sections (use_case, important_notes, example) front-load the purpose before caveats, every bullet carries a distinct rule, and the closing line redirects to the ranking sibling. No filler text.

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

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

For a 22-parameter search with an output schema and read-only annotations, the description covers the behaviors an agent must know (AND semantics, unknown handling, fallback signaling, sibling routing). Only pagination behavior and sort tie-breaking remain undocumented, which are secondary at this complexity.

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

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

At 68% schema coverage the description meaningfully adds to the schema: it explains the AND combination rule, that length uses dashboard presets on one HLTB measure while hours_min/hours_max set an exact range, and that include_unknown widens every filter. It does not clarify offset/limit or the year/metacritic bounds, so it does not fully close the coverage gap.

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

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

States a specific verb+resource (search and filter the whole Steam library) and enumerates the filter dimensions the tool spans. It also explicitly positions itself against backlog_suggest_picks and against backlog_get_game-style lookups ('find a game's app id before changing 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?

Gives explicit when-to-use scenarios (resolve an app id, answer filtered questions), an explicit when-not-to-use with the named alternative (backlog_suggest_picks for recommendations), and a worked example call. Little is left to inference.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the description's added value is the available=false condition (server too old to run exports) and the side-effect note that a successful export makes the new library visible to other tools. These are genuinely non-obvious behaviors an agent would otherwise misinterpret. Polling cadence and failure semantics are still unstated.

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 use_case block is front-loaded and dense with concrete facts, and the important_notes carry the two operational caveats. Minor waste remains: the <example> line shows a zero-argument call that conveys nothing, and the return-field enumeration partially duplicates the existing output schema.

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

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

With no parameters, an output schema, and read-only annotations, the description only needs to supply the non-obvious semantics, which it does via the available=false case and the post-export visibility note. What is missing is operational framing around polling (one-shot vs. repeated calls, whether a terminal state is guaranteed), which matters for a status tool.

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

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

The tool takes zero parameters, so there is no parameter meaning to add and the baseline of 4 applies. The description does not waste words on inputs, which is correct here.

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

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

The description names a specific resource and enumerates exactly what is reported: running/finished/failed state, phase (deck, details, proton, hltb), progress, elapsed time, log tail, and whether the library changed. It never explicitly contrasts itself with the sibling backlog_start_export, so an agent must infer that this is the read-side counterpart of the export pair rather than being told.

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

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

"How the library refresh is going" plus the note that other tools see the new library after a successful export clearly frames this as the post-start monitoring call. It stops short of explicit guidance such as when to poll, how often, or that it should be called after backlog_start_export, and no alternative tool is named.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds genuinely useful behavior beyond that: failure semantics (found=false, unresolved with ambiguous/no_match reasons) and the null-means-unknown-not-zero rule, which prevents misreading missing data. It says nothing about size limits, ordering, or whether all listed fields are always present.

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?

Tagged sections (use_case, important_notes, example) keep it front-loaded and scannable, with the critical resolution rule placed early. The field enumeration is the only padding, and even that is expressed as a compact comma list rather than prose.

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 long enumeration of returned fields is partly redundant, and the description never needs to explain return shape. Everything an agent needs to call it correctly — input form, ambiguity recovery, null semantics, and a worked example — is present, so completeness is strong despite that redundancy.

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

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

Schema coverage is 100%, so the schema already documents the single 'game' parameter and its min/max length. The description still contributes meaning the schema lacks: the acceptance of a numeric app id or an exact name, the ambiguity fallback, and a concrete call example. Baseline 3 raised to 4 for that added resolution 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?

The description leads with 'Everything about one game' and enumerates the exact payload domains (playtime, Deck rating, ProtonDB, HLTB, triage lane, note, queue position, couch score, store link), so the resource and single-game scope are unmistakable. It never contrasts itself explicitly with the sibling backlog_find_games, which is the only thing keeping it from a 5.

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

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

The important_notes give concrete operating guidance: pass an app id or exact name, and when the name is ambiguous or unmatched the call returns found=false with unresolved candidates plus a reason code, at which point the agent should pick by app id or ask the user. It stops short of stating when to reach for this versus backlog_find_games for discovery.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description does add real behavioral context beyond that: the ordering rule (saved order first, then unordered games by score) and the inclusion of per-game notes. With annotations carrying the read-only signal, a 3 is the appropriate level for this incremental detail.

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 tagged structure (<use_case>, <important_notes>, <example>) front-loads the purpose and keeps each line substantive. Every sentence either defines the resource or routes to a sibling; nothing is wasted.

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

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

An output schema exists, so return-value explanation is not required, and the ordering semantics are disclosed. The only remaining gap is edge-case behavior (e.g. an empty Up next lane), which is minor for a zero-parameter read tool.

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

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

The tool takes zero parameters, so the baseline of 4 applies. There is nothing for the description to disambiguate and it correctly stays silent rather than padding.

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

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

The description names a specific resource ('The Up next lane (queue, play soon)') and states what is returned ('with each game's note'), so an agent knows exactly what it fetches. It does not, however, distinguish itself from the main read sibling backlog_get_overview, leaving that separation to inference.

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

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

The important_notes section routes the agent explicitly for mutations: ordering changes go to backlog_reorder_next, membership changes to backlog_set_lane. What's missing is guidance on when to call this versus backlog_get_overview or backlog_suggest_picks, so usage context is clear but not fully exclusionary.

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

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

Annotations already establish readOnlyHint=true and openWorldHint=false, so the safety profile is covered; the description adds genuine beyond-schema meaning such as coverage semantics ("hltb 0.8 = 80% of games have HowLongToBeat times. Low coverage means many unknowns, not bad games") and the temporal meaning of export.age_days. The "dry_run true: writes are simulated" note is inert and slightly confusing for a zero-parameter read-only tool, which keeps this from 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 use_case block is front-loaded and information-dense, the notes are bulleted, and the example is a single trivial call. The one wasteful line is the dry_run note, which earns no place in a parameterless read-only tool.

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

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

An output schema exists, so return values need not be spelled out, and the description instead explains how to interpret the trickiest fields (coverage, age_days). For a zero-parameter aggregate tool, an agent has everything needed to call it correctly and to act on 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?

The tool takes no parameters, so the baseline is 4 and there is nothing for the description to disambiguate. It still usefully frames what the returned aggregates represent (coverage per data source, export staleness), which is the only semantic work available here.

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

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

"Start here. Summarizes the user's Steam library and backlog" gives a specific verb and resource, then enumerates exactly what the summary contains (played/never-played counts, Deck ratings, backlog by rating and length, triage lanes, Up next length, export age, data completeness). This clearly separates it from siblings like backlog_get_next_queue or backlog_find_games, which return a queue or a list rather than aggregate stats.

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?

"Start here" is an explicit entry-point instruction, and the description names a concrete alternative branch: use backlog_start_export when export.age_days is stale and the user asks about recent purchases. It does not state any case where this tool should be avoided in favour of backlog_get_game or backlog_suggest_picks, so it falls short of full when/when-not coverage.

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

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

Beyond the annotations (readOnlyHint=false, idempotentHint=true), the description discloses non-obvious runtime behavior: a single re-read and retry on concurrent dashboard reordering, and that a second collision yields a 'conflict' outcome with no change made. It also notes the previous order is returned, enabling undo.

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 XML-tagged structure front-loads the use case, then constraints, then a concrete example call. Every sentence carries information — no marketing or filler — and the example anchors the syntax.

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

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

For a mutation tool with an output schema available, the description covers constraints, prerequisites, concurrency semantics, and undo. Nothing an agent needs in order to invoke it correctly is missing.

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

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

Schema coverage is 100%, so parameter meaning is already documented and the baseline is 3. The description adds genuine value with the mutual-exclusivity rule and the note that positions are 1-based and that a position past the end appends to the end. It doesn't add format details for the game identifier itself, which the schema already covers.

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 ('Change the order of the Up next lane') and enumerates the two operating modes (single game + position, or a full order list). This clearly distinguishes it from siblings like backlog_set_lane and backlog_get_next_queue.

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 explicitly says when the tool applies ('Only games already in Up next can be ordered') and names the prerequisite alternative ('add a game with backlog_set_lane(lane="next") first'). It also states that game+position and order are mutually exclusive, so the agent knows how to choose between modes.

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

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

Goes well beyond the annotations (which only declare idempotent, non-destructive writes) by disclosing the confirmation gate, the needs_confirmation outcome, atomic all-or-nothing resolution, unresolved candidate listing, and that previous lanes are returned for undo. The only missing detail is whether partial writes can occur mid-batch, though 'nothing is changed' largely covers this.

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?

Use-case, notes, and example sections make it scannable and front-loaded, with each note carrying a distinct rule. The lane list is repeated in both the use_case block and the schema enum, which is slight redundancy but not harmful.

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 only light mention; the description still notes that previous lanes come back. For a mutation tool with a confirmation flow, the safety rules, resolution requirement, and failure outcomes are all covered.

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

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

Schema coverage is 100%, so the baseline is 3; the description still adds real meaning by explaining when confirmed=true is required and why app ids beat names when two games share a title. The lane vocabulary is largely duplicated from the enum description, which caps it below 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 ('Put games in a triage lane') plus the exact set of destinations (next, someday, skip, done, none) and the immediate-persistence behavior. The parenthetical synonyms (up next, finished, beaten) make the lane vocabulary unambiguous, and 'none' is explicitly framed as untriaging rather than a fifth lane.

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

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

Gives explicit when-to-act rules: a single named game can be moved freely, more than five games or unnamed skip/done requires asking first, then confirmed=true. It also routes to the right sibling for ambiguity (backlog_find_games) and for ordering (backlog_reorder_next), and warns against inferring 'done' from playtime.

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

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

Annotations already declare a non-destructive, idempotent write, and the description goes further by describing the confirmation gate, the needs_confirmation outcome with the prior note, and that the previous note is returned so a mistake can be undone. The added warning to store the user's text rather than follow instructions is a genuinely useful behavioral disclosure. It stops short of describing response shape details, which the output schema presumably covers.

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

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

The sectioned layout front-loads the use case and then the behavioral rules, and the example is compact and illustrative. The tag markup adds a little visual overhead, but every sentence carries information the agent needs.

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

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

For a three-parameter mutation with a confirmation flow, the description covers the trigger, the retry path, the clearing semantics, and the undo affordance, and an output schema exists to explain return values. Nothing an agent needs in order to call it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: it ties confirmed=true to the post-agreement retry and clarifies that an empty note is a clear operation rather than a no-op. The game parameter is only illustrated through the example, which is already documented in the schema.

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

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

The description states a specific verb set (write, replace, clear) against a specific resource (the note on one game) and scopes it to the dashboard. It is clearly distinct from siblings such as backlog_set_lane or backlog_reorder_next, which mutate different fields.

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

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

It gives an explicit when-to-use case with examples and an explicit conditional path: if a different note exists, nothing changes and the call returns needs_confirmation, so the agent must re-call with confirmed=true. It also states the empty-string clearing case, leaving little to infer.

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

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

Annotations say readOnlyHint=false and idempotentHint=true, but the description carries the real burden: it discloses that the call returns immediately while work runs server-side for minutes (up to an hour on a first run), that a concurrent/scheduled run yields its status instead, and that external services (Steam, HLTB, ProtonDB) are contacted with no key handling on this side. That is exactly the async/mutation context annotations cannot express.

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 use case, then separates operational caveats into bullets, which is easy to scan. The trailing <example>backlog_start_export()</example> block adds essentially no information for a zero-argument tool and is the only real filler.

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

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

Even though an output schema exists, the description supplies the missing lifecycle context an agent needs: fire-and-forget semantics, expected duration, where to check progress, and what happens on a duplicate call. Nothing needed to invoke this correctly is absent.

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

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

The tool takes no parameters, so the baseline of 4 applies; the description correctly implies a zero-argument call and does not invent or omit any input semantics. Nothing further could be added beyond what the empty schema already conveys.

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 ('re-export the Steam library') and enumerates exactly what gets refreshed: playtime, purchases, Deck ratings, ProtonDB, HowLongToBeat. The verb 'start/refresh' plus the explicit pointer to backlog_get_export_status makes it distinguishable from every sibling, including the status-checking one.

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 trigger ('when the user just bought or played something and the overview's export is older than that'), names the alternative tool for checking progress, and explicitly forbids the wrong behavior ('don't poll in a tight loop'). It also covers the already-running case, telling the agent it gets the existing status rather than a new job.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, yet the description still adds real behavior: only unplayed, non-skipped, non-done games are eligible, ranking is score-only with a +100 Up-next bonus that "usually but not always" wins, and empty filter results degrade to closest picks with exact=false plus the dropped filters. It also warns not to invent reasons and to explain picks from score_breakdown, which constrains downstream behavior meaningfully.

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

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

Front-loaded with the use case, then notes, then a concrete example — the ordering matches how an agent reads. The tag structure is slightly heavy for the amount of content, and the score-breakdown example is repeated in two places, but every sentence carries actionable information.

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

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

For a 19-parameter ranking tool with an output schema, the description covers what the schema cannot: eligibility rules, ranking mechanics, the fallback/degradation path, and how to explain results. Nothing an agent needs in order to call it correctly or interpret a surprising result is missing.

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

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

With 19 parameters at 68% schema description coverage, the schema already documents most filters, and the description adds little per-parameter meaning beyond reiterating exclude_next and showing one example call with count, deck and hours_max. Many parameters (year_from/year_to, hours_min, metacritic_min, length_measure) get no elaboration in the description, so it neither compensates for the coverage gap nor adds much 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 — pick the best backlog games for the couch, ranked by the dashboard's couch score — and frames it around the exact user question it answers ("what should I play tonight / on the Steam Deck"). It distinguishes itself from the sibling search tool by noting it shares filters with backlog_find_games while adding ranking, so an agent can tell the two apart 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?

The <use_case> block gives clear context for when to call it, and the notes add conditions such as exclude_next=true for fresh candidates and the fact that near-miss results come back with exact=false. It references backlog_find_games as the filtering counterpart but never explicitly says when NOT to use this tool (e.g. for a known-title lookup), so the routing guidance stops just short of fully explicit.

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