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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that an account is created, omitting side effects, permission needs, or implications for financial data. For a mutation tool, this is a critical gap with zero behavioral 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?

The one-sentence description is concise but under-specified, essentially restating the tool name without earning its place. It lacks front-loaded context or constraints that would help an agent parse the tool's purpose 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?

This tool creates a financial account with a required plan_id and nested account object, yet the description provides no context about prerequisites, side effects, or relationship to other resources like transactions or categories. The description is woefully inadequate for an agent to call this tool correctly and safely.

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

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

The description adds no meaning to the parameters beyond what the schema already provides. Schema coverage is only 50%, and the description fails to compensate for the undocumented 'account' object, leaving agents to infer the structure solely from the nested 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 'Creates a new account' is a direct restatement of the tool name 'createAccount', providing no additional detail about scope, parameters, or distinguishing behavior. It does not help differentiate the tool from siblings like createCategory or createPayee beyond the resource name, which is already evident from the tool name itself.

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 offers no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. An agent cannot determine context for invoking createAccount, such as whether plan_id must be validated or how it relates to other account operations.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only indicates a mutating action ('Creates') but does not mention side effects, required permissions, failure modes, or what the response contains.

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, direct sentence with no filler and is appropriately front-loaded. It is slightly under-specified, but the brevity is not itself a structural defect.

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

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

Despite having an output schema and a fairly detailed input schema, the description is minimal for a mutating tool of moderate complexity. It does not explain required relationships (e.g., category_group_id), goal-field behavior, or when creation is appropriate, so an agent is left without sufficient high-level 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?

The description adds no parameter-level meaning, but the schema already documents plan_id and most of the category object's fields in reasonable detail. At 50% schema coverage, the description does not meaningfully compensate, yet the schema provides enough to keep this at a baseline level.

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

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

The description uses a specific verb and resource ('Creates a new category'), which clearly states what the tool does. It is readily distinguishable from siblings like updateCategory, getCategories, and createCategoryGroup, so an agent can tell them apart without deeper inspection.

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

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

The description gives no guidance about when to use this tool versus alternatives like updateCategory or createCategoryGroup. It also omits any prerequisites or context about how category creation relates to plans or category groups.

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

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

With no annotations provided, the description must fully disclose behavioral implications. It only states 'creates', which implies mutation, but does not mention potential side effects, required permissions, or consequences like irreversible changes. The description fails to add behavioral context beyond the bare action.

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, concise sentence with no redundant information. It is appropriately front-loaded and efficiently communicates the core 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?

The description is minimal but sufficient for a basic create operation when combined with the schema and output schema. However, the absence of usage guidelines and behavioral transparency makes it incomplete for an agent that needs to decide when to call this tool and what to expect.

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

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

The schema description coverage is 50%, with the plan_id and name parameters already documented in the schema. However, the description adds no additional parameter semantics and does not compensate for the category_group object lacking its own description. The agent must rely solely on the schema, which is partially incomplete.

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 action (creates) and the resource (category group), making the tool's purpose unambiguous. However, it does not explicitly differentiate it from sibling tools like updateCategoryGroup or getCategories, though the resource name itself provides implicit differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives such as updateCategoryGroup or createCategory. It lacks context about prerequisites, typical scenarios, or any exclusions, leaving the agent to infer usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that a payee is created and does not mention required plan_id semantics, validation rules, side effects, permission needs, or behavior around the 'last-used' and 'default' plan options.

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 clear sentence with no filler or repetition. It is front-loaded and easy to parse, though it is so brief that it sacrifices informative content in other dimensions.

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 the input schema documents both required properties, which helps. However, the description lacks usage context, behavioral disclosure, and any differentiation from the many sibling create/update tools, making it insufficient for an agent to confidently select and invoke this tool correctly in 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 50%, and the description adds no parameter-level meaning beyond the schema. The plan_id 'last-used'/'default' semantics and the payee name maxLength constraint are already in the schema; the description does not help an agent understand the nested payee object or how plan_id relates to creation.

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 'Creates a new payee' uses a specific verb and resource, making the basic action clear. It implicitly contrasts with sibling updatePayee, though it does not mention the plan_id scoping or YNAB context that would fully distinguish it from other create operations.

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

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

The description gives no guidance on when to use this tool instead of alternatives like updatePayee or createCategory. The sibling list implies a CRUD context, but the description does not state any conditions, exclusions, or decision rules for selecting 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?

With no annotations, the description must carry the full burden of behavioral disclosure. It only clarifies that the date is in the future, which is redundant with the schema. It omits any mention of permissions, idempotency, response behavior, or side effects, which is critical for a create operation.

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 concise sentence with no filler, and it front-loads the core purpose. It is efficient, though arguably too sparse given the tool's complexity.

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 create operation with a nested object and an output schema, the description lacks essential behavioral context such as error handling, validation rules, or how it relates to other scheduled transaction tools. It is minimally sufficient but leaves the agent without guidance on important operational aspects.

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 50%, so the description should compensate for undocumented parameters. It adds no parameter-specific information and does not clarify the nested scheduled_transaction object structure or the meaning of required fields beyond what the schema already states. The 'future date' clarification is redundant with the schema description.

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 verb 'creates' and the resource 'scheduled transaction', and adds a clarifying parenthetical that it is a transaction with a future date. This differentiates it from regular transaction creation tools like createTransaction, though it could be more specific about the scheduling aspect.

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 is provided on when to use this tool versus alternatives such as updateScheduledTransaction or deleteScheduledTransaction. There is no mention of typical use cases, prerequisites, or conditions that would make this the preferred choice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It correctly signals a mutating create operation and discloses the future-date restriction. However, it does not address auth requirements, failure semantics, or split-transaction limitations, leaving some behavioral context to the input schema.

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

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

The description is front-loaded with the core action, then explains the two input shapes and the exclusion. It is concise and every sentence adds value, though it could be slightly tighter by omitting the repetitive phrase 'will be created.'

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 very rich input schema and existing output schema, the description covers the key selection and invocation facts: single vs. multiple and the scheduled-transaction exclusion. It does not discuss authentication or rate limits, but those are less critical for an agent that already has a plan_id and can rely on the detailed schema.

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

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

Schema description coverage is 33%, so the description should compensate for undocumented top-level parameters. It adds meaning by explaining the transaction/transactions body-shape distinction and the scheduled-date restriction, but it adds little about plan_id or the inner field semantics, which remain schema-dependent.

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 the specific verb 'Creates' with the resource 'transaction', and clearly distinguishes between single ('transaction' object) and multiple ('transactions' array) creation. It also explicitly excludes scheduled transactions, which distinguishes this tool from the sibling createScheduledTransaction.

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

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

