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

Annotations already declare non-read-only, open-world, idempotent, non-destructive, but the description adds the operationally critical details those hints omit: no card charge occurs, the URL must be shared privately, idempotency applies to requestId reuse, and renewal behavior differs by offer type. This is exactly the context an agent needs to avoid duplicate or leaked checkouts.

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?

Five tight sentences, purpose front-loaded, followed by the payment-safety caveat, retry rule, and offer semantics in descending order of importance. No filler or restatement of the name.

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

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

An output schema exists, so return shapes need not be spelled out, yet the description still signals that a checkoutUrl is produced. For a three-parameter, open-world mutation the description covers permissions, side-effect boundaries, idempotency and renewal behavior.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: months is bounded 1–12 and scoped to Pro/Studio passes, annual offers are recurring, requestId reuse semantics are stated. It stops short of explaining the requestId pattern or enumerating which offerId values are monthly vs annual, leaving a small 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 ('Create a private Stripe checkout') plus the trigger condition ('after the user expresses purchase intent'). An agent can distinguish it from siblings like get_checkout and create_scoreboard 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?

Explicit about when to use (user expresses purchase intent), when the tool is not sufficient (does not charge a card — hand checkoutUrl to the buyer), and the retry policy (reuse exact requestId/input, never create a replacement checkout). It also names the prerequisite scope 'billing:checkout'.

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 idempotency and non-destructiveness, yet the description adds material context: no money moves, separate authorization is required, the memo must be included, and duplicate payment must be avoided. This is exactly the safety-critical nuance 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?

Four tight sentences, front-loaded with the gating precondition, then outputs, scope, and safety constraints. No sentence is redundant and nothing is buried mid-paragraph.

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

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

With an output schema present, the description needn't enumerate return fields, and it summarizes them anyway. Preconditions, scope limits, idempotency contract, and the post-call authorization step are all covered, leaving no gap for an agent to 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 coverage is 0%, so the description must carry the load, and it does: it names the three offerId values, constrains months to 1–12 calendar months, and explains requestId's role as an idempotency key to be reused verbatim on retry. It stops short of restating requestId's charset/length constraints, but the semantic intent is fully conveyed.

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 ('Prepare an owner-bound one-time payment order') plus the exact artifacts it returns (recipient, USD amount, unique memo). The explicit 'This tool sends no money' clause distinguishes it from any sibling that would execute a transaction, such as create_checkout.

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 precise trigger ('after purchase intent, only when get_service_info pricing.paymentMethods.stripe_cli_pay.available is true'), an exclusion ('never annual subscriptions'), and retry/routing guidance ('Separately obtain authorization for the actual Stripe transfer'). An agent knows both when to call it and when not to.

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

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

Adds substantial context beyond the annotations: the board is publicly shareable, title and team names become public, free boards cap spectators at 50 views and show branding, and the identical requestId plus input should be retried after a timeout. That retry guidance directly operationalizes the idempotentHint in a way annotations alone cannot.

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

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

Three dense sentences, front-loaded with what the tool produces, then the intent precondition, then the visibility/limit caveats and the retry rule. No filler sentences.

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 public mutation with an output schema and rich annotations, the description covers the important unknowns: visibility of inputs, free-tier limits, and idempotent retry behavior. Ownership or what a duplicate board creation returns is not addressed, a minor 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?

With 0% schema description coverage, the description carries the load and does so meaningfully: it explains that title and team names are publicly visible and that requestId must be reused identically on retry. It does not cover the requestId pattern or the exactly-two-teams constraint, which remain discoverable only 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 ('Create a public, shareable two-team scoreboard'), which cleanly distinguishes it from get_scoreboard, list_scoreboards, update_scoreboard, and hand_off_scoreboard. The trailing fragment 'at zero' is unclear but does not obscure the core action.

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

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

Gives an explicit precondition ('Requires explicit user intent to create'), which tells the agent when this tool is appropriate rather than a read or update. It does not explicitly name a sibling alternative for modification scenarios, 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?

Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds two things annotations cannot express: the required billing:read permission and the privacy boundary (no personal or payment details returned). It does not say what happens on a missing permission, which costs it the top score.

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

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

Three short sentences: what it reads, when to call it, and the permission/privacy constraints. Front-loaded with the resource and field list, zero 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?

There is no output schema, so the description carries the burden of describing the return, and it does so at a field-category level (plan, expiry, capacity, permissions) plus an explicit exclusion. Exact response shape is unstated, a minor gap for a read tool with no inputs.

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 is 4. The description wastes no effort inventing parameter guidance and instead spends its words on scope and permissions.

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 (read the connected account) and enumerates exactly which fields are returned: plan, expiry, board capacity, permissions. This is clearly distinguishable from the sibling tools, which all concern scoreboards and checkouts rather than account/billing state.

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?

