Veqen: AI cost monitoring and protection

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, so the safety profile is partly covered. However, the description says nothing beyond those hints about what 'revoke' or 'disconnect' actually do (revoked tokens? removed OAuth grants? permanent?), which permissions ('owners') are required, or whether actions are reversible — notable gaps for a mutation tool, and destructiveHint=false sits uneasily with revoke/disconnect semantics.

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

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

It is short, but the single telegraphic sentence with nested parentheses and semicolons is hard to parse and front-loads no clear verb-object statement of purpose. Brevity here comes at the cost of legibility rather than earning 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 need not be described, but for a zero-required-parameter, 0%-coverage mutation tool with six action modes, the description omits which parameters each mode needs, what 'support' actually reveals, and what effect approve/deny/revoke/disconnect have. The agent is not equipped to call it correctly without trial and error.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, and it does partially: it ties grant_id to revoke and family_id to disconnect, which the schema does not express. But 'grant_id; owners' is cryptic, and the description never explains when grant_id or family_id are required versus ignorable given the zero required parameters.

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

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

The description enumerates the tool's modes (support, approve, deny, revoke, apps, disconnect) so the agent knows this is a multi-action access-management tool, but the name 'access' is generic and the telegraphic phrasing ('action support (Veqen support's requests to view the dashboard)') leaves the resource vaguely defined. It does not clearly separate itself from siblings such as disconnect_provider or list_connections.

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 pick this tool over alternatives, no prerequisites, and no mention of the plausibly competing siblings (disconnect_provider, list_connections, set_privacy). The agent must infer the call conditions entirely from the action list.

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 flag destructiveHint=true, idempotentHint=false and openWorldHint=true; the description adds real consequences beyond them — shut_off freezes an agent card, expected quiets the key's rules for a week, rotated serves as refund proof. It omits reversibility and permission prerequisites, which matters for a destructive tool.

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

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

A single dense sentence that front-loads the core purpose and then maps actions to outcomes; every clause carries information. The nested parentheses make it harder to parse than necessary, but no sentence 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?

With an output schema present, return values need no explanation, and the description covers the action vocabulary, the amount parameter, and the confirmation requirement. It lacks failure behavior and the confirm/execute sequencing relative to siblings such as waiting_shut_offs, leaving a small gap for a destructive, non-idempotent tool.

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

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

Schema description coverage is 0%, so the description carries the burden, and it mostly does: it explains all five action values, ties amount_usd to 'claim', ties incident_id to list_incidents, and implies confirmed via 'Confirm first'. The phrase 'confirmed as there' is ambiguous about exactly how confirmation is expressed.

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 ('One action on an incident from list_incidents') and enumerates the five actions with their meanings, which is far more than the title conveys. It does not, however, distinguish itself from closely related siblings like shut_off_key, confirm_shut_off, or update_claim, so an agent could still pick the wrong entry point.

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 per-action selection logic: 'expected' means 'this was us', 'rotated' means the key was replaced everywhere, 'claim' starts a refund for amount_usd or the incident amount. It also instructs 'Confirm first.' It stops short of naming alternatives or when NOT to use this tool versus shut_off_key/confirm_shut_off.

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

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

Annotations declare a non-readonly, non-idempotent, non-destructive write; the description adds genuinely new context by naming the required role (owner, admin or finance member) and the month-end booking side effect. It does not say what happens when a record already exists for the same provider+period — relevant given idempotentHint=false.

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, front-loaded with the core action and scope. 'Month-end books it' is terse to the point of being slightly cryptic, but no sentence is wasted.

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

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