The description gives clear context on when to use this tool: for one or many non-scheduled transactions, selected by body shape. It explicitly states that scheduled transactions cannot be created on this endpoint, which is a clear when-not. However, it does not name the alternative tool (createScheduledTransaction) or mention when importTransactions might be preferable.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool deletes a scheduled transaction, which implies mutation but provides no information about side effects, reversibility, permissions, or failure behavior. For a destructive operation, this is a significant gap in transparency.

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

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

The description is extremely concise, consisting of a single sentence with no redundant words. It is appropriately sized for a simple delete operation, though it lacks any structural elements like lists or separators. The brevity is a strength, but it could be slightly more structured to include relevant context, so a 4 is 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?

For a destructive tool with no annotations and an output schema, the description is notably incomplete. It does not explain what a scheduled transaction is, any preconditions for deletion, or what happens on success or failure. Given that the tool has two required parameters and is a mutation, more context is needed for an agent to use it safely and correctly.

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

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

Schema description coverage is 100%, with both plan_id and scheduled_transaction_id fully described in the input schema. The tool description adds no additional parameter context beyond what the schema already provides. Since the schema handles parameter semantics well, the description adds no extra value, justifying the baseline score of 3.

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

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

The description states a specific verb 'deletes' and a clear resource 'scheduled transaction', making the purpose unambiguous. It is clearly distinct from sibling deleteTransaction, which deletes regular transactions, and from createScheduledTransaction/updateScheduledTransaction. The name and description align perfectly, so an agent can immediately understand what the tool does.

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

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

The description gives no guidance on when to use this tool versus alternatives. With a sibling deleteTransaction, there is potential confusion about which deletion tool to pick for different scenarios. No context, prerequisites, or exclusions are mentioned, leaving the agent to infer usage based solely on the resource type.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb "Deletes" signals destructiveness, but nothing is said about whether the deletion is permanent, what side effects occur on linked data, or error conditions. For a destructive tool, this is a significant transparency gap.

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

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

The single sentence is grammatically complete, but at four words it is under-specified rather than appropriately concise. For a destructive operation with no annotations, the brevity is a deficiency — there is no front-loaded scope, caveat, or guidance, just a restatement of the name.

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

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

This is a destructive tool with no annotations and no usage guidance, yet the description contains only a restatement of intent. It doesn't address permanence, when to use it, prerequisites, or any behavioral caveats an agent would need to invoke it correctly. The effort level is well below what the tool's complexity demands.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema fully documents plan_id (including the "last-used"/"default" special values) and transaction_id. The description adds nothing about parameters, but the schema already carries that weight.

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?

"Deletes a transaction" states a specific verb and resource, and the resource type distinguishes it from the sibling deleteScheduledTransaction. However, it's essentially a restatement of the tool name with no added scope detail, so it's clear but minimal.

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

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

The description gives no guidance on when to use this tool versus alternatives like updateTransaction (which can change transaction state) or deleteScheduledTransaction. There's no context, no exclusions, and no when-not-to-use guidance, so an agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Returns' implies a read operation, but the description does not explicitly state that it is read-only, idempotent, or free of side effects, nor does it mention any permissions or error behavior.

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

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

The description is a single focused sentence with no filler. It is front-loaded and easy to parse, even if it is minimal.

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 retrieval tool with a fully documented schema and an output schema present, the core mechanics are covered. However, the lack of usage guidance and behavioral context means the description alone is not fully self-sufficient for an agent deciding when to call it.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description adds no extra meaning beyond what the schema provides, which is acceptable given the schema's completeness.

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 'Returns a single account' states a clear verb and resource, and the name getAccountById reinforces that it retrieves one account by ID. It distinguishes itself from getAccounts (plural) but does not explicitly mention the 'by ID' aspect in the description itself.

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 about when to use this tool versus getAccounts or other account-related tools. The required account_id parameter implies the intended use case, but the description does not state it or provide any alternative selection criteria.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Returns all accounts' and does not disclose that results are scoped to a plan, that 'all accounts' may be filtered by last_knowledge_of_server, or whether this is a read-only operation. The description is not misleading, but it is severely under-informative.

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 extremely short and front-loaded, which is good, but it is under-specified rather than concise. A single sentence that omits scope and filtering behavior does not earn full credit for structure because it fails to convey essential context.

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

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

The tool has an output schema and 100% schema coverage, but the description is too thin for a list endpoint with a required plan_id and an optional server-knowledge filter. An agent cannot tell from the description that 'all accounts' are scoped to a plan or that the result set can be a delta. The output schema may describe the response shape, but the description does not explain the tool's selection 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 description coverage is 100%, so the baseline is 3. The description itself adds no parameter meaning beyond the schema, but the schema already documents plan_id and last_knowledge_of_server well, including the special 'last-used' and 'default' values. The description does not need to compensate.

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 'Returns all accounts' states a clear verb and resource, but it does not distinguish this from sibling tools like getAccountById or getTransactionsByAccount. It is minimally clear but lacks scope details such as whether it returns accounts for a plan or across the entire system.

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 is provided about when to use this tool versus alternatives. The description does not mention that it is the list counterpart to getAccountById, nor does it explain the plan_id requirement or when to use 'last-used' or 'default' plan selection. The schema covers parameter mechanics but not usage 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?

With no annotations, the description carries the behavioral disclosure burden. It usefully discloses that amounts are specific to the current plan month and UTC, which is non-obvious context beyond the schema. It also implies a read-only operation via 'Returns', though it does not discuss pagination or auth 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?

Two sentences with no filler. The core behavior is front-loaded, and the timezone/month specificity is added in a second concise sentence. Every word earns its place.

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

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

Given the output schema exists and parameter descriptions are complete, the description covers the important behavioral nuances: grouping and month/UTC specificity. It is slightly incomplete in that it does not guide the agent toward sibling tools for single-category lookups, but that is a usage-guidance gap more than a completeness gap for invoking this 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 100%, so the schema fully documents both plan_id and last_knowledge_of_server. The description adds no parameter-level meaning beyond the schema, which matches the baseline of 3.

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

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

The description states a specific verb and resource: returns all categories, and adds the grouping dimension ('grouped by category group'), which clearly distinguishes it from getCategoryById. The scope is unambiguous and the agent can select it correctly 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 its use case: retrieving all categories rather than a single category. However, it does not explicitly mention alternatives like getCategoryById or provide when-not-to-use guidance, so the routing is left mostly to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description does add a key behavioral trait: the amounts are specific to the current plan month (UTC), which informs the agent that the returned data is time-dependent and may differ from other queries. However, it does not disclose other potential behaviors such as error handling (e.g., what happens if the category is not found), whether it is read-only (likely but not stated), or any authentication requirements. With no annotations, this is a moderate gap. The description adds some valuable context but not comprehensive behavioral transparency.

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

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