"Call before offering a paid upgrade" gives an explicit triggering condition, which is more than most definitions offer. It stops short of naming alternatives or a when-not case, but for a zero-parameter read there is little else to route against.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds genuinely new behavior context: the 15-second polling constraint, the fact that webhook-granted access is confirmed only by fulfillmentStatus=fulfilled, and that paid/completed alone is insufficient. That is exactly the kind of status-semantics detail annotations cannot convey.

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

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

Four short sentences, front-loaded with the action and resource, followed by the two decisive constraints and the return instruction. No sentence is filler.

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

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

An output schema exists, so return-value detail is unnecessary; the description still supplies the polling cadence, the access-granting status rule, and the id's origin. For a single-parameter read tool that is complete.

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

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

With one parameter and 0% schema description coverage, the description adds useful meaning by saying the id is 'returned' and 'opaque', implying it comes from create_checkout. However, it does not explain the 64-character hex format enforced by the schema pattern, so it only partially compensates for the coverage gap.

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

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

States a specific verb (read) and resource (checkout) scoped to the connected account, and clarifies it takes the opaque id returned at creation. The read-vs-create distinction from the sibling create_checkout is obvious from the wording.

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 operational guidance: poll no more often than every 15 seconds, treat only fulfillmentStatus=fulfilled as access granted, and return to the scoreboard task afterward. It does not explicitly name when to avoid calling it, but the conditions are clear enough to act on.

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?

Despite being named 'get', it discloses that the call may activate access — consistent with readOnlyHint=false — and defines the single authoritative success signal (fulfillmentStatus=fulfilled), explicitly rejecting proxies like CLI output or sender status. It adds latency expectations (business days), rate-limit behavior (pollAfterSeconds >= 60), and failure-state handling, all beyond what the annotations convey.

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

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

The purpose is front-loaded in the first sentence and the remaining sentences are dense operational constraints rather than filler. It is longer than typical but nearly every clause carries a distinct rule (confirmation signal, poll interval, latency, pending/review handling), so little could be cut without losing guidance.

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 annotations covering the safety profile and an output schema covering return values, the description fills exactly the gaps that matter: side effects, authoritative success criteria, latency, polling limits, and terminal-state routing. Nothing an agent needs to call it correctly is missing.

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

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