For a mutating, non-idempotent tool with a full output schema and 0% schema coverage, the description covers the essentials (what, who can call it, downstream effect) but leaves duplicate handling, currency and note behavior unexplained.

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% across 5 parameters, so the description must compensate; it clarifies that amount is the invoice total and that period is YYYY-MM. It says nothing about currency (default USD, ISO-3 pattern) or note, leaving two parameters undocumented anywhere.

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 (records) and resource (a provider's monthly invoice total) plus the key scoping condition: manual entry for providers whose billing Veqen can't read. That condition alone differentiates it from list_bills and the automated ingestion path.

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 makes the triggering condition clear ('providers whose billing Veqen can't read') and notes the downstream relationship ('Month-end books it'), implying this is the manual fallback before closing the month. It stops short of naming an explicit alternative tool or stating 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?

Annotations already declare the non-read-only, non-idempotent, non-destructive profile, so the description's job is supplementary — and it delivers the permission requirement plus the domain meaning of prepaid (an asset) vs promotional (free), which the agent cannot infer from structured fields. It stops short of saying what happens on a repeat call or whether an entry can later be corrected.

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 recorded, then kind semantics, then format, then permission. Nothing is padded, though the permission sentence reads as an afterthought rather than being integrated with usage 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?

An output schema exists, so return values need no explanation, and annotations cover the safety profile. Still, for a 6-parameter mutation tool with zero schema descriptions, the definition leaves provider enumeration, duplicate handling, and post-hoc editability 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 description coverage is 0%, so the description carries real weight and does explain the kind values and the YYYY-MM-DD date format for granted_on/expires_on. But provider's accepted values, the note field's purpose, and the effect of leaving expires_on null are left entirely to the schema's bare titles.

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

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

States a specific verb and resource: 'Records credits from an AI provider.' An agent can distinguish it from list_credits or credits_expiring by the write framing, but the description never names those siblings or explicitly contrasts with 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?

The permission prerequisite ('owner, admin or finance member') is useful context but is about authorization, not when to choose this tool over alternatives. There is no statement of when to record a credit versus, say, add_bill, leaving usage implied.

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-read-only, non-destructive, non-idempotent, closed-world operation. The description adds domain rules such as line kinds and positive credit amounts, plus 'Checked at once,' but that phrase is ambiguous and does not explain atomicity, duplicate rejection, or permission requirements.

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

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

The description is compact and front-loads the invoice line format with no redundant sentences. 'Checked at once' is terse to the point of ambiguity, slightly reducing clarity.

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 an output schema and safety annotations, it covers the most complex parameter and a key domain rule. It still leaves tool/period semantics, duplicate behavior, and sibling choice unexplained, so it is only adequately 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 0% schema description coverage, the description carries the full burden. It richly defines the lines array item fields, including kind values and quantity meaning, but does not explain the tool parameter's maxLength or the period format beyond 'for a month'.

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 identifies the resource (a coding tool's invoice for a month) and the line-item structure, but it is a noun phrase rather than an explicit verb and does not distinguish this tool from siblings like add_bill or add_credits. The title supplies 'Add', so creation can be inferred, but the description alone is only moderately clear.

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 guidance on when to use this tool versus add_bill, add_credits, or import_csv. It also does not state prerequisites, duplicate handling, or whether it is specifically for coding tools.

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

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

Beyond the annotations, the description adds meaningful consequences: cancel stops the action from counting toward the month and closes a pending approval, while get returns specific related records. It does not explain reversibility, error behavior, or permission requirements, but the annotations already cover the safety profile and the description adds non-obvious mutation effects.

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

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

The description is a single front-loaded sentence contrasting the two actions, with no filler. The parenthetical structure is slightly dense but still efficient 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?

An output schema exists, so return-value details are not required, and the annotations cover safety hints. Still, the description leaves the required action_id parameter undocumented, which is a notable gap for a tool whose schema provides no parameter descriptions.

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 the semantics of the action enum values (get vs cancel) beyond their names, but it completely omits any explanation of the required action_id parameter and its expected identifier format.

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 clearly defines the two operations on an agent action: get retrieves the current answer, approval, and matched transaction, while cancel aborts it. The resource is specific enough, though the title 'An agent action' is tautological and the description does not explicitly name the required action_id parameter.

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 implied condition for cancel ('the agent didn't go through with it') and explains what get returns, which helps choose between the two modes. However, it does not state when to use this tool versus siblings like agent_approvals or record_agent_actions, nor does it mention exclusions or prerequisites.

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

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

Annotations mark it as non-read-only, non-destructive, non-idempotent, so the safety profile is partly covered; the description adds that approve/deny is effectively a human's answer to an over-mandate spend request and requires user confirmation first, which is genuine behavioral context. It stops short of saying whether an approve/deny decision can be reversed or re-submitted.

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

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

One dense sentence that front-loads the two action modes before the flavour context and the confirmation rule; nothing is padded. The compressed, list-like syntax is efficient but slightly awkward to parse on first pass.

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?

Return values are covered by the existing output schema, and the description supplies the intent and the human-in-the-loop requirement for a 5-param, unlabeled schema. The only shortfall is the undocumented pagination parameter, which an agent needs for the list mode on large result sets.

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 has to carry all parameter meaning. It covers action, state (with all four enum values) and approval_id/note, but 'offset' — the 5th parameter, controlling paging — is never mentioned anywhere, leaving a real 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?

Names both modes concretely — 'list' with the four state values, and 'approve'/'deny' keyed on approval_id plus a note — and the closing clause ('a person's answer to an agent that asked to spend past its mandate') gives real domain meaning. It is distinguishable from nearby siblings like agent_action or agent_spend_view, though the telegraphic grammar takes a second read.

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

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

Tells the agent which action to pick for which intent (list vs approve/deny) and attaches a concrete operating constraint: 'Confirm with the user before answering.' No explicit exclusions or named alternatives among the many approval-adjacent siblings (approve_chargeback, approve_month, agent_action).

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 flag destructive/open-world/non-idempotent, and the description adds real context beyond them: freeze requires freeze access, a two-person shut-off causes a freeze to wait for a second person, limits are set at the platform level, and the agent should confirm with the user before mutating. That is concrete operational behavior an agent needs before calling.

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?

Almost every clause carries information, but it is delivered as one unbroken run-on with nested parentheses and no front-loaded summary sentence. The reader must parse rather than scan, which costs comprehension on a six-action 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?

For a six-parameter, six-action mutation tool, the description covers each action's inputs, the access prerequisite, the two-person approval flow, and the list return fields. An output schema exists so return values need no explanation, leaving only minor gaps around failure modes.

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

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

Schema description coverage is 0%, so the description carries the full burden, and it does map meaning onto every parameter: agent (including the opaque '-' for a person's card and '' to read from the card), card_id, freeze_id for confirm, limit_usd as a monthly platform limit, and incident_id as a recording target. The cryptic sentinel values are exactly the kind of semantics a bare pattern string cannot 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?

The description enumerates the six actions (list, assign, freeze/unfreeze, confirm, limit) against the resource implied by the title, so an agent can infer this manages per-agent payment cards. But there is no lead sentence stating what the tool is for, and nothing distinguishes it from close siblings such as limit_request, limits, waiting_shut_offs or confirm_shut_off.

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

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

Usage is only implied by the action list; there is no explicit when-to-use or when-not-to-use guidance and no routing to alternatives. The one explicit directive, 'Confirm with the user before changing a card,' is a useful guardrail but not selection guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is fully covered elsewhere. The description adds only content shape per view; it says nothing about pagination behavior despite an offset parameter with a 1,000,000 ceiling, nothing about defaults, and nothing about auth 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?

It is one long run-on sentence built from nested parentheticals, with no front-loaded statement of what the tool is for. The information is dense but the structure forces the reader to parse five parenthetical blocks to find the purpose.

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 shape need not be described, and the per-view contents are a reasonable supplement. Still, for a 6-parameter, 0%-schema-coverage tool with paging, the missing explanation of offset and of the match/state enum semantics leaves real gaps.

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

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

Schema description coverage is 0%, so the description must carry the load, and it does explain all five 'view' values plus the YYYY-MM format for period. But it only gestures at 'match filters' and 'state filters' without explaining the enum meanings, and never mentions offset or its paging role.

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 sentence names the resource ('agent spend') and enumerates the five views it can render, so an agent can infer what the tool returns. However, the framing verb is just 'view' and the whole thing is a parameter enumeration rather than a purpose statement, and nothing distinguishes it from close siblings like check_agent_spend, coding_agent_spend, agent_action, or agent_approvals.

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?

Each view is given a short gloss of its contents ('one agent: mandate, cards, latest transactions...', 'the month's agent spend controls report for the close and the auditor'), which implicitly tells the agent which view to pick. There is no explicit when-not guidance and no routing to the sibling tools that cover overlapping agent-spend territory.

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

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

The description adds substantial behavior beyond annotations: the new key is returned once in 'key' and must be stored as a secret, a rotated key stays valid for a day, and full-access keys can't be created here (so access can't survive disconnect). It doesn't state rate limits or permission requirements, and the 'revoke' action sits uneasily against destructiveHint:false at runtime, but the description itself discloses valuable operational 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-loaded with the action list and each action's relevant params, then behavioral notes and a security instruction. It's dense and slightly run-on, but every sentence carries information an agent needs, so little 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 documentation isn't required, yet the description still flags the one critical return detail ('key' shown once). Combined with the secret-handling admonition and the full-access limitation, it's fairly complete for a multi-action tool, with only the 'access' parameter left under-explained.

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

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

With only 17% schema coverage the description must compensate, and it does explain name, expires_days values (30/90/365), allowed_ips ('a send-only key for an app'), and key_id's role in rotate/revoke. But the 'access' enum (send-only|full) and defaults are not explained, leaving a meaningful gap for a 6-param tool.

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 clearly states the resource (API keys) and enumerates the four supported verbs (list, create, rotate, revoke) with context. It's specific enough to know exactly what the tool does, though it doesn't explicitly contrast with siblings like set_key_owner or shut_off_key that could confuse an 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?

It gives per-action guidance and a useful scope exclusion ('Full-access keys aren't made or rotated here'), which is real when-to-use context. However, it never names an alternative tool or says when NOT to use this tool in favor of a sibling, so the routing is implied rather than 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, so the agent knows this is a non-idempotent state change. The description adds genuinely new context: the operation freezes the chargeback, and the close 'books its work and coding agents', which tells the agent there are downstream effects on cost attribution, plus an explicit confirmation requirement. It stops short of saying whether the freeze is reversible or what happens if the month is still open.

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

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

Two short clauses, front-loaded with the effect and followed by the confirmation directive; nothing is padded. The phrase 'the close books its work and coding agents' is compressed to the point of being cryptic, costing a little clarity for its brevity.

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 need no explanation, and the mutation's core effect and confirmation requirement are covered. Still missing for a non-idempotent mutation: reversibility, behavior when the month isn't finished, and how it differs from approve_month / month_end.

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 month property has only a regex pattern and no description — so the description must carry the meaning. It does supply the required format (YYYY-MM) and the semantic constraint that the month must be finished, but adds nothing about validation failure modes or how month relates to the chargeback period.

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 concrete action (freezes), a specific resource (a month's chargeback), and a scope qualifier (a finished month, formatted YYYY-MM), so the agent knows the effect is a lock on one month's chargeback. It does not distinguish itself from close siblings such as approve_month, month_end, or month_end_actions, and the shift from the name's 'approve' to the description's 'freeze' leaves the mapping between the two slightly implicit.

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?

'A finished month's' implies a precondition (the month must be complete) and 'Confirm first' is a real usage directive. But it names no alternatives and gives no guidance on what to do when the month is not finished, or when the agent should reach for approve_month or month_end instead.

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, it discloses the consequential effect (freezing entries, not just approving) and the authorization requirement, which annotations cannot express. It does not say whether a freeze is reversible or what happens on a repeat call, which matters given idempotentHint=false.

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: effect and scope first, then the confirmation requirement, then the permission gate. No filler and nothing 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 need no explanation. For a one-parameter mutation, the description covers the action, its lock effect, the human confirmation step, and the required role.

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

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

Schema description coverage is 0%, so the description carries the burden, and it does supply the period format ('YYYY-MM') matching the regex pattern. That compensates for the single undocumented parameter, though it could clarify timezone/calendar or whether the month must be closed.

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 pair (approves and freezes) plus the exact resource (a month's journal entries) and the period identifier format. An agent can distinguish this from siblings like month_end or reconciliation_status 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 a clear precondition ('Confirm with the user first') and the required role (owner, admin or finance member), which is genuine selection context. It stops short of naming when to prefer a sibling such as month_end or what to do if the month is already approved, 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?

Annotations declare a non-read-only, non-idempotent, non-destructive, closed-world mutation tool; the description meaningfully adds to that by disclosing the owner/admin permission requirement, the confirmation-before-changing-a-subscription norm, and the security model (card details only go to Stripe, checkout returns a link for the payer). It stops short of saying what 'drop' actually removes or whether it is reversible.

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?

No sentence is wasted — every clause carries action semantics — but the whole thing is a single dense run-on with nested parentheses, making it hard to scan for a specific action. Front-loading 'status' as the default action helps, yet bullets or action-newlines would have made it far more usable.

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

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

An output schema exists, so return-value explanation is unnecessary, and permissions, confirmation norms, and the Stripe handoff are covered. What is missing for an eight-action multiplexer is a clear per-action parameter matrix and any note on what a successful 'drop' or 'set_interval' changes.

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 must carry all eight parameters, and it largely does: action values are glossed, yearly and Stripe link behavior explained, product restricted to work_agents/product_inference via the drop clause, work_agents/product_inference tied to checkout, interval tied to set_interval, receiver tied to activate_jvzoo, and partner_code tied to both redeem_offer and checkout. It does not state defaults or clarify which parameters are ignored by which action.

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

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

The description enumerates every action (status, checkout, portal, set_interval, drop, redeem_offer, jvzoo, activate_jvzoo) with a parenthetical gloss, so an agent can tell this is the subscription/plan/spend management tool. However it never states a unifying purpose sentence and never distinguishes itself from billing-adjacent siblings like list_bills, add_bill, plan_costs, or add_credits.

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?

Useful guardrails are present: 'Needs an owner or admin' and 'Confirm before changing a subscription', plus per-action hints such as jvzoo being for purchases bought with your email. But there is no explicit routing guidance telling the agent when to pick this tool over the many sibling billing/credits/plan tools, so selection among alternatives 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 mark this as non-read-only, non-destructive, non-idempotent, so the description must add context, which it partly does: connect takes a read-only credential validated by listing cards, and freeze_access requires a separate credential that can freeze cards and set limits. However, it says nothing about what disconnect or remove_freeze_access do to existing connected data, or whether these actions are reversible.

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

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

It is a single dense run-on sentence packed with parentheticals, which makes it hard to scan; the action-to-meaning mapping would read far better as a short list. It is front-loaded on 'action list' but not on the highest-value 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 formatting needn't be explained, and all five action values are at least touched. But for a multi-action mutation tool with zero schema coverage, the description omits the effect semantics of disconnect/remove_freeze_access and the identity of the credential fields an agent must supply.

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 maps platform values to named providers and explains that 'fields' means a read-only credential for connect versus a separate freeze/limit credential for freeze_access. It still leaves the exact field keys and the purpose of fields for list/disconnect undocumented.

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

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

The description names the resource (the card/banking platforms Veqen reads: Stripe Issuing, Ramp, Brex, Mercury) and enumerates the specific actions (list, connect, disconnect, freeze_access, remove_freeze_access). It does not explicitly differentiate itself from nearby siblings like connect_provider or agent_cards, but the purpose is unmistakable.

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

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

It implies when each action applies by describing what list returns ('what each needs, and which are connected') and that connect credentials are verified by listing cards, but there is no explicit when-to-use vs. alternatives guidance (e.g., linking vs. agent_cards or connect_provider), and no stated prerequisites or ordering constraints.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the description adds value by disclosing the owner-only privilege constraint and mandating confirmation before executing. It stops short of saying what happens to a removed member's data or whether removal is reversible beyond the idempotency hint.

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?

Extremely compact and front-loaded, with no filler sentences. The telegraphic phrasing 'action role (member_id from list_members, role)' is slightly ambiguous on first read but every token carries information.

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

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

Annotations plus the output schema relieve the description of safety and return-value details, and the action-to-parameter mapping is present. Still missing for a destructive membership tool: which role values are assignable and their meaning, and what removing a member does to their existing records or owned resources.

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 must carry the load, and it does map each action to the parameters it consumes and explains where member_id originates (list_members). It does not explain the semantics of the distinct roles (finance, security, viewer) or whether role/invitation_id are ignored on other actions, so a small gap remains.

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

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

The description enumerates the three concrete operations (change role, remove member, cancel invitation) and their respective parameters, so the agent knows exactly what the tool does. It is distinguishable from invite_member and list_members, though it never names those siblings directly.

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 tells the agent which action value pairs with which identifier (role/remove -> member_id, cancel_invitation -> invitation_id) and sources member_id from list_members. It also states a real precondition ('Owners alone add or remove owners') and a confirmation requirement ('Confirm first'), but offers no explicit routing to alternatives such as invite_member.

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, it discloses that the set_access credential is never shown again, names the required roles, requires confirmation before acting, and constrains shutoff to dormant and owner_gone keys. These are meaningful behavioral details, though it does not discuss reversibility or repeat/idempotency 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 definition is appropriately sized at roughly two sentences and every clause carries information, but it is not front-loaded: it opens with the action list rather than stating the tool's purpose, and the long parenthetical makes the action-to-parameter mapping harder 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 seven-parameter conditional mutation tool, the description covers the action variants, role prerequisite, confirmation step, and the main constraint on shutting keys off. It still leaves the semantics of 'rule' and the effect of set_options on sharing unspecified, but the output schema is present and much of what an agent needs is supplied.

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 and seven parameters, the description does most of the work: it maps provider/key to set_access, provider to remove_access, rule/policy to set_policy with allowed values, and two_person_shutoff/share_patterns to set_options. The 'rule' parameter remains unexplained and the key parameter's direction (input credential vs identifier) is ambiguous.

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

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

The description enumerates the four actions (set_access, remove_access, set_policy, set_options) with their associated fields, so an agent can tell this mutates protection settings rather than reads them like protection_settings. It lacks an opening statement of the tool's overall purpose and does not explicitly distinguish itself from siblings such as shut_off_key or confirm_shut_off.

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 prerequisites (owner, admin or security member) and a confirmation requirement ('Confirm first'), which is real guidance. However, it never says when to use this versus protection_settings, shut_off_key, or confirm_shut_off, so the choice 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 cover read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful context that results are matched to invoices and include journal entries, and hints at Enterprise plan availability, but it does not disclose whether the report must exist, whether it is generated on demand, or what happens if the month is not finished.

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 compact and front-loads the deliverable. The trailing fragment 'Work and coding agents Enterprise.' is abrupt but still conveys plan availability; it could be integrated more cleanly.

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

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

An output schema exists, so return structure need not be explained. However, for a report-generation tool with a single required parameter at 0% schema coverage, the definition should clarify month semantics and when to prefer this over adjacent reporting tools such as month_end or reconciliation_status.

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

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

The single parameter has 0% schema description coverage, so the description must compensate. It adds the meaningful constraint that the month should be 'finished,' while the YYYY-MM format is only conveyed by the schema pattern; the description does not explain timezone, month boundary, or what happens for incomplete months.

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 identifies a specific resource (a finished month's chargeback breakdown by cost center, team, person, tool, matched to invoices with journal entries), but it reads as a noun phrase rather than a clear action and does not explicitly distinguish itself from siblings like month_end, get_spend, or reconciliation_status.

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 explicit guidance on when to call this tool versus alternatives such as month_end, get_spend, or reconciliation_status. The phrase 'finished month's' weakly implies it is for closed periods, but no preconditions or exclusions are stated.

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 flag non-read-only, non-idempotent, non-destructive. The description adds the crucial side effect that the action 'is recorded either way and matched to the card or account transaction when it appears,' which annotations alone would not reveal. It omits auth requirements and rate limits, so it is not a 5.

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

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

Three sentences, front-loaded with the trigger and decision, and no padding. The approval-parenthetical is slightly dense but earns its place by explaining the follow-up call.

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?

It covers the decision outcomes, the recording behavior, and the approval follow-up, and the output schema handles return values. For a 10-parameter tool with zero schema descriptions, however, it never explains the key inputs (amount, agent, card, rail, kind), leaving an agent to guess their meaning.

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 the burden. It explains only action_id (reuse for polling approval) and references agent_action, but leaves eight parameters—agent, amount, card, run, kind, rail, payee, purpose, currency—semantically unexplained beyond their 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 ('check before an AI agent spends money') and enumerates the three possible answers (allow, approval, deny). It also names the sibling tool agent_action as the way to retrieve a decision, so an agent can distinguish it from passive viewing tools like agent_spend_view.

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 timing is explicit ('Call before an AI agent spends money'), and the approval path is spelled out ('call again with the same action_id, or agent_action'). It does not say when not to use it or contrast it with get_spend/limits, but the core when-to-use guidance is clear.

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

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

Annotations already cover read-only, idempotent, non-destructive, closed-world. The description adds real value beyond them: the default month behaviour and the note that results are scoped to what the viewer would see in the dashboard (permission-based visibility). It does not explain pagination behaviour or the result ordering, and the offset parameter goes unmentioned.

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

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

A single dense sentence, front-loaded with the resource and scope, then parenthetical defaults, then the permission note. No filler, though the final dashboard clause is slightly indirect.

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. However, with three parameters at 0% schema coverage and no annotations about pagination, the missing offset meaning and unspecified result ordering leave the agent short of what it needs to page through per-person cost data confidently.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It does for two of three: month format 'YYYY-MM' with 'this month by default', and team ('optionally for one team'). The offset parameter is never explained, leaving pagination semantics undocumented anywhere.

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: per-person work and coding agent cost for a month, broken down tool by tool, optionally scoped to one team. That is clearly distinct from generic siblings like get_spend or get_customer_cost, though it never names those alternatives 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?

Usage is implied by the framing (cost per person, per month, per team) but there is no explicit guidance on when to choose this over get_spend, get_customer_cost, or forecast_spend. The 'optionally for one team' phrase hints at the filtering case but doesn't state 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false and non-destructive, so the safety profile is covered. The description adds that costs are computed at 'the company's contracts' and invoices are 'checked against what Veqen expects', which is meaningful context about the data, but it says nothing about default behavior when month is omitted or how large the result set can be.

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

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

A single dense sentence with no filler, and the most important scoping fact (month, with format) appears early. It is a verbless fragment, which slightly reduces readability but costs no tokens.

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 tool with an output schema and safety annotations, the description covers the returned content adequately without needing to restate return shape. The missing piece is optional-parameter behavior: with month defaulting to null and no required fields, an agent cannot tell what a bare call does.

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 the parameter alone; it does convey the month semantics and its YYYY-MM format (though the schema pattern already enforces that). It fails to explain the null default — whether omitting month means the current month or all months — which is the one thing an agent actually needs 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 the resource (coding tools) and enumerates the specific fields returned per tool: connection status, cost at contract rates, plan, and invoice reconciliation against Veqen's expectations. That is far more specific than the tautological title, though it never explicitly contrasts itself with near siblings such as coding_agent_spend, reconciliation_status, or add_tool_invoice.

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 reach for this tool versus alternatives like coding_agent_spend or reconciliation_status, and no exclusions. An agent must infer from the noun phrase that this is the per-tool monthly breakdown rather than the aggregate spend view.

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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds that results are reported both per call and per month and that token-based versus unit-based models are costed differently — useful behavioral context, though it says nothing about limits (max 10 models) or what happens with mixed/unsupported model lists.

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

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

A single dense sentence with no filler, and the core deliverable (cost per call and per month) is front-loaded before the input taxonomy. Slightly overloaded with parenthetical enumerations, but every clause carries information.

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

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

An output schema exists, so return values need no explanation, and the input taxonomy is covered. However, for a 7-parameter analytical tool the description omits the multi-model limit, default assumptions (e.g. 100000 calls/month), and when this beats get_model_price or simulate_workload — a moderate 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 coverage is 71%, just under the baseline threshold, and the description meaningfully compensates by explaining which inputs apply to which model classes: tokens for text, embedding and realtime models, units (images, seconds, characters, queries, pages) for the rest. That is genuine semantics beyond the field-level descriptions, though 'variant' and 'calls_per_month' get no treatment.

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

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

States the resource precisely: cost of the same call across several models, per call and per month. The plural 'several models' implicitly distinguishes it from get_model_price (single price lookup) without naming the sibling, so differentiation is inferable rather than explicit.

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 statement of when to use this versus get_model_price, simulate_workload, or estimate_switch. The multi-model framing hints at a comparison use case, but there are no exclusions or prerequisites, so an agent must infer routing from the sibling names alone.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is partly covered. The description adds that this is a second-person confirmation of a waiting shut-off, which is meaningful context beyond annotations, but it does not explain the effect of confirmation or what exactly becomes destructive.

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 main action, which is good. However, the fragment "Confirm first" is ambiguous and does not clearly earn its place, making the structure less effective than it could be.

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

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

The tool is destructive and open-world, but annotations and an output schema reduce what the description must cover. It identifies the waiting_shut_offs source and the second-person confirmation role, yet it does not fully describe the confirmation workflow or consequences of confirming.

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 burden for the single action_id parameter. It partially does so by saying the id comes from waiting_shut_offs, but it does not explicitly map action_id to that source or explain the integer/minimum constraint already present in the schema.

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

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

The description states a specific verb and resource: it is the second person's confirmation of a waiting shut-off, and it points to waiting_shut_offs as the source of the id. The only weakness is the cryptic fragment "Confirm first," which slightly muddies an otherwise clear purpose.

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 implies usage by saying the id comes from waiting_shut_offs and that this is the second person's confirmation, which gives useful workflow context. However, it does not explicitly say when not to use it, what alternative to use, or fully explain the two-person prerequisite.

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

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

The description adds significant behavioral context beyond annotations: it stores a credential (sensitive), fetches 30 days of data, and may take up to a minute. These details help the agent understand the operation's impact and timing, though it could mention idempotency or failure modes explicitly.

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

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

The description is three sentences, but the first sentence is long and awkwardly structured ('with the fields list_connections names...'), making it harder to parse. The key information is present but not optimally front-loaded.

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

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

Given the presence of an output schema and annotations covering safety and idempotency, the description provides enough context for correct invocation: it covers credential storage, timing, data range, and field sourcing. Minor gaps remain, such as what happens on failure or the exact shape of the fields object.

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 compensates well: it explains that 'fields' should contain the field names from list_connections (e.g., an admin key) and gives a concrete example ('provider stripe with a key field connects revenue'). This clarifies both required parameters despite the lack of schema annotations.

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 ('Connects') and resource ('a provider's billing or a coding tool's usage'), making the tool's function clear. It implicitly distinguishes from the sibling disconnect_provider, though it doesn't explicitly name 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?

The description includes a prerequisite ('Confirm first: it stores a credential') and points to list_connections for field names, but it does not explicitly state when to use this tool versus alternatives or 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered; the description usefully adds that only credits with a nonzero balance are returned. It says nothing about whether already-expired credits are included or how the window is bounded.

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

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

One short sentence with no filler, and the key qualifier (expiring within N days) comes at the end where it reads naturally. It is under-specified rather than padded.

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 shape needn't be described, and annotations cover safety. Gaps remain on window semantics and on routing among the many reporting siblings, which matters for a tool with 12 dashboard-style alternatives.

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

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

Schema coverage is 0%, so the description must carry the parameter's meaning; it does clarify that within_days is an expiry horizon in days, which is real added value. It does not state the reference point (now vs. billing cycle), inclusivity, or that the field is optional with a 60-day 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?

The phrase names a specific resource (provider credits), a filter (positive balance), and a time horizon, which distinguishes it from siblings like get_spend or get_account. It is a noun fragment without a verb, but the returned entity is unambiguous.

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

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

It says nothing about when to reach for this tool versus get_spend, get_customer_cost, or reconciliation_status. The only usage signal is the implied 'set within_days to your horizon', which an agent must 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?

The annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is covered. The description adds a meaningful authorization requirement ('Needs an owner or admin') and clarifies that the id comes from list_budgets.

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 two short sentences with no wasted language. The core action and id source are front-loaded, followed by the authorization requirement.

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 one-parameter delete tool with rich annotations and an output schema, the description covers what an agent needs: the action, the identifier source, and the permission requirement. Return values need not be explained because an 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 the sole parameter budget_id is only typed as an integer in the schema. The description compensates by explaining that budget_id is the id obtained from list_budgets, giving the parameter clear semantic grounding.

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: deletes a budget, identified by its id from list_budgets. It is clear and actionable, but it does not explicitly distinguish this operation from the related set_budget sibling.

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 useful prerequisite ('Needs an owner or admin') and indicates where to obtain the id ('from list_budgets'), which implies when to use it. However, it does not explicitly state when not to use it or name alternatives such as set_budget for creating or updating budgets.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, readOnlyHint=false, so the safety profile is largely covered. The description adds the non-annotated 'Confirm first' requirement and clarifies the deletion scope, but says nothing about irreversibility, permissions, or what happens to dependent data.

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

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

Two short sentences, front-loaded with the verb and affected resources, with the confirmation caveat placed last. No filler.

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

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

An output schema exists and annotations carry the destructive/idempotent profile, so the description needn't explain returns. What it adds — entity kinds, id scoping, confirm-first — is nearly sufficient; a note on irreversibility or failure modes would close the remaining gap for a destructive tool.

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

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

Schema coverage is 0%, so the description must compensate, and it does part of the job: it enumerates the six valid kinds and the phrase 'from the matching list' conveys the non-obvious fact that record_id is scoped per kind. It lacks type/format detail for record_id, but the id-scoping insight is genuinely valuable 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?

Opens with a specific verb ('Deletes') and enumerates the six resource types plus the lookup key ('by its id'), so an agent knows exactly what it removes. It does not differentiate against the near-neighbor sibling delete_budget, nor clarify that deleting a 'baseline' is different from freeze_baseline, so it stops short of full sibling discrimination.

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?

'Confirm first' is the only procedural guidance, which is a useful workflow hint but not an when-to-use/when-not-to-use rule. Nothing tells the agent when to prefer this over delete_budget or freeze_baseline, or what preconditions exist before deletion.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, yet the description adds a concrete consequence not encoded anywhere: the billing records the provider supplied are deleted along with the connection. That plus the confirmation requirement gives an agent real decision-relevant behavior, though permanence/restore options remain 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?

Two short sentences, the destructive effect is front-loaded, and there is no filler. Slight deduction for the ambiguous 'it' that forces the reader back to the title.

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

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

An output schema exists so return values need no explanation, and the annotations carry the safety profile. However, for a destructive tool the description omits the parameter format and any note on what depends on the provider (keys, tools, historical attribution), leaving real gaps.

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

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

One required parameter with 0% schema description coverage and no enum. The description says nothing about whether 'provider' expects a slug, display name, or ID, so the agent must guess the value format for a destructive call.

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 (disconnects) plus the consequential effect (deletes billing records brought in from that provider), which distinguishes it from connect_provider. The object is an unresolved pronoun 'it' that only the title supplies, and 'Veqen' is unexplained jargon, so it falls just short of fully self-contained.

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?

'Confirm first' gives a workflow precondition, which is more than nothing. But it never says when to prefer this over alternatives such as connect_provider, list_connections, or shutting off a key, nor what happens to the provider's keys/data afterwards.

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 closed-world, so safety is covered. The description adds two genuinely useful bits of context: the estimate uses the org's real token volumes (not hypothetical) and applies standard rates, implying negotiated discounts are excluded. It does not say whether historical data availability affects the result or how partial windows are handled.

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 sentence, front-loaded with the key distinction, with no filler. Brevity is appropriate here; the shortfall is missing content rather than wasted words.

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 relieves the description of explaining return values, and annotations cover safety. But for a 4-parameter tool with zero schema description coverage, the definition leaves the meaning of days, feature and from_model unstated and gives no guidance on when to prefer this over sibling estimation 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% and the description only gestures at to_model ("another model"). The required from_model and especially days (1-90, default 30) and feature are entirely unexplained, forcing the agent to interpret a bare JSON 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?

A specific verb ("re-prices") and resource ("the organization's real token volumes on another model") makes clear this is a cost what-if based on actual usage, not a generic model comparison. It implicitly distinguishes itself from compare_models and simulate_workload, though it never names them, 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?

There is no explicit when-to-use statement and no routing to alternatives, despite siblings like compare_models and simulate_workload that plausibly overlap. The agent must guess whether this is the right tool for a pricing question versus a side-by-side model comparison.

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 behavior. The description adds useful context beyond annotations: it explains that the tool names the top-moving models/features/customers and that the baseline defaults to the same number of days just before. It doesn't cover rate limits or auth needs, but those are lower priority for a read-only analytical 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?

Two sentences with no wasted words: the first describes the core comparison and output, the second clarifies default baseline behavior. The purpose is front-loaded and easy to parse.

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

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

Given the output schema and annotations, the description covers the essential non-schema behavior (default baseline, output content). It lacks explicit sibling differentiation and edge-case constraints (e.g., date inclusivity, maximum range), but it is sufficient for a simple read-only comparison tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining the default behavior when baseline_start and baseline_end are omitted—they default to the same number of days just before the main period. This is valuable for correct invocation.

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 ('compares') and resource ('two periods') and specifies the output ('names the models, features and customers that moved most'). This clearly distinguishes it from simple spend retrieval tools, though it doesn't explicitly contrast with the sibling compare_models.

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

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

The description implies usage by stating it compares periods and identifies top movers, but it doesn't explicitly say when to use this tool versus alternatives like compare_models or get_spend. No exclusions or routing guidance are provided.

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, idempotentHint, non-destructive, closed-world. The description adds real substance beyond them by disclosing the forecast method (spend so far plus each remaining day at its weekday's recent average) and the 80% range, which tells an agent how much to trust the number. It does not mention any caveats about sparse data, but that is a minor omission against an already-strong annotation set.

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

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

A single dense sentence with the resource and scope front-loaded and zero filler; the parenthetical methodology earns its place by explaining the calculation.

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 covers the method and all three param semantics. The remaining gap is that it never says how month-end vs quarter-end is chosen (there is no parameter for it), leaving the agent to guess that both horizons come back.

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 the load — and it does: 'for the organization or one customer, feature or project' explains that all three optional params are scope selectors and that omitting them yields org-level results. The phrase 'one customer, feature or project' also hints they are single-value selectors. It does not state whether they can be combined, which keeps 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?

The description names a specific verb+resource (forecast spend) and adds the scope (month-end and quarter-end, organization or one customer/feature/project), which clearly separates it from get_spend and month_end. It never explicitly names a sibling tool, 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 implied: this is the forward-looking counterpart to get_spend's actuals. But there is no explicit 'use this when…' clause, no exclusions, and no pointer to month_end or get_spend as alternatives, so an agent must infer the 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?

The description carries real behavioral weight the annotations do not: `run` is asynchronous with roughly an hour of latency, and `share` produces a link open to anyone signed in to the organization for 30 days, an access-control fact worth stating. Annotations only supply the generic readOnly/destructive/idempotent flags, so this added context is genuine value. Minor gap: it doesn't say whether `unshare` revokes links immediately or whether a new `run` replaces prior data.

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

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

A single dense sentence front-loads the action enumeration, with each action's meaning in a parenthetical. It is efficient, though the telegraphic style (missing articles, semicolon-chained clauses) costs a little readability.

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-shape detail is unnecessary, and the description covers all four action modes plus the async and link-lifetime behaviors. What is missing is the default action and any note on prerequisites (e.g., whether connections must exist before `run`).

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 the parameters, and it partly does: it defines what get/run/share/unshare mean and ties `run_id` to the share/unshare actions. It omits that `action` defaults to `get`, that `run_id` must be a positive integer, and whether get can target a specific historical run.

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?

Enumerates the four actions with their distinct effects: get (latest audit state or its report), run (a 30-day audit across connections), share/unshare (link management). A reader knows this is a multi-mode audit tool. It does not distinguish itself from audit-adjacent siblings like get_run/get_runs or access, so it falls short of a 5.

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

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

The cost/timing note on `run` (30 days of data, ready within the hour) implicitly signals it is a slow, heavy action, and the share lifetime implies the sharing workflow. But there is no explicit when-to-use guidance, no mention that `action` defaults to `get`, and no routing to or away from siblings such as get_run.

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=false, idempotentHint=false, and destructiveHint=false, so the description does not need to restate safety basics. It adds meaningful behavioral context by warning that the baseline cannot be edited afterward and only deleted, plus the need to confirm first.

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 and the description is short enough to scan. It repeats the 'before the new terms start' timing idea, which slightly reduces conciseness but also reinforces an important constraint.

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 that annotations cover mutation/idempotency hints and an output schema exists, the description provides enough context for correct invocation: purpose, timing, immutability, and confirmation. It omits optional parameter semantics and permission details, but those are secondary 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 description explains the roles of covers, base_start, base_end, and changed_on in prose, tying them to the baseline period and first day of new terms. It does not explain the optional name or agreement_id fields, so with low schema description coverage it only partially compensates.

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 uses a specific verb, 'Freezes,' and identifies the resource as a savings baseline, with scope tied to covers, base_start/base_end, and changed_on. It is clear on its own, but it does not explicitly distinguish itself from savings-related siblings such as get_savings or forecast_spend.

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 timing prerequisite: 'Do it before the new terms start,' and adds 'Confirm first.' However, it does not state when not to use this tool or name alternative tools/options, so usage guidance is implied rather than 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?

Annotations already state read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful content scope (organization, plans, billing-period usage) but does not explain freshness, billing-period boundaries, or authorization requirements.

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

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

It is a single concise sentence fragment with no wasted text, front-loading the organization and including the relevant plan and usage details. The parenthetical is slightly dense but still appropriate.

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 zero-parameter schema, rich annotations, and an output schema, the description provides enough context about what account information is returned. It could be stronger by clarifying how it relates to spend-focused sibling 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?

The tool has zero parameters, so there are no parameter semantics to explain. The baseline for no parameters 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?

The description clearly identifies the resource and its contents: the connected organization, plans, and current billing period usage. It is more specific than the name alone, but lacks a verb and does not explicitly differentiate from siblings such as get_spend or get_customer_cost.

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 explicit guidance on when to use this tool versus alternatives like get_spend or get_customer_cost. Usage is only implied by the described contents.

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, idempotentHint, and destructiveHint=false, so safety is covered. The description adds that the response includes both destination configuration and the latest sent alerts, which is useful beyond the annotations, but it does not mention pagination, limits on 'latest', or other behavioral details.

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 no waste, and the two content pieces (destinations, latest alerts) are front-loaded. It is arguably slightly terse given the lack of an explicit verb, but efficient.

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

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

With zero parameters, an output schema present, and annotations covering the safety profile, little else is needed. The description covers both what is returned and the channel types, though it could be clearer about scope of 'latest' and whether both pieces are always returned.

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. There is no parameter semantics for the description to explain.

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

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

The description conveys that this tool returns alert destinations (email, Slack, webhook) plus recently sent alerts, which is a reasonably specific resource description. It lacks an explicit verb and does not explicitly differentiate itself from siblings, though no sibling overlaps this domain.

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

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

No guidance on when to call this tool, when not to, or what alternatives exist. The agent must infer usage entirely from the wording 'where alerts go' and 'latest alerts sent'.

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, idempotentHint and non-destructive, so safety is covered. The description adds genuine behavioral context beyond that: margin is only included when Stripe revenue is connected, which tells the agent why a field may be absent. It does not cover default date-range behavior, which is a minor remaining gap.

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

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

A single front-loaded sentence that lists exactly the breakdowns offered and qualifies the one conditional output. No filler and nothing 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 structure need not be explained, and annotations cover the safety profile; the description is therefore nearly complete. The one shortfall is that it is silent on the customer parameter's expected format and on default time window, which matter for correct invocation.

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

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

Schema coverage is 67%; start and end are documented as YYYY-MM-DD with patterns, but customer has no schema description. The description says nothing about the parameters, including what 'customer' accepts (id vs name) or what omitting start/end defaults to, so it adds no meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description names a specific resource (one customer's cost) and enumerates the breakdown dimensions: total, by feature, by model, plus margin. It is clear what the tool returns, but it does not contrast itself with siblings like get_spend or get_margin, so the 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?

Usage is implied by the scoping phrase 'one customer', which suggests per-customer analysis versus the account-level siblings. However there is no explicit when-to-use, no named alternative (get_spend, get_margin, compare_models) and no exclusions or prerequisites.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description only needs to add what annotations don't say. It does add the payload structure — timeline, per-hour reasons, claims — but that overlaps with the output schema and it says nothing about behavior on a nonexistent id or whether the response is capped.

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

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

A single front-loaded sentence with no filler. The parenthetical-style breakdown of return contents is compact and informative rather than verbose.

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 a full output schema, the description covers purpose, provenance of the id, and the shape of the result. The main gap is error behavior for an unknown id, which an agent might reasonably want to know before calling.

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 single incident_id parameter is undocumented in structured fields. The description compensates partially by saying the id comes 'from list_incidents', which tells the agent where to source a valid value, but it adds no format or validation detail beyond the schema's integer 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?

Names a specific verb and resource ('One incident by its id') and explicitly distinguishes itself from the sibling list_incidents as the single-item drill-down. It also previews what comes back (timeline, hourly reasons, claims), so the agent knows exactly what this tool yields versus the list tool.

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 'from list_incidents' establishes the intended workflow: call the lister first, then fetch a specific incident by id. It doesn't state when not to use it or what happens with an invalid id, but for a simple read-by-id tool the usage context is clear.

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 safe, read-only, idempotent, non-destructive operation. The description adds useful behavioral context beyond that: the data sources (Stripe revenue and AI cost) and the default ordering by least profitable customer.

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

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

The description is a single tight sentence with no waste, and it front-loads the key metric and ordering. Every phrase contributes useful 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?

The output schema exists, and annotations cover safety and idempotency, so the description need not explain return values or side effects. It provides enough context to understand the tool’s purpose, though it could better clarify date-range behavior and limit semantics.

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 67%: start and end are documented as YYYY-MM-DD dates, while limit has no schema description. The description does not explain any parameter, but the remaining schema constraints/defaults make the tool minimally usable, so this is adequate with a clear gap around limit 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 clearly states the resource and calculation: revenue from Stripe versus AI cost per customer, with results ordered least profitable first. It distinguishes the tool implicitly from cost/spend siblings by framing it as margin, though it does not explicitly name 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?

Usage is implied by the phrase "least profitable first," which suggests this is for identifying low-margin customers. However, the description gives no explicit when-to-use guidance, prerequisites, or comparison to siblings such as get_customer_cost or get_spend.

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, idempotentHint and openWorldHint=false, so safety is covered. The description adds real context beyond that: rates are USD per million tokens, the field abbreviations (in, out, cr, cw, cw1h, ain, aout), tiering (batch, priority, long-context), and the unit-rate variant scheme for non-token billing.

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 with the core statement, then a dense but necessary glossary of rate fields and tiers. No filler.

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

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

An output schema exists, so return values needn't be spelled out, yet the description still decodes the rate fields and variant notation. Only the relationship to sibling pricing tools 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?

Schema coverage is 100%, so both model and provider are already documented in the schema. The description adds only a general note that any model kind is supported, which is the correct baseline when the schema does the heavy lifting.

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

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

States a specific resource and outcome — pricing rates for a single model — and the sentence 'Models billed per image, second, character, query or page have a unit rate' makes the scope (any model kind) explicit. It does not name siblings like compare_models or list_models, so differentiation is left 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?

There is no when-to-use guidance, no prerequisites, and no named alternative. An agent must infer from the sibling list that compare_models handles multi-model comparison while this returns rates for one model.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful details about output (total, duration, up to 200 requests with model/tokens/cost), but does not disclose error behavior, rate limits, or other operational traits beyond what annotations provide.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently conveys purpose, scope, and key output details.

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 rich annotations, an output schema, and a single-parameter input, the description is nearly complete for an agent to call it correctly. It could mention error handling (e.g., if the run id is not found), but overall it provides sufficient context.

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 clarifies that the single parameter 'run' is a run id, which adds some meaning beyond the bare schema, but it does not specify format, examples, or constraints (e.g., where to find a run id) beyond what is already implied.

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 resource (one agent run, conversation, or job) and its scope (by run id), and it distinguishes from the sibling get_runs by noting that get_runs lists the costliest runs. An agent can tell exactly what this tool 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?

The description implies usage (you need a run id to get details) and references get_runs as an alternative, but it does not explicitly state when to use this tool versus get_runs or any other sibling. The guidance is present but indirect.

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

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

Annotations already declare this as a safe, read-only, idempotent operation, so the bar is lower. The description adds useful behavioral context by defining what counts as a run and clarifying that filtering is based on when runs ended, plus the aggregate metrics 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 definition is a single dense sentence with no filler. It is appropriately concise, though it front-loads the definition of a run rather than the action and could be structured more clearly for scanning.

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 details need not be in the description, and annotations cover the safety profile. However, with five parameters and low schema description coverage, the description is incomplete regarding filter parameters and the limit 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 only 40%, and the description only hints at the date-range parameters. It does not explain the feature, customer, or limit parameters, nor does it compensate for the undocumented schema 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?

The description clearly states the resource (agent runs/conversations/jobs identified by run id or OpenTelemetry trace) and the returned metrics (count, total, average, median, p90, most expensive). It is specific but does not distinguish this aggregate tool from sibling tools such as get_run, get_spend, or get_customer_cost.

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

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

The description implies the tool is for runs ending in a date range, but it gives no explicit when-to-use guidance, no when-not-to-use guidance, and no alternatives among the many sibling cost tools. An agent must infer the appropriate context.

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 closed-world, so the safety profile is covered. The description adds real context beyond that: the 30-day window over which savings are computed and the fact that each item carries an estimated monthly saving amount, which shapes how the agent should present results.

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, scope front-loaded in the first and category enumeration kept tight. The final sentence is a usage nudge rather than descriptive content and sits a little awkwardly, but it is short and does not bloat 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?

An output schema exists, so return values need not be explained, and the annotations plus the stated time window cover the read semantics. What is missing is routing: with siblings like estimate_switch, compare_models and get_spend in the same family, the description should say which question this tool answers versus those.

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 schema-derived baseline of 4 applies; there is nothing about inputs the description needs to compensate for.

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 the resource concretely — savings opportunities over the last 30 days across four specific categories (prompt caching, batch API, cheaper host, cheaper model) each with a monthly estimate. That is clear enough for an agent to know what comes back, but it never distinguishes itself from close siblings like estimate_switch or compare_models, which plausibly return overlapping advice.

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 explicit when-to-use or when-not-to-use guidance relative to siblings. The closing line 'Test a cheaper model's answers before switching' gestures toward compare_models without naming it, leaving the agent to infer the relationship itself.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description earns credit for adding real behavior: only ONE group_by dimension at a time, the remaining dimensions act as filters, and the response always includes this month's run rate and forecast regardless of range. It does not mention the 20-row default cap or row 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?

A single front-loaded sentence, 'AI spend for a date range', followed by a colon-delimited enumeration of what comes back. Dense but zero waste; it would read slightly better split into purpose and output clauses.

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 readOnly annotations cover safety. However, with 11 all-optional parameters and 27% schema coverage, the description omits default behavior — what range you get with no dates and what `limit` truncates — which 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 coverage is only 27%, so the description must carry weight and it does explain the most subtle rule — group_by takes one dimension while the others filter, meaning the grouped dimension is excluded from filtering. But it leaves `limit` (default 20, max 100) and the default date range when start/end are omitted completely undocumented.

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 resource and scope: 'AI spend for a date range' with totals, an optional single-dimension breakdown, filters, and run rate/forecast. That is far more than a restatement of the name, but it never names a sibling (get_customer_cost, get_margin, compare_models) to mark where its territory ends.

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: 'an optional breakdown by one dimension, filters on the others' tells the agent how to shape a call, but there is no explicit when-to-use-this-instead-of-get_customer_cost or get_margin guidance, and no 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?

Annotations already carry the safety profile (readOnly, idempotent, non-destructive), and the description adds real context: what the numbers mean (cost against a usual day) and the comparison baseline (same weekday a week before). That baseline detail is genuinely useful for interpreting results and is not available anywhere in the structured fields.

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

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

A single dense sentence with zero filler, front-loading the resource and the id provenance. The clause structure is slightly awkward ('by the id list_anomalies gives'), which costs a little readability but not correctness.

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 instead explains the analytical meaning of the response and the comparison window. Combined with full annotation coverage and a single required parameter, an agent has what it needs to call this correctly; only edge cases (invalid or stale ids) are 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 description coverage is 0%, so the description must compensate, and it does by identifying the id's origin and namespace (the ids returned by list_anomalies). It doesn't state format or validation rules, but the schema already constrains the type to a positive integer.

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 precisely what is fetched: a single spending spike, identified by an id, along with cost-versus-usual-day and the top-moving models, features, customers and users. It also explicitly distinguishes itself from list_anomalies, the sibling that produces the ids, so an agent can route correctly without opening either schema.

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

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

Gives an explicit prerequisite and alternative route: the id must come from list_anomalies, so the agent knows it should list first and then fetch detail. No explicit when-not guidance, but for a straightforward detail-fetch tool the routing condition is the one that matters and it is 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?

Annotations already declare this is a non-readonly, non-destructive, non-idempotent write. The description adds CSV format requirements but does not explain what happens on import—whether records are appended or replaced, how duplicates are handled, or what the 5MB size limit means in practice.

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 but efficient: one long enumeration of kinds followed by a short directive to pass file text as csv. It is front-loaded with the most important information, though a structured list would be more 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?

Given the existing output schema and annotations, the description covers the critical input semantics—especially which kind to use and what columns each expects. Minor gaps remain around mutation behavior and the precise meaning of every optional parameter.

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

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

Schema coverage is only 20%, so the description carries most of the burden. It meaningfully explains the `kind` enum values and their CSV shapes, and it hints at the roles of `provider` and `match` for bills, though the `tool` parameter's exact semantics remain somewhat ambiguous.

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

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

The description enumerates the five supported import kinds and their expected CSV contents, making it clear the tool ingests CSV data of a specified type. However, it never states the action verb explicitly and does not distinguish this tool from siblings like add_bill or teams_and_people.

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 list of kinds implies which kind to choose for which data source, but there is no explicit guidance on when to use this tool versus alternatives such as add_bill or teams_and_people. Usage is implied rather than stated.

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, idempotentHint, non-destructive, and closed-world, so the safety profile is covered. The description's added value is the shape of the returned evidence – key changes followed by an hour-by-hour or day-by-day billed-vs-actual comparison – which tells the agent what form the data takes. It does not clarify whether this is a cached retrieval or an on-demand computation, nor any cost/latency implications.

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

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

A single sprawling sentence that leads with a purpose clause rather than the operation, and buries the useful detail (hourly/daily billed-vs-actual comparison) mid-sentence. It is information-dense but poorly front-loaded and hard to parse quickly.

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, but for a one-parameter tool with zero schema description coverage the definition should still say what the tool does and when to reach for it. Editors and agents get an atmospheric picture of the evidence without a clear statement of the operation or call conditions.

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

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

Schema coverage is 0% and the single required parameter (incident_id) is only labeled 'Incident Id'. The description adds nothing – no mention of which incident to pass, where to obtain the ID (e.g., from list_incidents), or whether the incident must be in a particular state.

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

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

The description conveys the resource and its content – an incident's evidence, comprising key changes plus an hourly (or daily) comparison of provider billing against the company's own code, laid out as columns and rows. But it never states an action verb ('returns', 'compiles') and opens with an oblique use-case clause ('What a provider's refund process asks for'), so the agent must infer that this is a read that produces a reconciliation table. It also does nothing to distinguish it from siblings like get_incident, reconciliation_status, or explain_change.

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 usage signal is the embedded phrase about a 'refund process', which weakly implies dispute/chargeback contexts, but no explicit when-to-use, when-not-to-use, or which sibling to prefer is given. With get_incident and list_incidents available, the agent has no basis for choosing this tool.

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

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

Annotations only declare the generic safety profile (not read-only, not destructive, not idempotent); the description adds the key behaviors an agent can't infer: an email is actually sent, an elevated permission (owner/admin) is required, and confirmation should happen first. It stops short of covering what happens on duplicate invitations or expiry.

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, action front-loaded, each adding information (what it does, the required values, the confirmation step, the permission gate). Nothing 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?

An output schema exists so return values needn't be described, and the description covers purpose, permission requirement, and role options. Remaining gaps (duplicate-invite behavior, whether the invite expires) are minor for a two-parameter tool.

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

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

Schema description coverage is 0%, so the description has to carry the load. It does enumerate the allowed role values (admin, member, finance, viewer) and contextualizes email as the address to confirm, but says nothing about the default role being 'member' or email length bounds — the enum value is recoverable from the schema pattern anyway.

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: emails an invitation to join the organization, and names the role dimension. That distinguishes it cleanly from list_members, though it doesn't explicitly reference the sibling by name.

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?

"Confirm the address with the user first" and "Needs an owner or admin" give real preconditions for use. No explicit when-not-to-use or alternative-tool routing, so not 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 cover the safety profile (not read-only, not destructive, not idempotent), so the description adds real value by disclosing the lasting side effect that approve makes amount_usd 'the person's limit in every tool,' and that ask is scoped to the signed-in person. It does not mention permissions or reversibility, keeping it off 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?

A single front-loaded sentence built around the action parameter, with each parenthetical earning its place by tying parameters to branches. The nested parentheses make it slightly harder to parse than a short bulleted list would be, but there is no 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 four-parameter mutation tool with an output schema (so return values need no explanation) and annotations covering safety, the action semantics and the global effect of approve are covered. Still missing is authorization context for approve/deny and what happens on a rejected or duplicate request, which matters for a governance operation.

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 carries the burden and largely does: it maps amount_usd/note to ask, request_id/amount_usd to approve, and request_id to deny. The gap is that note's required/optional status for ask and the units of amount_usd (per month) are stated loosely rather than definitively.

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 three concrete operations (ask, approve, deny) against a specific resource, a spending limit request, and says who they apply to (the signed-in person, a request_id). It is clearly a request/approval tool, though it never names the sibling it is not (limits, set_budget) to sharpen 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 action breakdown implies when each branch applies (ask to raise your own limit, approve/deny to resolve someone's request), but there is no explicit when-to-use versus limits or set_budget, no statement of who may approve, and no prerequisite ordering such as whether a request must exist first.

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, idempotentHint, destructiveHint=false and closed-world scope, so the safety profile is fully covered by structured data. The description adds one piece of behavioral context the annotations cannot: the result is visibility-scoped ('the person may see'), meaning results are permission-filtered rather than exhaustive. It says nothing about result volume, ordering, or whether requests and limits are returned together — but with an output schema present and rich annotations, that omission is tolerable.

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

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

Only two sentences, but the first is a long, awkwardly constructed clause stack ('...the requests for a higher limit they answer or made') that slows comprehension instead of front-loading the verb. The routing hint to set_budget is buried at the tail rather than positioned where it would do the most work.

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

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

For a zero-parameter, read-only listing tool with full annotation coverage and an output schema, the description covers who the data is about (engineers and teams), what it contains (limits and higher-limit requests), and the visibility constraint. The remaining gap — nothing on pagination or result volume — is low-risk given there are no input parameters to control it and an output schema defines the shape.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate — baseline 4 applies. The mention of 'scope engineer or team' arguably belongs to set_budget rather than this tool, so it contributes little here, but there are no undocumented inputs to compensate for.

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 identifies the resource (engineers' and teams' monthly work and coding-agent limits, plus higher-limit requests) but never supplies a clean verb — 'the person may see' implies a read/list, yet the sentence is grammatically tangled left-to-right. It does distinguish itself from the mutating sibling set_budget, which helps an agent place it, but the core action remains inferred rather than stated.

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

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

The trailing clause 'Set a limit with set_budget' gives one explicit alternative and the condition that selects it, which is real routing value. However, the nearby sibling limit_request (clearly the request-creation counterpart) is never mentioned, and there is no when-not-to-use guidance — e.g. whether to prefer this over person_month or billing for limit data.

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

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

Annotations already cover read-only, idempotent, non-destructive behavior, so the bar is lower. The description adds meaningful domain logic by specifying the exact anomaly threshold and comparison window, which an agent could not infer from annotations alone.

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

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

A single dense sentence front-loads the core concept and definition with no filler. Every clause contributes to defining the anomaly rule.

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

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

An output schema exists, so return values need not be described, and the anomaly definition is complete. However, the days parameter is entirely unexplained and there is no guidance on when to use this tool versus related spike 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?

There is one parameter, days, with 0% schema description coverage. The description never mentions the lookback window or how days affects the median calculation, so it fails to compensate for the missing schema documentation.

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

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

The description names the resource (spend spikes) and precisely defines the detection rule: a day costing at least twice the same-weekday median over the preceding four weeks. It does not explicitly distinguish this list operation from the sibling get_spike, leaving some ambiguity.

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 explains what counts as an anomaly but not when to call this tool versus get_spike or explain_change, nor any exclusions such as minimum spend thresholds. Usage must be inferred.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and closed-world scope, so the safety profile is covered. The description adds value by disclosing that results pair provider-entered bills against Veqen's recorded figures, but says nothing about ordering, history depth, or pagination for what is presumably a growing monthly set.

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

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

A single efficient sentence with the key content (provider bills vs. Veqen's records) front-loaded and no filler. It loses a point only because the fragment form omits the action the tool performs, leaving the name to carry the verb.

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

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

With a rich annotation set and an output schema that presumably documents the returned bill/comparison fields, the description only needs to say what the call yields, which it does. The remaining gap is routing guidance relative to month_end and reconciliation_status, which a zero-param list tool arguably still needs.

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

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

Zero parameters, so the baseline is 4 and there is nothing for the description to compensate for. The schema is empty and the description correctly implies no filtering arguments are 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?

The description names a concrete resource — monthly provider bills entered or imported — and adds a useful scope nuance: figures are shown next to what Veqen recorded for the same month. But it is a noun phrase with no verb, never says it returns a list, and gives no differentiation from adjacent tools like reconciliation_status, month_end, or compare_models.

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 use this tool, when not to, or which sibling covers a related need. An agent must infer from the name alone whether this or reconciliation_status is the right call for month-end comparison work.

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, idempotentHint=true, destructiveHint=false, and closed-world, so the safety profile is fully covered by structured data. The description adds modest value by hinting the response is ranked toward limit proximity and scoped to the current period. It does not discuss scoping (all budgets org-wide?), ordering guarantees, or freshness of spend data.

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

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

One sentence, zero padding, and the most decision-relevant payload ('who's closest to the limit') is placed last for emphasis. Nothing repeats the name or title verbatim.

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 zero parameters, an output schema, and full annotation coverage, very little burden remains on the description, and it does describe the shape of the answer at a high level. The one gap is scope: it never says whether results cover the whole account or a single team/member, which for a 'list every budget' tool is worth one clause.

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. It correctly implies a no-filter, return-everything call rather than suggesting any hidden inputs.

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

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

Names the resource (budgets) and specifies the payload precisely: spent this period and proximity to the limit. It is clearly a read/list operation and cannot be confused with mutation siblings like set_budget or delete_budget. It stops short of an explicit verb and never names an alternative, so it lands at 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?

Usage is only implied — an agent infers you call this to survey budget status. There is no statement of when to prefer it over get_spend, forecast_spend, or credits_expiring, and no exclusions or prerequisites. Adequate for an obvious zero-arg list tool, but no routing help.

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