The description is extremely concise and front-loaded. The first sentence states the primary purpose, and the second sentence adds a crucial caveat about month-specific amounts. There is no wasted wording, and the most critical information (the return's time-dependence) is placed immediately after the purpose. This is an efficient and well-structured description.

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

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

Given that the tool has an output schema (which likely details the return structure), the description does not need to explain return format. The primary missing piece is error handling and prerequisites (e.g., must have a plan_id that exists), but the output schema and input schema cover the core. The description is complete enough for an agent to successfully call the tool with the given parameters and understand the key nuance of the data. Thus, a 4 is appropriate; it's nearly complete but could mention error cases or permissions.

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

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

Schema description coverage is 100%, meaning both parameters (plan_id and category_id) are fully documented in the input schema. The description adds no additional meaning to the parameters themselves; it only clarifies the returned data's month-sensitivity. Since the schema already explains the parameters well, the baseline of 3 is appropriate. The description does not need to repeat parameter details, but it also doesn't add extra semantics beyond the schema, so a 3 is fair.

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 tool's function: 'Returns a single category.' This directly and specifically describes the resource (category) and the action (get by ID). It is distinguished from sibling tools like 'getCategories' (plural) and 'getMonthCategoryById' (which is per-month) by the singular focus and the added detail about month-specific amounts. The specificity of 'single category' and the scope clarification make it a strong purpose statement.

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 provides some implied usage context by explaining that amounts are specific to the current plan month (UTC), which is useful for understanding the data returned. However, it does not explicitly state when to use this tool over alternatives like 'getCategoryById' versus 'getMonthCategoryById' or when the month-specific amounts might be important. The guidance is clear enough for an agent to understand the tool's purpose, but it lacks explicit exclusions or alternatives. A 3 is appropriate because it gives context but does not fully guide selection among siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only restates the basic function and does not reveal anything about ordering, aggregation, pagination, plan scoping, or relationship to money movements. An agent gets no behavioral context beyond the literal 'returns all' statement.

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 short sentence with no filler. It is front-loaded with the core functionality, though it may be too terse to convey useful nuances. It earns a high score for concise structure but loses a point for extreme brevity at the expense of context.

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 existence of closely related sibling tools like getMoneyMovements and getMoneyMovementGroupsByMonth, the description is incomplete. It does not explain what a money movement group is, whether the result is plan-scoped, or how it differs from the month-specific variant. The output schema and parameter schema help, but the description alone leaves an agent uncertain about correct tool selection.

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

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

Schema description coverage is 100%, and the plan_id parameter is well documented, including special values like 'last-used' and 'default'. The description adds no additional parameter meaning beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb and resource: 'Returns all money movement groups.' It is clear that the tool lists the full set of money movement groups, which distinguishes it implicitly from the by-month variant. However, it does not explicitly differentiate itself from siblings like getMoneyMovements or getMoneyMovementGroupsByMonth.

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 is given about when to use this tool versus alternatives such as getMoneyMovementGroupsByMonth or getMoneyMovements. The description does not mention any conditions, exclusions, or scenarios where a sibling would be more appropriate.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'Returns' implies a read-only operation, but the description does not mention pagination, sorting, or any plan-scoping behavior beyond the parameters. It is not misleading, but it adds little beyond the obvious read 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?

A single sentence conveys the operation, the resource, and the filter with no wasted words. The key qualifier 'specific month' is front-loaded and immediately clarifies the tool's scope.

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

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

The tool is simple, the schema covers both required parameters, and an output schema exists, so return-value details are unnecessary. However, the description lacks any distinction from closely named sibling tools, which is a notable completeness gap for an agent choosing among many similar endpoints.

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

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

Schema description coverage is 100%, so both month and plan_id are already documented in the schema. The description adds no extra meaning about the parameters, such as the meaning of 'current' or 'last-used', so it stays at the baseline.

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 clear verb ('Returns') with a specific resource ('money movement groups') and a clear temporal filter ('specific month'). It does not explicitly distinguish itself from the sibling getMoneyMovementGroups, which could be confused as the non-monthly variant, so it misses the final bit of differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives such as getMoneyMovementGroups, getMoneyMovementsByMonth, or getMoneyMovements. The agent must infer the intended use case solely from the tool name and the schema.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that it 'returns all money movements' without mentioning read-only behavior, filtering, pagination, or any side effects. For a tool that likely queries data, the lack of detail about what 'all' means in relation to the required plan_id is a notable gap.

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

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

The description is a single sentence with no fluff. It is efficiently worded, though it is so brief that it may be under-specified rather than concise. It earns a 4 because there is zero waste, but the brevity contributes to completeness issues.

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 existence of siblings like getMoneyMovementsByMonth and getMoneyMovementGroups, the description is insufficient to distinguish this tool's scope or output. It does not clarify whether 'all' means all time or all for the given plan, and the output schema exists but is not referenced. The description is too thin for an agent to use this tool confidently without exploring other definitions.

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

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

The schema provides 100% coverage for the single parameter (plan_id) with a detailed description including special values. The tool description adds no additional meaning about parameters, so it neither helps nor harms. Baseline 3 is appropriate given high schema coverage.

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

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

The description uses a clear verb ('returns') and resource ('money movements'), so the core action is unambiguous. However, it doesn't differentiate from siblings like getMoneyMovementsByMonth or getMoneyMovementGroups, which also return money-movement-related data, so an agent cannot tell them apart from the description alone.

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

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

There is no guidance on when to use this tool versus its siblings. No mention of scope (e.g., all time vs. a specific month) or conditions that would make getMoneyMovementsByMonth more appropriate. The description gives no exclusions or alternatives, so an agent has no basis for selection.

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

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

No annotations are present, so the description carries the full burden, but it only states that movements are returned. It does not mention pagination, ordering, read-only status, or behavior around the 'current' special month value. For a simple getter, this is minimally adequate.

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

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

One short sentence, front-loaded with the verb and object, with no wasted words or repetition of the input schema. It is appropriately concise.

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

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

For a two-parameter read tool with a fully documented schema and an output schema present, the description plus metadata is largely sufficient. Only the absence of alternative-tool guidance keeps it from being fully complete.

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

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

Schema description coverage is 100%, so the schema fully documents plan_id and month. The description adds no parameter-level detail beyond the 'specific month' scope, matching the baseline of 3.

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

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

The description uses a specific verb ('Returns') and a specific resource ('money movements') scoped to a month, which distinguishes it from the un-scoped getMoneyMovements and the group-level siblings. It is not merely a restatement of the tool 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?

The phrase 'for a specific month' implies the tool is for month-scoped lookups, but there is no explicit when-to-use guidance or comparison to alternatives such as getMoneyMovements for unfiltered queries. An agent must infer selection logic from the name and sibling 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?

With no annotations, the description carries the behavioral burden. It does clarify that amounts are month-specific and UTC-based, which is useful, but it does not explicitly state that this is a read-only operation, possible error cases, or other behavioral constraints.

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

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

Two short sentences with no filler. The core action is front-loaded, and the additional month/UTC detail earns its place.

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

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

For a simple single-resource retrieval with a full input schema and an output schema, the description covers the essential scoping. It could add an explicit note about read-only behavior or the relationship to non-month category lookups, but nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents month, plan_id, and category_id. The description adds mild contextual value by noting that amounts are plan-month-specific, but it does not add per-parameter meaning beyond the schema.

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

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

"Returns a single category for a specific plan month" states a specific verb and resource, and the month scoping clearly separates it from siblings like getCategoryById. The purpose is immediately identifiable without inspecting 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 gives clear context: this is the tool for a single category scoped to a plan month. It does not explicitly name alternatives or say when not to use it, so it stops short of full routing guidance.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states that it returns a single payee, with no mention of whether it is read-only, what happens if the payee is not found, or any error conditions. For a getter, this is minimal disclosure.

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

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

The description is a single, focused sentence with no wasted words. It is front-loaded with the core action and resource, achieving maximum conciseness while still conveying the primary 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?

For a simple get-by-ID tool, the description combined with the full schema and output schema is largely complete. An agent can infer how to call it: provide plan_id and payee_id, and expect a single payee object. It lacks usage context, but that is covered under usage guidelines. Given the simplicity, it is adequate.

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

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

Schema description coverage is 100%, so both parameters are fully documented in the input schema. The description adds no extra meaning beyond the schema, meeting the baseline of 3 for high schema coverage.

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

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

The description states a specific verb and resource: 'Returns a single payee.' The word 'single' differentiates from the sibling getPayees, which returns multiple. However, it doesn't explicitly contrast with other get-by-ID tools like getPayeeLocationById, relying on the tool name for disambiguation. Purpose is clear but sibling differentiation could be stronger.

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 provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or pointing to getPayees for listing. Usage context is entirely implied by the name and schema.

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

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

No annotations are provided, so the description carries the full burden. It only says 'Returns a single payee location' and discloses nothing about error behavior, authentication, read-only status, or edge cases like 'last-used'/'default' plan handling beyond the schema.

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

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

A single six-word sentence with no filler or repetition. It is appropriately short for a simple retrieval tool, though it could have added sibling differentiation without much cost.

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

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

With an output schema present and full schema parameter coverage, the description is mostly sufficient for this low-complexity getter. However, it lacks any usage guidance or clarification of how it differs from sibling list tools, leaving a small but real gap.

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

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

Schema description coverage is 100% and both plan_id and payee_location_id are already described clearly in the schema. The description adds no parameter-level meaning, so the baseline of 3 applies.

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

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

States the specific verb 'Returns' and the resource 'payee location' unambiguously, and the singular 'single' and 'byId' help differentiate it from sibling list tools like getPayeeLocations and getPayeeLocationsByPayee. It is clear, 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?

No guidance is provided on when to use this tool versus the closely related getPayeeLocations or getPayeeLocationsByPayee. The agent must infer entirely from the name and schema that this is for fetching one specific location by ID.

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

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

With no annotations, the description carries the behavioral burden. It makes the read-only nature clear via 'Returns' and indicates the unfiltered scope with 'all', but it does not mention required plan context, auth, or pagination behavior. The output schema covers the return shape, which softens the gap.

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

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

The description is a single front-loaded sentence with no filler or redundant wording. Every word contributes to stating the action and object.

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 one documented parameter and presence of an output schema make the core call usable. However, the description gives no indication of when to choose this endpoint over its by-payee sibling, leaving some contextual ambiguity for an agent.

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

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

Schema description coverage is 100%, and the single plan_id parameter already has detailed documentation including 'last-used' and 'default' values. The description adds no parameter-specific meaning, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Returns') and resource ('all payee locations'), clearly identifying a list operation. 'All' signals the unfiltered variant, though it does not explicitly distinguish from the sibling getPayeeLocationsByPayee.

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 is given on when to use this tool versus alternatives such as getPayeeLocationsByPayee or getPayeeLocationById. An agent must infer the intended scope from sibling tool names rather than from the description.

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

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

With no annotations, the description must carry behavioral disclosure itself; 'Returns' does signal a read-style operation and the 'all...for a specified payee' scoping is clear. It does not mention plan_id behavior, pagination, auth, or empty-result behavior, but for a simple lookup this is a minimally viable disclosure.

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

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

A single, front-loaded sentence with no filler. It communicates the exact result set in the fewest 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?

For a simple read endpoint the description plus fully documented required parameters and an output schema is largely sufficient to call the tool correctly. The main missing piece is explicit sibling differentiation, but the tool name and 'for a specified payee' make the selection reasonably clear.

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

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

Schema description coverage is 100%, so the parameters are already fully documented; the description adds only the implicit mapping of 'specified payee' to payee_id. This meets the baseline but does not enrich the schema's parameter meaning.

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

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

The description uses a clear verb and resource ('Returns all payee locations') and scopes it to a specified payee, so the tool's function is immediately understandable. It does not explicitly contrast with siblings such as getPayeeLocations or getPayeeLocationById, so it stops short of full differentiation.

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

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

No guidance is given about when to choose this tool over getPayeeLocations or getPayeeLocationById, and no exclusions or prerequisites are mentioned. The agent must infer from the name that payee_id is the filter.

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

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

No annotations are provided, so the description carries the full burden. It only says 'Returns all payees' without disclosing behavior such as pagination, ordering, whether deleted payees are included, or the meaning of 'all' in the context of the plan. The schema hints at change tracking via last_knowledge_of_server, but the description doesn't explain the implications of that parameter or any 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?

The description is a single concise sentence that is front-loaded with the core action. It is appropriately sized, though it could add a bit more context without becoming 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?

Given the tool has an output schema and 100% schema coverage, the description doesn't need to explain return values. However, for a list tool with no annotations, it lacks important context such as whether the result is paginated, how to handle large lists, or the relationship to plan_id. The description is minimal and leaves the agent to infer behavior from the schema alone.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds no additional parameter meaning beyond what the schema provides. Baseline 3 is appropriate because 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?

The description 'Returns all payees' clearly states the verb and resource, and the tool name getPayees aligns with that. It distinguishes from siblings like getPayeeById and getPayeeLocations, though it doesn't explicitly name them. It is clear but lacks explicit differentiation from similar list tools.

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

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

The description implies usage for retrieving all payees, and the schema provides context for optional filtering via last_knowledge_of_server. However, there is no explicit guidance on when to use this tool versus alternatives like getPayeeById or getPayeesByPayee (not present but similar). No exclusions or alternative routing 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?

With no annotations, the description carries the disclosure burden. It does add value by warning that the response is a comprehensive export rather than a summary, but it does not address read-only guarantees, error behavior, or the fact that providing last_knowledge_of_server narrows the result to changed entities. The word 'all' is also slightly too absolute given that filter.

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

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

Two short sentences front-load the core behavior. The second sentence mostly restates the first, but the 'full plan export' analogy adds a useful size/scope signal that justifies 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 no elaboration. Combined with the schema-documented parameters and the 'full plan export' framing, the description gives an agent enough to call the tool correctly; the only notable omission is explicit guidance about sibling selection.

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 plan_id and last_knowledge_of_server are already well documented in the schema. The description adds no parameter-level meaning beyond implying that the response includes related entities, which is the baseline expectation.

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 ('Returns'), names the exact resource ('a single plan'), and adds scope ('all related entities', 'effectively a full plan export'). This clearly distinguishes it from the list-oriented sibling getPlans and from other by-id getters.

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 'full plan export' phrasing implies this is the tool to use when a complete plan payload is needed, but it never names alternatives or states when not to use it. Siblings like getPlans or getPlanSettingsById exist, so the routing decision 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?

No annotations are present, so the description must carry the behavioral burden. It only restates the return outcome and does not disclose read-only behavior, error cases, or any side effects; it adds no behavioral context beyond the name and purpose.

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 entire description is one short, front-loaded sentence with no filler. It is appropriately concise for the tool's simple 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?

For a simple getter with full schema coverage and an output schema, the description is minimally adequate. However, it omits usage guidance and behavioral context, so an agent must rely on the tool name and sibling list to determine when this tool is the right choice.

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 input schema already covers 100% of the parameters with examples and special values (e.g., 'current', 'last-used', 'default'). The description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Returns') and a specific resource ('a single plan month'), and the word 'single' distinguishes it from the sibling getPlanMonths. This makes the tool's function immediately identifiable.

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 explicit when-to-use or alternative routing is provided. The word 'single' only implies that this is for retrieving one plan month rather than the list from getPlanMonths, so usage context 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?

No annotations are present, so the description carries the full behavioral burden. It only states the return behavior and does not disclose the side-effect profile, authentication expectations, or how last_knowledge_of_server affects results; 'Returns' implies read-only but is not explicit.

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?

At one short sentence, the description has no filler and is easy to scan. However, it is under-specified: it lacks the plan context and any sibling distinction, so the brevity is more minimalism than well-structured completeness.

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 two-parameter read with a full output schema, the schema handles parameter and return-value needs. The description is incomplete as a selection aid because it gives no usage context or alternative routing, and with no annotations the safety profile is not clarified.

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

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

The schema covers both parameters 100%, including plan_id's special values ('last-used', 'default') and the semantics of last_knowledge_of_server. The description adds no parameter-level information, so the schema baseline of 3 applies.

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

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

The description uses a clear verb ('Returns') and identifies the resource ('all plan months'). It is not a tautology and, via the plural 'months', hints at the distinction from the singular getPlanMonth sibling, though it does not name it or mention the required plan_id context.

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

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

No when-to-use or alternative guidance is provided. It does not tell the agent to use getPlanMonth for a single month or getPlans for plan-level data, so the agent must infer selection from the name and schema.

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

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

With no annotations, the description carries the behavioral burden, and 'Returns' conveys a read operation with no side effects. It does not disclose pagination, default behavior of include_accounts, or what 'summary information' includes. This is basic transparency but with meaningful gaps.

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 concise sentence with no filler, and the core result ('Returns plans list') is front-loaded. It is appropriately short for a simple read endpoint, though it lacks any structural detail like examples or parameter mention. Fine for conciseness, but not exceptional.

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-optional-parameter read endpoint with an output schema, the description gives the essential purpose but leaves 'summary information' undefined and omits how include_accounts changes the result. It also doesn't connect to sibling tools for full-detail lookups. Slightly under-complete for an agent selecting among many plan-related 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 input schema fully describes include_accounts, so the 100% schema coverage establishes a baseline of 3. The description does not mention the parameter or clarify its effect on the returned summary, so it adds no semantic value beyond the schema. Score remains at baseline.

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 ('Returns') and identifies the resource ('plans list'), and the word 'list' differentiates it from getPlanById and getPlanSettingsById. However, 'summary information' is vague and doesn't specify what fields are summarized, 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?

No explicit when-to-use or when-not-to-use guidance is given; there is no mention of getPlanById for single-plan detail or getPlanSettingsById for settings. The only signal is the plural 'plans list,' which weakly implies this is the collection-level endpoint. This is implied usage at best.

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?

'Returns' implies a read-only operation, which is the main behavioral trait an agent needs for a getter. With no annotations, though, the description does not disclose auth expectations, error behavior, or explicitly confirm that nothing is mutated; this is a gap but a minor one for a simple retrieval.

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 one short, front-loaded sentence with no filler or repetition. Every word contributes to stating the tool's core 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?

The input schema fully documents plan_id, and an output schema exists, so the return shape does not need to be described. However, the definition leaves the relationship to getPlanById unclear and says nothing about usage context, making it adequate but not fully 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?

The single parameter plan_id is fully documented in the schema, including special values like 'last-used' and 'default', so the schema carries 100% of the parameter meaning. The description adds no parameter information, but none is needed beyond the schema.

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

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

The description names a specific operation ('Returns settings') on a specific resource ('a plan'), which is enough to identify the tool's purpose. It does not explicitly differentiate getPlanSettingsById from getPlanById or getPlans, so the 'settings' versus 'plan' distinction 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 statement about when to use this tool versus getPlanById or getPlans. No prerequisites, exclusions, or alternative routing are provided, so the agent receives no 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?

No annotations are present, so the description carries the burden of behavioral disclosure. It states the core read behavior ('Returns a single scheduled transaction') but doesn't disclose error handling, not-found behavior, or any operational constraints beyond the schema. This is minimal yet not misleading.

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 the verb and object stated directly and no filler. Every word earns its place for this simple operation.

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 defining return values and a fully documented parameter schema, the description only needs to identify the operation, which it does effectively. It lacks usage context, but the simplicity of the tool and the structured data make the definition adequate for invocation.

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

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

Schema description coverage is 100%, so both plan_id and scheduled_transaction_id are already fully described in the schema. The description adds no parameter-level meaning beyond what the schema provides, leaving the baseline of 3 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 uses a specific verb ('Returns') and a resource ('a single scheduled transaction'), clearly distinguishing this from sibling tools like getScheduledTransactions (plural) and create/update/delete variants. Although it doesn't explicitly name an alternative, the singular wording and focus on a single by-ID lookup make the operation 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?

The description provides no guidance on when to use this tool versus alternatives such as getScheduledTransactions, and it doesn't state prerequisites or scenarios. The only clues come from the tool name and parameter names, which is not explicit usage guidance.

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

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

No annotations are provided, so the description must carry the full burden. It does not disclose any behavioral traits such as the read-only nature, potential side effects, pagination, or that the response is a list. It merely repeats the name without adding depth.

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 short sentence, which is concise and front-loaded with the core action. However, it is slightly under-specified as it does not mention return format or context, but for the limited content, it is efficient.

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

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

Given the rich output schema (likely including pagination and list structure) and no annotations, the description is incomplete. An agent lacks needed context about list semantics, ordering, or how to handle the last_knowledge_of_server parameter effectively, making it under-specified for a list-fetching tool.

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

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

The schema description coverage is 100%, so the schema already documents both parameters in detail, including the special values for plan_id and the filtering behavior of last_knowledge_of_server. The description adds no additional parameter information, so it meets the baseline but does not go beyond.

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 the verb 'Returns' and the resource 'all scheduled transactions', which is clear. However, it does not distinguish it from siblings like getScheduledTransactionById or getTransactions, which could be confused for similar list operations.

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 provides no guidance on when to use this tool versus alternatives. An agent cannot tell if it should use getScheduledTransactions or getTransactions for a given scenario, and no exclusions or conditions are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool returns a transaction, with no mention of error handling, authentication requirements, rate limits, or what happens if the transaction does not exist. The description adds minimal behavioral context beyond the action itself, which is insufficient for a tool with no annotation support.

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 short sentence, which is appropriately concise and front-loaded. However, it is under-specified: it lacks any contextual details that would help an agent decide when to use it. The brevity is fine, but the content is minimal, so it earns an average score rather than higher for 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?

Given the tool's complexity is low (a simple get-by-ID operation) and an output schema exists, the description need not explain return values. However, the presence of many sibling tools and the lack of annotations mean the description should provide more context on how this tool differs from others and any relevant behavioral caveats. The current description is too sparse to be complete in this 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?

The input schema has 100% description coverage for both parameters (plan_id and transaction_id), so the schema already documents them well. The tool description adds no additional parameter information, but since the schema is complete, the baseline score of 3 applies. The description does not compensate with any extra usage nuance, so it stays at baseline.

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 'Returns a single transaction' clearly states the verb (returns) and the resource (single transaction). It is unambiguous about the operation, though it does not explicitly mention 'by ID' beyond the tool name, nor does it differentiate from the many other transaction-related siblings such as getTransactions or getTransactionsByAccount. The purpose is clear enough for an agent to understand the basic function.

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 provides no guidance on when to use this tool versus alternatives. There is no mention of scenarios where fetching a single transaction by ID is appropriate, nor any exclusion criteria. Given the large set of sibling tools (e.g., getTransactions, getTransactionsByAccount), this lack of routing guidance leaves the agent to infer usage from the name 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose that pending transactions are excluded, which is a behavioral trait not visible in the schema. However, it does not mention other behaviors such as pagination, ordering, or that it returns transactions across all accounts (as opposed to a specific account). This is minimal but non-zero transparency.

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

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

The description is a single, short sentence that immediately states the purpose and the key exclusion. It is front-loaded and contains no unnecessary words. Every part earns its place, making it an excellent example of conciseness.

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

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

With an output schema present and detailed parameter descriptions, the description only needs to clarify scope and usage context. It mentions the exclusion of pending transactions but does not clarify that this returns all transactions for a plan across all accounts, which is important given the existence of filtered sibling tools. This makes it incomplete for an agent to decide when to call it. It's adequate but not comprehensive.

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 input schema has 100% description coverage, so the description does not need to explain parameters. The description adds no parameter-specific information; it only mentions a behavior (excluding pending) that isn't a parameter. Thus, it provides no added value for parameter understanding, and the baseline 3 is appropriate given the high schema coverage.

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

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

The description states a clear action and resource: 'Returns plan transactions.' It adds a specific exclusion ('excluding any pending transactions') which adds precision. However, it does not differentiate from sibling tools like getTransactionsByAccount or getTransactionsByCategory, which also return transactions but with filters. An agent could infer this is the unfiltered plan-level endpoint, but the description doesn't make that 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?

There is no guidance on when to use this tool versus the many sibling tools that filter by account, category, payee, or month. The description does not mention alternatives or conditions for selecting this over others. An agent would need external knowledge to decide which transaction endpoint to call.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does add a useful non-obvious behavior by stating that pending transactions are excluded, and 'Returns' implies a read-only operation. However, it omits any context about authentication, rate limits, possible pagination, or the fact that optional filters can narrow the result 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?

The description is one concise sentence with no filler. It front-loads the core result ('Returns all transactions for a specified account') and then appends the key behavioral caveat ('excluding any pending transactions').

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 covers return values and the input schema covers parameters, so the description need not repeat those. However, given the large family of transaction-related siblings, the description would be more complete if it mentioned why getTransactionsByAccount should be preferred over getTransactions or getTransactionsByCategory. As written, it is minimally viable but leaves the routing decision to the agent.

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

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

Schema description coverage is 100%, and the schema already thoroughly documents plan_id, account_id, type, since_date, until_date, and last_knowledge_of_server, including formats, defaults, and allowed enum values. The description adds no parameter-level meaning beyond the schema, so the 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 states a clear verb and resource: 'Returns all transactions for a specified account'. It also specifies a meaningful scope restriction, 'excluding any pending transactions', and the 'specified account' clause distinguishes it from sibling transaction getters like getTransactionsByCategory, getTransactionsByPayee, and getTransactionsByMonth.

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 provides no guidance on when to choose this tool over the closely related getTransactions, getTransactionsByCategory, getTransactionsByPayee, or getTransactionsByMonth. It tells the agent what the tool does, but not when it is the right alternative, so an agent must infer selection criteria from the name 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?

With no annotations provided, the description carries the full disclosure burden. It contributes one genuinely useful behavioral fact beyond the schema — the exclusion of pending transactions — which materially changes what results an agent should expect. However, it leaves other behaviors undisclosed (e.g., whether subcategory transactions are included, ordering, pagination), so disclosure is thin for a tool with zero annotation coverage.

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

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

A single tight sentence with zero filler — the core purpose is front-loaded before the pending-transaction qualifier. It is appropriately economical, though it forgoes a small opportunity to include a sibling-routing clause without losing conciseness.

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

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

The tool has 6 params, yet the description is complete enough for the core query because the schema covers all parameters and an output schema exists. The notable gap is decision-making context: among five similar transaction-listing siblings and with no annotations, the description does not help an agent choose this tool over alternatives or anticipate which transactions are excluded beyond pending ones.

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

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

Schema description coverage is 100%, so the baseline of 3 applies; the schema already documents plan_id, category_id, and all optional filters with their defaults. The description adds no parameter-level meaning beyond noting the category scope, which is appropriate given the schema's richness.

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 ('returns'), resource ('transactions for a specified category'), and adds a distinguishing behavioral qualifier ('excluding any pending transactions'). This differentiates it clearly from siblings like getTransactions, getTransactionsByAccount, getTransactionsByPayee, and getTransactionsByMonth — an agent can route correctly without opening any schema.

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

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

Usage context is implied rather than explicit: the name and description make it clear this is the category-filtered variant among several transaction-listing siblings, but the description never says when to choose it over getTransactions or the other by-X variants, nor does it state exclusions. There is no misleading guidance, but the agent is left to infer the selection rule from the name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add a genuinely useful behavioral trait by stating that pending transactions are excluded, which is not inferable from the tool name or input schema. It does not cover every possible behavioral aspect, but for a read-only retrieval tool this is reasonably transparent.

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 filler or repetition. Every phrase adds value: the action, the resource, the month scope, and the pending-transaction exclusion.

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 exists and all parameters are documented, the description covers the main invocation context: what is returned and the key exclusion. It could be more complete by stating how this tool relates to date-range siblings, but that is a gap in usage guidance rather than a fatal omission.

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

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

Schema description coverage is 100%, so the parameters are already fully documented in the input schema. The description adds no extra parameter-level meaning beyond the general 'specified month' phrasing, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Returns') and resource ('transactions') with a clear scope ('for a specified month') and a meaningful exclusion ('excluding any pending transactions'). It does not explicitly name or contrast sibling tools like getTransactionsByAccount or getTransactions, so it falls just short of full sibling differentiation.

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

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

The description implies when to use the tool: when a month-scoped transaction list is needed. However, it gives no explicit guidance on when not to use it or which sibling alternative (e.g. getTransactions, getTransactionsByAccount, getTransactionsByCategory) might be more appropriate for other query shapes.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It discloses that pending transactions are excluded, which is a useful behavioral trait. However, it doesn't mention other behaviors like default date range (one year ago), pagination, or that the result may be empty. The schema provides some parameter details, but the description doesn't add much beyond the pending exclusion.

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 sentence that is concise and front-loads the core purpose. It includes the key exclusion (pending transactions) without unnecessary detail. It could be slightly more structured, but it's efficient and clear.

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

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

The tool has an output schema and 100% schema coverage, so return values and parameters are documented. The description is adequate for a filtered-list tool, but it lacks explicit guidance on when to use it versus siblings and doesn't mention default behaviors like the one-year date default. Given the complexity (6 params, output schema), a bit more context would help, but it's not critically incomplete.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no additional parameter semantics beyond what the schema provides. Baseline 3 is appropriate since 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?

The description clearly states the tool returns all transactions for a specified payee and excludes pending transactions. It identifies the resource (transactions) and the filter (payee), which distinguishes it from sibling tools like getTransactionsByAccount and getTransactionsByCategory. However, it doesn't explicitly name a sibling alternative, so it doesn't fully differentiate itself.

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 context: use this when you need transactions filtered by payee, and it notes the exclusion of pending transactions. It doesn't explicitly state when to use this over alternatives like getTransactions or getTransactionsByAccount, but the payee-specific scope is clear from the name and description. No explicit exclusions or alternative routing is 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Returns' implies a read-only operation, but the description does not mention authentication requirements, error behavior, or response characteristics. This is minimal disclosure for a tool with zero annotations.

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 filler. Every word contributes to stating the operation and resource.

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 a simple getter operation, the description covers the essential calling context. It could explicitly clarify that no parameters are required or define 'authenticated user', but the schema already confirms the empty parameter list.

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 and the input schema confirms an empty properties object, so there is no parameter documentation burden. The baseline of 4 applies because there are no parameters 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?

Uses the verb 'Returns' and names the resource 'authenticated user information', making the operation clear. It is distinct from all sibling tools, which target plans, accounts, categories, payees, transactions, and similar resources. The only minor ambiguity is that 'authenticated user' is not expanded to 'current user'.

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 is provided about when to use this tool versus alternatives. While no sibling tool appears to target user information, the description does not explicitly state applicability, prerequisites, or exclusions. The agent is left to infer usage 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?

With no annotations provided, the description carries the behavioral disclosure burden. It states the action (imports transactions), the scope (all linked accounts), that it initiates the import, and that the response contains imported transaction IDs. It does not discuss idempotency, failure modes, or side effects, but the core behavior is well disclosed.

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-loaded with the main action. The second sentence adds context about linked accounts but partially repeats the first sentence ('this endpoint initiates that import'). Still, there is no filler and the length is 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?

For a single-parameter endpoint with an output schema, the description covers the action, the scope, and the response contents. It could mention behavior with no available transactions or repeated calls, but as it stands it supplies what an agent needs to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already fully documents plan_id, including special values like 'last-used' and 'default'. The description adds no additional parameter semantics, so the baseline score of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Imports available transactions on all linked accounts for the given plan.' This clearly distinguishes the tool as the automatic-import action, not a manual create or read operation. The UI analogy ('equivalent of clicking Import') further anchors exactly what the endpoint performs.

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

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

It provides clear context for when to use the tool: when there are linked accounts and you want to import available transactions from the financial institution. It does not, however, explicitly mention alternatives or when-not-to-use cases, such as distinguishing from createTransaction for manual entry.

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

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

With no annotations, the description carries the burden of behavioral disclosure, but it only signals 'Update'. It does not mention side effects, auth/write permissions, the fact that null removes existing goal targets, or restrictions such as internal category groups being disallowed.

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 one-liner is front-loaded and free of fluff, but it is underspecified rather than efficiently complete for a tool with three required parameters and a complex nested payload. It does not earn its place as a meaningful description.

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

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

Although an output schema exists and the input schema is rich, the description lacks the context needed to orient an agent among many category-related siblings and to understand the update's scope. Key constraints and behavioral context are left entirely to the schema.

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

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

The description adds no parameter meaning beyond the schema, and schema coverage is 67%, below the high-coverage baseline. The per-field schema descriptions are useful, but the tool description does not clarify that the 'category' object is the update payload or how partial updates behave.

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 'Update a category' restates the tool name (updateCategory) almost verbatim and adds no differentiating details. It is clear about the basic mutation but does not distinguish the tool from siblings such as updateMonthCategory or updateCategoryGroup.

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 about when to use this tool instead of createCategory, updateMonthCategory, or getCategoryById. The agent must infer selection solely from the name and schema.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only implies mutation via "update" but does not state whether the update is partial or full, whether existing values are replaced, what permissions are needed, or what side effects occur.

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?

While the description is short and free of filler, it is under-specified rather than truly concise. The single sentence merely restates the tool name and does not earn its place by adding operational value.

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

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

With three required parameters, one nested object, and no annotations, the description is too thin to be complete. It leaves out update semantics, required field behavior, and context about where category_group_id comes from, even though 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 67%, with plan_id and the category_group.name property documented, but category_group_id is only described as "The id of the category group." The description adds no meaning beyond the schema and does not help an agent understand how to obtain or use the IDs correctly.

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 "Update a category group" is essentially a restatement of the tool name and provides no distinguishing scope, fields, or behavior. It does not differentiate from sibling tools like updateCategory, updateMonthCategory, or createCategoryGroup, so an agent gains little clarity beyond the name itself.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention prerequisites such as needing an existing category_group_id, nor does it point to createCategoryGroup for initial creation or updateCategory for category-level updates.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does clarify that only `budgeted` can be updated, but it does not state whether the update is partial or full, how non-budgeted fields are treated, required permissions, or error behavior. For a mutation endpoint, this is thin.

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

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

Two short sentences with no filler; the key constraint is front-loaded immediately after the verb. Every word earns its place.

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

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

The schema and output schema carry most of the calling details, and the description covers the one critical constraint. Missing are explicit when-to-use guidance and side-effect semantics, but these are not required to construct a syntactically correct call given the schema richness.

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

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

The schema already documents all four parameters with formats and special values (`month` ISO/'current', `plan_id` 'last-used'/'default', `budgeted` milliunits), so the baseline is 3. The description adds the meaningful constraint that `budgeted` is the only mutable field, which helps explain the purpose of the nested `category` object.

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 the specific verb 'Update', the resource 'a category for a specific month', and the only allowed field (`budgeted`). This clearly differentiates it from siblings like `updateCategory` (category-wide) and `getMonthCategoryById` (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?

The description implies this is the tool for month-scoped category budget changes and limits updates to `budgeted`, but it does not explicitly state when to prefer it over `updateCategory` or mention preconditions like plan/month existence. Usage guidance is present but entirely 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it fails to carry it. "Update" is the only behavioral signal, and it comes from the tool name itself; the description does not state whether the update is a merge or replace, whether it is reversible, what response to expect, or what happens to omitted 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?

The description is a single short sentence with no redundancy, which is superficially concise. But this is under-specification rather than purposeful conciseness — it contains no information beyond the tool name and fails to earn its place as a definition.

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

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

For a mutating tool with a nested object parameter, an output schema, and zero annotations, this description is drastically incomplete. It neither explains the update semantics nor gives the agent any context about behavior, edge cases, or the response, leaving the agent to infer everything from the schema and name.

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

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

The schema already documents all parameters (plan_id with last-used/default semantics, payee_id, and the nested payee.name), so the parameter burden is mostly carried by the schema at 67% coverage. However, the description adds zero parameter-level meaning and does not compensate for the remaining gaps, such as explaining that only the name field is editable or how the nested payee object behaves.

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?

"Update a payee" is a direct restatement of the tool name updatePayee with no added specificity. It states verb+resource but does not clarify what aspects of a payee can change (e.g., only the name, per the schema) or how this differs from createPayee, making it functionally a tautology.

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 provides no guidance on when to use this tool versus siblings such as createPayee, getPayees, or getPayeeById. There is no indication of prerequisites (e.g., needing plan_id resolution) or exclusions, so the agent gets zero routing help.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that a transaction is updated, with no information about partial vs. full replacement, validation constraints, side effects, permissions, or response behavior. This is insufficient for a mutation tool.

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

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

The description is a single concise sentence with no filler, and the core action is front-loaded. It is appropriately brief, though the brevity comes at the cost of behavioral and usage detail.

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 input schema is rich and an output schema exists, but the description still omits crucial context for a mutation operation: when to use it, what update model applies, and any constraints or side effects. For a nested-object tool with no annotations, this is not complete enough for an agent to invoke it 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?

The description adds no parameter-level meaning beyond the schema. With schema description coverage at 67%, the schema documents plan_id, scheduled_transaction_id, and the nested scheduled_transaction object, but the description does not clarify update semantics, required fields, or special values like 'last-used' or 'default' for plan_id.

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

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

The description uses a specific verb and resource: 'Updates a single scheduled transaction.' It clearly identifies the target resource and the singular nature of the operation, which helps distinguish it from create/delete scheduled transaction tools. However, it largely restates the tool name and does not explicitly differentiate from related update tools like updateTransaction.

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 alternatives such as createScheduledTransaction, deleteScheduledTransaction, or updateTransaction. The description only states what the tool does, not the conditions or prerequisites for using 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?

With no annotations, the description carries the full burden of behavioral disclosure, but it only states that the tool mutates a transaction. It does not mention permissions, side effects, idempotency, or important behaviors like split transaction limitations, which are present in the schema but absent from the description.

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 one-sentence description is concise and front-loaded, with no filler words. It is efficient, though arguably too sparse to fully support the tool's otherwise complex schema.

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

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

Given the complexity of the transaction update semantics, the description is far too thin. It does not explain when to use updateTransaction over updateTransactions, how to handle split transactions, or what update fields are available; the rich input schema only partially compensates for this absence.

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 adds no parameter meaning: it does not mention plan_id, transaction_id, or the transaction payload. Schema description coverage is 67%, and while the nested transaction object is well-documented in the schema, the description itself fails to compensate for the partially covered 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 uses a specific verb ('Updates') and a clear resource ('a single transaction'), so the agent knows what operation this tool performs. The word 'single' also helps distinguish it from the sibling updateTransactions, though it does not elaborate beyond that.

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 is given about when to use this tool versus alternatives such as createTransaction, updateTransactions, or deleteTransaction. There is no mention of batch updates, prerequisites, or conditions that would route an agent to a sibling 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?

No annotations are provided, so the description must carry the full behavioral burden. It only states the lookup mechanism ('by id or import_id'), with no mention of side effects, whether fields are partially updated, response structure, or constraints like not providing both id and import_id. This is minimal disclosure for a mutation 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?

One short, front-loaded sentence that contains the essential purpose and identifier mechanism. No filler, every word earns its place.

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

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

Despite having a complex nested schema and no annotations, the description provides only a minimal one-liner. It does not explain the batch usage context, contrast with the singular updateTransaction, or mention constraints like 'not both id and import_id' or 'import_id cannot be updated'. The output schema exists, but the overall context is under-specified for a tool of this complexity.

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

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

Schema description coverage is 50% (plan_id has a description, transactions array does not). The description adds the requirement that each transaction be identified by either id or import_id, which is helpful but does not fully compensate for the missing array-level description. The nested schema already contains detailed field descriptions.

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

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

States a specific verb ('Updates'), the resource ('multiple transactions'), and the key identifier mechanism ('by id or import_id'). The plural 'multiple' clearly differentiates it from the sibling updateTransaction (singular).

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 'multiple transactions' implies this tool is for batch updates, but there is no explicit guidance about when to use it versus updateTransaction for a single transaction, or importTransactions for import-based operations. No exclusions or alternatives are named.

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