There is one parameter (id) with 0% schema description coverage; the description implies it identifies the connected account's payment order but does not explain the 64-hex-character format, which only the regex pattern communicates. The mentions of fulfillmentStatus and pollAfterSeconds describe response fields, not the input, so they do not compensate for the parameter 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 opens with a specific verb and resource — 'Check ... the connected account's payment order' — and an explicit scope limit ('only the connected account's'), plus the secondary effect of reconciling a bank receipt. An agent can distinguish this from create_payment_order or get_checkout without opening any schema.

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

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

It states the conditions that forbid action ('Never send a replacement payment while pending') and routes abnormal states elsewhere ('review_required or reversed needs support reconciliation, not another payment'). It also gives polling discipline via pollAfterSeconds >= 60. It stops short of naming the sibling tool to use instead, so it is strong context rather than full when/when-not/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?

readOnlyHint=true and openWorldHint=false already declare the safety and locality profile, so the description only needs incremental context. It adds the ownership constraint on the target resource, but says nothing about what happens for unknown/foreign ids (error vs. empty) and its note about output contents partly duplicates the existing output schema.

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

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

One compact sentence with the resource and the scoping constraint front-loaded; nothing is padded. The trailing clause about team IDs and revision is slightly informational rather than operational, but it is brief.

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 annotations and an output schema present, the description needn't explain return values or safety. It is still missing how to source/format the required id and the failure behavior for ids outside the account, which are the two things an agent needs to call this 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% and the single `id` parameter has a pattern constraint but no prose meaning in the schema. The description never mentions the id argument, where to obtain it, or that it must match the pattern, so the coverage gap is left unfilled.

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

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

States a specific verb and resource ("read a scoreboard") and narrows the scope to scoreboards created through this API by the connected account, which distinguishes it from a generic lookup. It does not explicitly name the sibling it differs from (list_scoreboards), but the singular-object scope makes the distinction inferable.

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 "created through this API by the connected account" implies the usage precondition (only scoreboards owned by the caller are reachable), but no when-to-use/when-not guidance or alternatives are named. An agent must infer that list_scoreboards is the route for discovery and this tool for a known id.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuinely new behavioral context: the tool is public and requires no account or authentication, and it performs no side effects. Minor gap: no note on response size or rate limits, though an output schema exists.

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

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

Three tight sentences, front-loaded with the routing cue 'Start here' and the content enumeration. Every clause (onboarding paths, operations, limits, prices, payment steps) carries information an agent needs to decide to call 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-value detail is not required here. With annotations covering safety and the description covering auth requirements, scope, and no-side-effect behavior, an agent has everything needed to invoke it correctly.

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

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

The tool takes zero parameters, which is the baseline-4 case per the rubric. The description correctly implies a no-argument call by framing it as a public discovery endpoint requiring no account.

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 ('discover') and enumerates the exact resource content: MCP/OAuth and guest REST onboarding, supported scoreboard operations, free limits, prices, and payment steps. 'Does not create anything' explicitly separates it from the create_* siblings, and 'Start here' positions it as the entry point ahead of get_account/get_scoreboard.

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' gives a clear first-call directive, and 'Does not create anything' rules out a class of misuse. It does not name specific alternatives for narrower needs (e.g., get_account for existing credentials), so it falls short of explicit when-not/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?

Goes beyond the annotations by disclosing that ownership is not transferred, that the returned link is sensitive and should be scoped to one scorer, and that requestId should be reused on retries (reinforcing idempotentHint=true). It does not say whether earlier links are invalidated, whether the link expires, or that readOnlyHint=false means state changes on the server.

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

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

Four short sentences, front-loaded with what is returned, followed by the sharing constraint and the two key behavioral caveats. No sentence is filler.

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

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

Output schema and annotations already cover return shape and safety profile, so the description only needs to fill in semantics and cautions. It does that for secrecy and idempotency but leaves the identity of 'id' and the lifecycle of the link (expiry, single-use, invalidation of previous links) unstated.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It explains retry semantics for requestId but never defines what 'id' identifies (scoreboard vs. session) and adds no constraint guidance beyond the schema's pattern fields.

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

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

States a specific verb and resource: it returns the connected account owner's private management link, which is clearly distinct from get/list/update/create scoreboard siblings. It does not explicitly tie the link to the required 'id' parameter, so an agent must infer that the link is scoped to a specific scoreboard.

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?

"Share it only with the intended scorer, never spectators" constrains downstream use of the result but says nothing about when to call this tool versus get_scoreboard or update_scoreboard. Usage is implied by the hand-off framing rather than stated as a selection 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?

Annotations already establish that this is a read-only, non-open-world operation. The description adds useful behavioral detail beyond annotations: pagination continues by passing nextCursor as cursor until null, and a filtered page may legitimately be empty.

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

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

Three compact sentences with the primary purpose front-loaded, followed by the key exclusion and pagination behavior. There is little wasted text.

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

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

Given the output schema and read-only annotations, the description covers scope, exclusions, and pagination well enough to call the tool correctly. The main remaining gap is that limit semantics are left entirely to the schema.

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 explains cursor semantics and continuation behavior, but does not explain the limit parameter or its 1–100 range.

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 (list scoreboards) and narrows scope to the connected account's API-created generic scoreboards, explicitly excluding unrelated legacy boards. This distinguishes it clearly from the get/create/update 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?

Gives clear usage context for listing API-created generic scoreboards and explicitly notes that legacy boards are not returned. It also explains cursor continuation, though it does not explicitly route to a sibling tool such as get_scoreboard.

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

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

Annotations already declare the operation destructive, open-world, and idempotent, but the description adds meaningful context beyond them: updates are atomic, changes appear publicly immediately, revision conflicts require re-reading, and identical retry IDs return the previous result. It does not discuss permissions or the full scope of what may be overwritten, so it stops 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 description is dense and front-loaded: it starts with the operations, then gives revision handling and retry semantics. Every sentence carries operational value with no filler.

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

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

For a destructive, open-world mutation tool with an output schema, the description covers atomicity, public visibility, conflict handling, and retry idempotency well. It is missing explicit sibling selection guidance and does not reconcile the empty input schema with its references to team IDs, revisions, and retry IDs.

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 has zero declared parameters, so the baseline is 4. The description adds conceptual guidance about stable team IDs, last read revision, and retry IDs, though those inputs are not present in the empty schema, which limits how actionable that guidance can be.

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 specific operations (set exact scores, increment scores, rename teams, change title) on an implied scoreboard resource, so the agent can tell what the tool does. It does not explicitly differentiate this from siblings like hand_off_scoreboard or get_scoreboard, which keeps it from a 5.

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

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

It gives useful operating guidance for conflicts and retries, including reading the board again on revision_conflict and not blindly replaying stale increments. However, it does not say when to use this tool versus alternatives such as hand_off_scoreboard or get_scoreboard.

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