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

With no annotations, the description carries the full behavioral disclosure burden. It explicitly states 'Read-only', which is useful and prevents misuse, but it does not describe output format, pagination behavior, or any additional side-effect context. The read-only disclosure is valuable, but more behavioral detail would be expected.

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 that conveys the core action, resource, key filtering dimensions, and read-only nature. Every word earns its place; there is no redundancy or filler.

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

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

For a read-only query tool with no output schema and no annotations, the description covers the essential purpose and key filter concepts. However, it lacks detail on expected return values, pagination behavior, exact field names for the controlling variables, and guidance relative to overlapping siblings like m3_graphql.

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%, with only 'order' and 'where' having generic GraphQL descriptions. The tool description adds meaning by tying the where filter to controlling variables (cost center, project, activity), but skip and take remain undocumented in both schema and description, and exact filter syntax is not provided.

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 a specific action ('Query') and resource ('accounting journal'), and even names the controlling variables it can filter by. It does not explicitly compare against siblings, but the resource and read-only qualifier are enough to distinguish it from the many creation/deletion tools in the list.

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: use this tool when you need to query the accounting journal with controlling variables. However, it provides no explicit when-not-to-use guidance or alternatives, such as pointing to m3_graphql for more general GraphQL queries or to other list tools for related data.

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

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

With no annotations, the description carries the full burden, but it only says 'Read/write'. This is misleading because the input schema only has pagination parameters, indicating a read-only list operation. There is no explanation of returned data, pagination behavior, or any side effects.

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

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

While short, the description wastes space on confusing phrases like 'controlling variable' and the contradictory 'Read/write'. The only helpful part is 'Query activities'; the rest detracts from clarity rather than earning its place.

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

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

For a tool with no annotations and no output schema, the description is severely inadequate. It does not explain what 'activities' means in this M3 context, how to interpret the results, or how this differs from related tools like m3_crm_activities.

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

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

Schema description coverage is 0%, and the description provides no information about the 'skip' and 'take' parameters. It does not compensate for the missing schema documentation, leaving the agent without any understanding of pagination or limits.

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 verb and resource ('Query activities'), so it is not a tautology. However, the phrase 'controlling variable' is cryptic and 'Read/write' muddies the purpose by suggesting mutation, which the schema does not support. It also does not distinguish this from sibling tools like m3_crm_activities.

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 alternatives. It does not reference m3_crm_activities or m3_create_activity, nor does it mention any conditions or exclusions. The agent is left 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?

There are no annotations, so the description carries the behavioral disclosure burden. It does state this is a read/query operation and lists what data categories are included. However, it does not mention response shape, pagination behavior, or how the GraphQL order/where clauses affect results.

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

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

A single sentence that front-loads the verb and resource and then compacts the detail scope into a short list. Every phrase contributes meaningful information with no repetition or filler.

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

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

For a simple read tool with no required parameters and fully documented schema parameters, the description provides the essential context: what is queried and what level of detail is returned. The lack of an output schema leaves return format unspecified, but the listed data categories give sufficient expectation 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?

The input schema has 100% description coverage for all four parameters (skip, take, order, where), so the schema already explains them. The description adds no extra parameter-level detail, which is acceptable given the full 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 specific verb ('Query') and resource ('address book (contacts/partners)') and enumerates the fields returned, making the tool's scope unmistakable. It also distinguishes itself from sibling create/delete address tools by clearly positioning itself as a read operation.

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 clearly signals that this tool is for querying address book data with full detail. It does not explicitly state when-not-to-use it, but the presence of m3_create_address and m3_delete_address among siblings makes the intended usage boundary inferable.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It correctly conveys a read-only listing operation and the fact that it returns GUIDs, but it does not describe response details, error behavior, or any instance-level prerequisites. It is adequate but not rich.

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

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

Two sentences with no filler. The core purpose is front-loaded, and the second sentence immediately tells the agent what to do with the returned GUIDs.

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 parameterless list tool with no output schema, the description is complete: it states what is listed, what the output includes (GUIDs), and how the output should be used downstream. An agent can invoke it correctly without further detail.

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 is empty with 0 parameters, so there is nothing for the description to clarify. The baseline for zero-parameter tools is 4, and the description contains no misleading parameter references.

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 ('List') and resource ('all agendas') and clarifies the domain term as companies/databases. It also names the follow-up tool m3_set_agenda, clearly positioning this tool as the GUID source among many siblings.

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

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

The description gives a clear workflow: call this tool to obtain GUIDs, then use m3_set_agenda to select an agenda. It lacks explicit 'when not to use' guidance or alternative comparisons, but the intended context is clear from the stated next step.

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 explicitly discloses that the operation is read-only, which is the most important behavior for a listing tool with zero parameters. It does not describe output shape, but that is not needed to invoke the tool safely.

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 states the action, resource, scope, and safety qualifier with no wasted words. Every element 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 zero-parameter, read-only listing tool, the description is sufficient for an agent to decide to call it and invoke it correctly. It leaves the exact return fields unspecified, but with no output schema or parameters this is a minor gap.

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

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

The tool has zero parameters and 100% schema coverage, so the schema imposes no burden. Per the 0-param baseline, the description needs no parameter documentation, and the resource scope is already clear.

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?

Description uses a specific verb ('List') and clearly identifies the resource ('bank accounts and cash desks configured in Money S3'). The 'read-only' qualifier differentiates it from sibling mutation tools such as m3_create_bank_document and m3_create_account.

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

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

The description makes the use case clear: retrieving the configured bank accounts and cash desks. It implicitly excludes creation/management actions via the read-only qualifier, though it does not name sibling alternatives explicitly.

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. 'Query' clearly signals a read-only operation, and the listed output attributes give some idea of what is returned. But it does not mention pagination behavior, filtering semantics, response shape, or any access considerations.

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 conveys the core purpose and key output dimensions with no filler. Every phrase contributes meaningful 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 four parameters, no output schema, and no annotations, so the description should provide more operational context. It leaves out how to use the GraphQL filter/order parameters, pagination defaults, and what the actual response structure looks like, making it incomplete for reliable invocation.

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

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

Schema coverage is only 50%, and the description adds no parameter-level meaning. It does not explain skip/take pagination semantics or how to construct the GraphQL 'where' and 'order' clauses, so an agent has to infer from bare schema metadata.

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 the specific verb 'Query' and identifies the resource as 'bank documents (payments, transfers)', clearly distinguishing this read tool from the sibling create/delete bank document tools. It also highlights distinctive output aspects (VAT breakdown, payment status, controlling variables).

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

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

The description implies the tool is for querying bank documents, and the verb 'Query' contrasts with the create/delete siblings. However, it gives no explicit guidance about when to prefer this over alternatives like m3_graphql or m3_cash_desk_documents, and it does not state when not to use it.

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

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

With no annotations, the description is the sole source of behavior. It discloses that the tool returns cash desk documents and highlights VAT breakdown, payment status, and controlling variables. However, it does not mention pagination, result shape, filtering/ordering behavior, or any access/side-effect considerations, leaving significant behavioral 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?

A single front-loaded sentence with no filler. The verb and resource appear first, followed by the key output qualifiers.

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 query tool with no output schema, no annotations, and vague terms like 'controlling variables', the description is too thin. It does not explain pagination defaults, GraphQL filter/order syntax, return container, or how this tool relates to the many sibling query/create tools.

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

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

Schema coverage is only 50%; order and where are described merely as GraphQL clauses, while skip and take have no description. The tool description does not explain these parameters or connect them to the listed fields, so it fails to compensate for the schema's sparse parameter documentation.

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

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

Description opens with a specific verb and resource: 'Query cash desk (register) documents'. It further narrows the scope by naming the returned aspects (VAT breakdown, payment status, controlling variables), and the read-oriented wording distinguishes it from sibling create/delete cash-desk 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?

No guidance is given on when to choose this tool over alternatives such as m3_graphql, m3_bank_documents, or m3_create_cash_desk_document. The word 'Query' weakly implies read-only usage, but there is no explicit when-to-use or when-not-to-use instruction.

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

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

With no annotations provided, the description carries the behavioral transparency burden. It explicitly discloses the read-only nature, which is useful, but it does not describe behavior around pagination, ordering, result shape, or any limitations. The basic safety trait is covered, but deeper behavioral context is missing.

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 immediately states the operation and resource, with 'Read-only' adding safety context. There is no redundant phrasing or filler, and the most important information is front-loaded.

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

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

For a simple read-only query tool with three optional parameters and no output schema, the description is adequate but minimal. It tells the agent what the tool does and that it is safe, but it does not explain return values, pagination defaults, or the semantics of the order clause, leaving some context to be inferred from the schema.

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

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

Schema description coverage is only 33%, and the description adds no information about the parameters. It does not clarify how skip, take, or order should be used, and the schema's only description ('GraphQL order clause') is vague. With low coverage, the description should compensate, but it does not.

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 ('Query') and a clear resource ('chart of accounts (accounting plan)'), which distinguishes it from the many sibling tools such as m3_accounting_journal or m3_graphql. The 'Read-only' qualifier further clarifies the operation type.

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: this is the tool for querying the chart of accounts and it is read-only. However, it does not explicitly state when to prefer this over alternatives nor does it mention any exclusions or related tools, so guidance is only implicit.

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

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

With no annotations, the description carries the behavioral burden and does well by listing three concrete checks the call performs. It implies a read-only diagnostic via 'Test' and 'verifies'; the only minor gap is not specifying the exact success/failure return shape.

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

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

One sentence with the primary verb and resource front-loaded, followed by three concrete verification targets. Every phrase adds information and there is no filler.

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

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

For a zero-parameter health-check tool this is largely complete: an agent knows exactly what will be tested and how it differs from the sibling operations. The definition could add the response/result format, but the absence is minor for such a simple diagnostic.

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 zero parameters, so the baseline is 4 and there are no parameter semantics to document. The description's mention of auth, endpoint, and agenda access clarifies what the no-arg call is actually validating.

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 ('Test'), names the exact resource ('Money S3 API connection'), and enumerates what is verified: OAuth2 auth, endpoint reachability, and agenda access. This clearly distinguishes it from the many sibling data-operation 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 tool's intended use as a connectivity/auth diagnostic is clear from 'verifies OAuth2 auth, endpoint reachability, and agenda access.' It does not explicitly state when not to use it or name alternatives, but there are no equivalent sibling connection tests.

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

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

Annotations are absent, so the description carries the full burden. It discloses only that the operation is read-only, which is valuable but minimal. It does not mention pagination behavior, response shape, whether results are ordered by default, or any access prerequisites — gaps that matter for a tool whose only behavioral hint is one word.

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 primary action is stated first and the safety qualifier second. 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?

With no annotations, no output schema, and only 50% parameter schema coverage, the description leaves an agent without enough context to call confidently. It does not explain what constant symbols represent, how filtering/pagination interact, or what the response contains — a thin definition for a tool in a large unfamiliar API surface.

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%: 'order' and 'where' get minimal GraphQL-clause descriptions, while 'skip' and 'take' are undocumented (though their names, defaults, and min/max bounds make them self-evident). The description adds zero parameter meaning and does not compensate for the half of the schema that lacks documentation.

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

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

States a specific verb (List) and resource (constant symbols, with the Czech gloss). The 'Read-only' qualifier reinforces it as a lookup tool rather than a mutation. It is clear enough to distinguish from the many m3_create_*/m3_delete_* siblings, though it doesn't explicitly contrast with any similar list tool.

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

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

'Read-only' hints that this is a safe lookup, but the description provides no when-to-use context, no mention of why one would fetch constant symbols, and no exclusions or alternatives. In a sibling list of 60+ tools, the agent gets no routing help beyond the obvious 'this is the list tool for constant symbols.'

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 full responsibility for behavioral disclosure. The 'Read/write' claim is vague and misleading given that the schema only permits skip/take pagination parameters and has no mutation-related inputs. It does not state side effects, permissions, pagination behavior, or output structure.

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 very short, but the phrases 'controlling variable' and 'Read/write' add noise rather than value. The core query statement is buried among ambiguous fragments and does not earn 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 paginated query tool with no output schema or annotations, the description should at least clarify that this is a read-only listing operation and how pagination works. It does not, and the 'Read/write' fragment actively undermines the otherwise simple query intent.

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

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

Schema description coverage is 0%, and the description does not mention the skip/take parameters, their defaults, or their limits. The tool description adds no semantic context for how pagination works or what results the agent should expect.

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 'Query cost centers (střediska)', giving a specific verb and resource. However, the trailing 'Read/write' creates ambiguity about whether this tool also performs mutations, and the 'controlling variable' phrase does not clarify the purpose further.

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 like m3_create_cost_center. The description provides no context about prerequisites, filtering, or situations where another 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It does state 'Read-only,' which is a valuable and accurate safety signal for an AI agent. However, it does not disclose pagination behavior, output shape, or any limitations beyond what the schema already exposes.

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 only five words, front-loaded with the action and resource, and contains no filler. Every word earns its place, and the 'Read-only' qualifier adds useful behavioral information without bloat.

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 simple list tool, but there is no output schema and the description gives no detail about return values, pagination expectations, or filter semantics. The schema covers skip/take defaults, but an agent still receives minimal context for a tool that supports GraphQL-style filtering.

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

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

Schema description coverage is only 50%, and the description adds no parameter-level meaning. It does not mention how skip, take, order, or where affect the listing, so the description fails to compensate for the undocumented parameters in the schema.

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

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

The description uses a specific verb ('List') and a distinct resource ('country codes'), making it immediately clear what the tool does. It is unique among the siblings, and the 'Read-only' qualifier further clarifies that this is a lookup operation.

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, and there are many sibling list tools. It does not mention any exclusions, prerequisites, or cases where another tool like m3_graphql might 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 full behavioral disclosure burden. It does disclose an important non-obvious trait: creation happens via an 'Async import queue'. However, it does not explain consequences such as delayed creation, how to check success, or what failures look like.

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

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

The description is two short sentences with no filler. The primary purpose is front-loaded, and the async note adds meaningful behavioral context in minimal space.

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

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

For an 8-parameter mutation with no annotations and no output schema, the description is thin. It does not explain how to verify that the queued creation succeeded, what error or validation behavior to expect, or how the async import queue affects eventual consistency.

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 parameter-level detail beyond what the input schema provides, 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 states a specific verb ('Create'), a resource ('account'), and a context ('chart of accounts'). It clearly identifies the tool's function and is distinguishable from the many sibling m3_create_* tools that target different objects.

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

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

The description implies the obvious usage: use this when you need to create an account in the chart of accounts. However, it provides no explicit alternatives, prerequisites, or exclusions, nor does it mention when the async import queue behavior matters for choosing this tool.

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

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

With no annotations, the description carries the full burden. It does disclose a key behavior: the operation is queued asynchronously ('Async import queue'). However, it does not explain what that means for the caller (e.g., no synchronous result, how to verify success, possible delays), leaving a meaningful 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?

Two short sentences with no filler. The core action is front-loaded, and 'Async import queue' packs an important behavioral detail into few words. Every token 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 3-parameter create tool, the essential action is stated, but the asynchronous queue behavior is left unexplained, and with no output schema the agent does not know what to expect as a return. This is adequate but has clear gaps, such as how to confirm successful creation and what happens on failure.

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 adds no parameter-specific meaning beyond the schema; 'code' and 'name' remain defined only by their schema descriptions. The 'import queue' phrase hints at how parameters are consumed but does not clarify their semantics.

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

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

The description states a specific verb ('Create') and resource ('activity'), reinforced by the Czech gloss 'činnost', which clearly distinguishes it from listing-type siblings like m3_activities. However, it does not explicitly name or differentiate against sibling create tools, so it falls just 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 guidance is given on when to use this tool versus alternatives, and no exclusions or prerequisites are stated. The only hint is 'Async import queue', which implies asynchronous behavior but does not tell the agent when this tool should be selected over other create/list tools.

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

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

No annotations are present, so the description carries the full disclosure burden. The 'Async import queue' clause is a valuable behavioral trait — it tells the agent results are not synchronous. However, it omits other important behaviors for a mutation tool: validation failure handling, duplicate detection, eventual-consistency implications, and how to confirm the import succeeded.

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

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

One sentence front-loads the create intent, scopes the relevant fields, and appends the async behavior note. There is zero filler and no redundant restatement of the tool 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?

For a tool with 23 parameters, no annotations, and no output schema, the one-sentence description is inadequate. It does not identify the required 'name' parameter, explain what the call returns, or tell the agent how to check on the queued async import — critical information for an agent that must verify side effects.

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 61%, leaving roughly 9 of 23 parameters undocumented. The description partially compensates by grouping parameters into meaningful categories — business/invoice addresses, banking, credit limits, and maturity terms — which maps onto the schema, but it adds no per-parameter meaning beyond what the schema already provides.

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 ('Create') and resource ('new entry in the address book'), and enumerates the field scope (addresses, banking, credit limits, maturity terms). This clearly separates it from the sibling list tools like m3_address_book and m3_delete_address by verb and intent, though it never explicitly names an alternative.

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

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

A single sentence states what the tool does but gives no when-to-use or when-not-to-use guidance. With over 60 siblings including m3_create_account and many other create_* tools, nothing helps an agent decide between creating an address versus an account, a contact, or a stock card, and no prerequisites or exclusions 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?

With no annotations, the description carries the full behavioral disclosure burden. It does reveal that the operation uses an async import queue and supports controlling variables, but it omits side effects, success/failure behavior, return values, and other consequences of creating a document.

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 very short and front-loaded with the core action. However, phrases like 'Supports controlling variables' and 'Async import queue' are cryptic and would carry more value if expanded slightly.

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

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

For a 14-parameter creation tool with no annotations and no output schema, this description is too sparse. It lacks information about required setup, how the async queue processes requests, what response or confirmation the agent can expect, and how to handle errors or partial failures.

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 71%, so the schema already handles most parameters, but the description adds little beyond the vague phrase 'controlling variables.' It does not clarify the remaining undocumented parameters like constantSymbol, variableSymbol, specificSymbol, or documentNumber.

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 ('Create') and a specific resource ('bank document (payment)'), and clarifies the document subtype as a payment. This distinguishes it from sibling tools like m3_create_cash_desk_document, m3_create_issued_invoice, and m3_delete_bank_document.

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 alternatives such as m3_create_cash_desk_document or m3_create_issued_invoice. The purpose implies bank payment creation, but there is no explicit context, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does mention 'Async import queue,' implying the creation is queued rather than immediately completed, but it does not explain side effects, validation, failure behavior, or what the agent should expect after invocation. The async hint is useful but underdeveloped.

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

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

The description is short and front-loaded with the core operation. It does not waste words, though the two appended notes are dense and would benefit from more precise phrasing.

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

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

For a 10-parameter creation tool with no annotations and no output schema, the description is too thin. It omits important context such as whether isExpense defaults to income, how the async import queue affects confirmation or response, and what 'controlling variables' means in practice.

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 80%, so most parameters are already documented in the schema. The description adds no concrete parameter-level meaning; 'controlling variables' is only a vague hint and does not clarify documentNumber, variableSymbol, or how controlling variables map to 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 clearly states the verb ('Create') and resource ('cash desk (register) document'), which distinguishes it from other m3_create_* siblings. The phrase 'Supports controlling variables' is vague and does not clarify what that capability entails.

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 m3_create_bank_document, m3_create_stock_document, or m3_create_internal_document. There are no stated prerequisites, exclusions, or conditions that would lead an agent to prefer 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds the key fact that creation is asynchronous via an import queue, which is helpful. However, it does not explain what happens after enqueueing, whether a job identifier is returned, how to monitor success or failure, or whether duplicates are rejected.

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: two short sentences, each earning its place. It front-loads the purpose in the first sentence and adds a relevant behavioral trait in the second. There is no redundant wording or repetition of schema details.

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

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

For a simple three-parameter creation tool, the description covers the core purpose and the asynchronous nature. However, with no annotations and no output schema, an agent is left uncertain about the operational semantics of the async queue, such as how to confirm the cost center was actually created or if any error handling is needed.

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 descriptions, so the baseline is 3. The tool description adds no parameter-specific meaning beyond naming the resource, but because the schema documents code, name, and definitionShortcut, the description does not need to compensate heavily.

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: 'Create a cost center (středisko).' It clearly states what the tool does and the parenthetical clarifies the domain term. Among many sibling m3_create_* tools, the resource is unambiguous, and the 'Async import queue' note distinguishes this as a queued creation operation.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as m3_cost_centers or other m3_create_* tools. The 'Async import queue' hint implies a batch/import workflow, but the description does not state conditions, exclusions, or which sibling should be used for non-async creation or for reading cost centers.

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 transparency burden. It does disclose an important behavioral trait: 'Async import queue', signaling that creation is asynchronous and queued. However, it does not explain what the agent should expect after invoking, such as confirmation behavior, error handling, or side effects.

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

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

The description is extremely short and front-loaded with the primary purpose. The second fragment, 'Async import queue', is structurally awkward but conveys key behavior without waste. It earns its place despite being terse.

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

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

For a mutation tool with no annotations and no output schema, the description leaves too much unexplained. It does not define what an internal document is, what 'controlling variables' means, how the async queue affects the caller, or what a successful invocation returns. The agent would still have significant uncertainty after reading 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 coverage is 75%, so most parameters are already described in the input schema. The description adds little parameter-level meaning beyond the vague phrase 'controlling variables'. It does not compensate for the two undocumented parameters (documentNumber and variableSymbol).

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 core action: 'Create an internal document', which clearly identifies the resource and operation. The added phrase 'with controlling variables' gives some domain context but is vague about what those variables are. It is distinct enough from siblings like m3_internal_documents and m3_delete_internal_document.

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 guidance is provided about when to use this tool versus alternatives. 'Async import queue' hints at a behavioral context, but there is no mention of when this create tool is preferred over the many other m3_create_* tools or what disqualifies 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 behavioral disclosure burden. It does disclose a key trait beyond the schema: the operation is asynchronous and goes through an import queue. However, it does not explain implications such as how to confirm creation, whether the response is immediate, or what happens on failure.

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 very brief: one clear purpose sentence and one short behavioral note. It is front-loaded with the main action. 'Async import queue' is a fragment, but it is still efficient and earns its place.

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

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

For a creation tool with no output schema and no annotations, this description is incomplete. It does not explain what a caller receives, how to verify success of the async queue operation, or how this relates to listing/deleting inventory documents. An agent would need to guess at post-call behavior.

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

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

The description adds no parameter-level information, but the input schema already documents dateOfIssue, warehouseCode, and definitionShortcut, covering 75% of parameters. The one gap, documentNumber, has no description and the tool description does not help clarify its meaning or format.

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

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

The description clearly states the action ('Create') and the resource ('inventory/stocktaking document'), and the synonym 'stocktaking' clarifies what an inventory document is. However, it does not explicitly differentiate from sibling tools like m3_create_stock_document or m3_create_stock_card, 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?

Aside from the terse note 'Async import queue,' there is no guidance on when to use this tool versus alternatives such as m3_create_stock_document or m3_inventory_documents. No exclusions, prerequisites, or selection criteria 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 behavioral disclosure burden. It adds a meaningful trait: the operation is queued to an async import, so the caller should not assume synchronous completion/reflection. But it does not disclose what the call returns, what happens on import failure, or any permission/prerequisite 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?

A single front-loaded sentence places the action first and the async caveat second. There is no redundant or extraneous wording. Short but information-dense.

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 plus detailed schema covers the main concerns for invoking the tool: parameters are fully documented and the async behavior is flagged. However, with no output schema and no annotation, the absence of any return-value or post-call behavior explanation leaves a gap. This is adequate but not 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 already documents every parameter with descriptions and formats. The description adds no parameter-level information. Per the baseline for high coverage, this dimension is adequate at 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?

States a specific action ('Create'), a specific resource ('new issued (outgoing) invoice'), and names the target system ('Money S3'). The parenthetical 'outgoing' differentiates it from the sibling m3_create_received_invoice. The title/name is expanded rather than repeated, so this is not 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 implies the use case: creating an outgoing invoice. However, it never explicitly contrasts this with alternatives like m3_create_received_invoice for incoming invoices or m3_issued_invoices for reading issued invoices. The usage context is clear but the exclusion/alternative guidance 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?

With no annotations, the description must carry behavioral disclosure. It does disclose the async import queue behavior, which is useful, but it does not explain side effects, queue semantics, whether validation is synchronous, or what happens on failure. This is partial but not rich 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 compact and front-loaded: the first sentence states the primary purpose, and the second flags async behavior. However, the phrase 'controlling vars' is jargon and could be clearer without much added length.

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 14 parameters, no annotations, and no output schema, the description is too brief to fully instruct an agent. It does not explain the async queue workflow, required input semantics, how to track the operation, or what response/confirmation to expect, so an agent would still face significant uncertainty.

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 71%, so the baseline is 3. The description adds only minimal parameter context by mentioning 'maturity date' and vaguely referring to 'controlling vars'; it does not meaningfully explain the purpose of most parameters 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 uses a specific verb and resource ('Create a liability') and adds the Czech term 'závazek/payable', which clearly distinguishes it from sibling tools like m3_create_receivable and m3_liabilities. It also mentions key attributes (maturity date, controlling vars), leaving little ambiguity about the tool's job.

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 m3_create_receivable or m3_create_issued_invoice. The description only states what it does, not when it should be selected or which sibling tools to prefer in different scenarios.

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

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

The description discloses one meaningful behavioral trait: 'Async import queue', which signals the creation is queued rather than guaranteed to complete synchronously. Since no annotations are provided, this adds some transparency beyond the schema. However, it does not explain what the queue means for error reporting, validation failures, or how the agent can verify success.

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

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

The description is short and front-loaded: the primary purpose comes first, followed by a concise behavioral note. There is no redundant wording or restating of the tool name. It could earn a 5 with slightly more useful detail, but as written it is efficient and readable.

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

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

With no annotations and no output schema, the description carries a heavy burden, but it only provides a two-sentence summary. It does not explain the async import lifecycle, what a successful call returns, what failure modes exist, or how the created entry can be later found via m3_predefined_entries. This is insufficient for an agent to confidently handle the operation end-to-end.

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

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

Schema description coverage is 100%, and every parameter already has a description in the input schema. The tool description adds no additional meaning about how parameters relate to the predefined entry or the async import process, so it does not improve on the schema. Baseline 3 is appropriate.

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

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

The description states a clear verb and resource: 'Create a predefined accounting entry (predkontace)'. It also adds the async import-queue behavior, which helps distinguish this create operation from a plain synchronous creation. However, it does not explicitly contrast itself with the sibling m3_predefined_entries, so it is clear but not fully differentiated.

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

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

No guidance is given about when to use this tool versus alternatives such as m3_predefined_entries for listing entries, or other m3_create_* tools for different resources. There are no stated conditions, prerequisites, or exclusions, so the agent must infer usage from the name and description 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 earns credit for the non-obvious behavioral trait 'Async import queue,' which signals that creation is not synchronous and results may not be immediately visible. However, it stops short of explaining the consequences: what the response contains, how failures surface, or how to confirm the project was actually created.

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 zero filler, and the primary purpose is front-loaded before the behavioral note. Every word earns its place; the description is appropriately sized for a three-parameter create tool.

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

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

The tool is low-complexity (3 flat params, no enums, no output schema), but the async behavior creates a real completeness gap: without an output schema or annotations, the agent doesn't know what the call returns, how long the queue takes, or how to verify success. The description is adequate for initiating the call but not sufficient for a confident end-to-end interaction.

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 code ('Project code'), name ('Project name'), and definitionShortcut ('XML transfer shortcut' with a default). The description adds nothing about parameters, but the baseline of 3 applies 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 states a specific verb and resource ('Create a project') and adds domain context with the Czech term '(zakázka)'. Among the many m3_create_* siblings, the resource is unambiguous, and the name itself reinforces the distinction. It doesn't explicitly contrast with m3_projects (likely a listing tool), but the core purpose is clear.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of m3_projects for verifying creation, no conditions stated, and no exclusion criteria. The 'Async import queue' hint implies a follow-up is needed, but the description never tells the agent what to do next.

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

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

The phrase 'Async import queue' is a meaningful behavioral disclosure, indicating that the create operation is queued and may not complete synchronously. Since no annotations are provided, the description carries the full burden, but it does not explain what happens after enqueueing, how errors are reported, or whether the operation can be confirmed. This is a useful but incomplete 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 very short and front-loaded, stating the purpose in the first sentence. The second sentence adds a distinct behavioral fact about the async import queue, so both sentences earn their place. It is slightly telegraphic but not redundant.

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

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

Given the tool has 14 parameters, no output schema, and no annotations, this two-sentence description is insufficient for an agent to fully understand the operation. It does not explain the async semantics beyond a fragment, nor what response or confirmation to expect, nor how to decide among the many optional parameters. The description is adequate for basic identification but not for confident 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 71%, so most parameters already have explanatory text in the schema. The description adds little beyond mentioning 'maturity date and controlling vars', which loosely maps to dateOfMaturity and definitionShortcut but does not clarify the four undocumented fields such as documentNumber or variableSymbol. It does not substantially compensate for the 29% schema coverage gap.

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

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

The description clearly states the operation with a specific verb and resource: 'Create a receivable (pohledávka)'. It also mentions two key attributes, maturity date and controlling vars, which helps distinguish it from related tools like m3_create_liability or m3_delete_receivable. However, 'controlling vars' is somewhat vague and could be more 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?

The description provides no guidance on when to use this tool versus alternatives such as m3_create_liability or m3_create_received_invoice. It does not state exclusions, prerequisites, or typical scenarios. The only contextual hint is 'Async import queue', which implies a specific execution mode but not when to choose 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?

No structured annotations are present, so the description must carry the behavioral burden. It adds useful non-obvious context by noting the invoice is 'written to async import queue,' implying asynchronous/eventual processing rather than synchronous creation. It does not disclose permissions, validation errors, or what a successful call returns.

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 redundancy; the primary action and resource are front-loaded, followed by the async-queue caveat. Every phrase 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 create operation with an entirely described schema, the description covers the core action and the non-obvious async behavior. It does not explain how results are returned or confirm success, but no output schema is declared and the schema fully documents parameters.

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%; every parameter (dates, items, codes, definitionShortcut) is already described in the schema. The tool description adds no additional parameter-level meaning, so baseline 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 an explicit create verb, target resource ('received (incoming) invoice'), and the writing mechanism ('async import queue'). The parenthetical '(incoming)' plus the tool name clearly differentiates it from m3_create_issued_invoice.

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

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

The description establishes that this tool is for incoming invoices, which gives an agent a clear basis to prefer it over m3_create_issued_invoice. It does not explicitly list exclusion criteria or alternatives, but the 'received (incoming)' qualifier provides clear selection 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 full burden of behavioral disclosure. 'Async import queue' is a genuinely useful behavioral trait — it tells the agent the creation is queued rather than synchronous. However, it does not explain the implications: whether a confirmation is returned, whether the agent must poll m3_stock_cards later, or what happens on failure. This is a meaningful disclosure but incomplete.

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

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

The description is two short fragments with zero filler; the main action is front-loaded and every word earns its place. It loses a point because 'Async import queue' reads as a disconnected afterthought rather than an integrated sentence explaining the behavior.

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 complex 14-parameter creation tool with no annotations and no output schema, yet the description is minimal. The async-queue disclosure raises questions (no response contract, no polling guidance, no error semantics) that the description does not answer. An agent cannot fully predict the call's behavior or what to do after invoking it, so the description is not complete enough for the tool's 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 100%, so the schema already documents all 14 parameters. The description adds only the 'optional' framing for barcode/weight/warranty/category, which the schema already implies by listing just 2 required fields. This is a marginal addition over the schema, so the baseline 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 ('Create') and a clear resource ('stock/inventory card'), and names the optional fields (barcode, weight, warranty, category). This distinguishes it from sibling tools like m3_stock_cards (read) and m3_delete_stock_card (delete), and from resource-different siblings like m3_create_stock_document. It loses the 5 because it doesn't explicitly contrast itself with the confusingly similar creation siblings.

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

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

The description implies 'use this when you need a new stock card' but gives no explicit when-to-use guidance, no exclusions, and no mention of alternatives. With 60+ siblings including m3_create_stock_document and m3_create_inventory_document, an agent gets no help choosing between them. The async-queue note hints at context but does not clarify 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?

With no annotations, the description carries the behavioral disclosure burden. It does disclose one important trait: the operation is asynchronous and goes through an import queue. But it does not explain what success/failure looks like, whether the document is created immediately or only after queue processing, or any side effects beyond queuing.

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

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

Two short sentences, front-loaded with the core action and resource, then the key behavioral caveat. No redundant phrasing or filler.

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

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

The description is reasonably complete for a create tool with a well-defined schema: it names the document type, notes the async queue, and the schema covers required fields. However, with no output schema and no annotations, it would benefit from clarifying what the caller should expect after enqueueing, such as a queue ID, status check, or error handling.

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 89%, so the schema already explains most parameters. The description adds a mild semantic grouping by mentioning 'controlling vars,' which likely maps to codes like projectCode, activityCode, and costCenterCode, but it does not explain any specific parameter beyond what the schema provides.

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

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

The description names a specific verb ('create'), a concrete resource ('stock/warehouse document'), and clarifies the document kind ('receipt or dispatch'). This is enough to distinguish it from nearby siblings like m3_create_stock_card and m3_create_inventory_document.

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 intended use is implied by the name and opening phrase: use this to create a stock/warehouse document. However, there is no explicit guidance on when to prefer it over related create tools, nor any exclusion criteria or alternative names.

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 behavioral burden. It does disclose a key trait — 'Async import queue' — which signals that the call enqueues work rather than returning a completed record immediately. However, it does not mention permissions, failure modes, or what happens after enqueueing, so the disclosure is only partial.

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

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

The description is a single, front-loaded sentence that communicates the action, the domain, and the async behavior with no wasted words. Every element 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 fully documents all 8 parameters, and the description conveys the core purpose and async nature of the operation. However, because there is no output schema and no annotations, the agent is left without information about the response shape or how to verify the enqueued import succeeded. For a create operation with side effects, this is a moderate gap.

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

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

Schema description coverage is 100%, so all parameters are already documented in the input schema. The description itself adds no parameter-level meaning beyond the schema, which meets the baseline for full schema coverage but does not exceed it.

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

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

The description states a specific verb ('Create') and resource ('a wage record'), and adds the domain context 'for payroll processing' with the local term 'mzdovy doklad.' This clearly distinguishes it from other create tools in the sibling list, such as create_activity or create_received_invoice.

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

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

The phrase 'for payroll processing' provides clear context on when the tool is appropriate. It does not explicitly name alternatives or exclusion criteria, but the payroll-specific purpose is sufficient for an agent to route to this tool versus the many other m3_create_* siblings.

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

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

No annotations are provided, so the description must carry behavioral disclosure. It states the operation is read-only, which is useful, but it does not disclose pagination limits, default ordering behavior, or how the 'where' and 'order' GraphQL clauses behave. For a list tool with pagination parameters and no output schema, these gaps matter.

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

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

The description is short and front-loaded with the primary action and resource. The read-only note is placed right after the main clause. It doesn't waste words, though the second sentence could arguably be merged.

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

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

With no annotations, no output schema, and a low schema description coverage, the description leaves the agent guessing about return structure, pagination behavior, filtering syntax, and sort fields. A simple list tool still benefits from saying what a record looks like or how to constrain results. The current text is minimally viable but 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 only 50%, with 'order' and 'where' barely documented as 'GraphQL order/filter clause'. The description adds no further meaning about what values these clauses accept, the shape of 'where' grammar, or how pagination interacts with them. It fails to compensate for the undocumented half of the 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 identifies a specific verb ('List') and resource ('CRM activity records') and clarifies it is a log of user actions on documents/contacts. It does not explicitly contrast with the similar sibling 'm3_activities', but the 'CRM' qualifier distinguishes it somewhat. A clear, non-tautological statement overall.

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 clear context that it lists activity records and is read-only, implying safe, general listing use. However, it does not explicitly state when to use this tool versus sibling tools like m3_activities or m3_graphql, leaving some ambiguity for an agent choosing among similar list/query tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It explicitly states 'Read-only,' which is the key side-effect disclosure for a list tool. It does not mention pagination limits, filtering syntax, or authentication assumptions, but those are either present in the schema or implicit for a simple list 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?

Only two short sentences, with the core behavior first and the safety qualifier second. Every word earns its place; there is no redundant or filler text.

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

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

For a low-complexity read-only list, the description names the return content (currencies and exchange rates) and the operation's safety. The schema covers the four optional parameters, so the definition is adequate for an agent to understand the tool's role and invoke it correctly.

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

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

The description adds no parameter-level detail, but order and where already have descriptions in the schema as GraphQL clauses, and skip/take are standard pagination parameters with defaults and bounds. The missing parameter information in the description is therefore not a significant barrier to correct invocation.

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

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

Description uses a specific verb ('List') and a precise resource ('configured currencies with exchange rates'), and the read-only clause clarifies the operation. This is distinct from sibling list tools that target other master-data resources such as m3_countries or m3_vat_classifications.

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 use when the agent needs to retrieve configured currencies with exchange rates, and the read-only label signals it is a safe retrieval rather than a mutation. It does not explicitly name alternatives or exclusion conditions, but no sibling tool appears to offer a currency-list alternative.

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. The verb 'Delete' does reveal the destructive intent, but nothing is said about whether deletion is permanent, what happens when the ID does not exist, whether referenced records are affected, or any permission requirements. This is a meaningful gap for a destructive 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?

One sentence with zero wasted words: the verb is front-loaded, the resource is explicit, and the selection mechanism is stated. For a simple one-parameter tool, this is perfectly sized and 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?

For a minimal single-parameter delete with no output schema and no annotations, the description covers the essential invocation facts: what to delete and how to identify it. However, it omits behavioral context such as error handling and permanence, which a destructive tool with no annotation support should ideally disclose. The core call can still be made 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%: the single required 'id' parameter already documents 'Address record ID' with exclusiveMinimum 0. The description's 'by ID' reinforces the schema but adds no new semantic meaning, so the high-coverage 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 ('Delete'), resource ('address book entry'), and mechanism ('by ID'), making the tool's purpose unmistakable. It implicitly distinguishes from the many sibling delete tools (m3_delete_invoice, m3_delete_liability, etc.) by naming the exact resource type, though it does not explicitly name an alternative.

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. It does not mention prerequisites such as first looking up the ID via m3_address_book or m3_create_address, nor any conditions for preferring this over other m3_delete_* tools. The only usage signal is trivially implied by the verb and 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?

Without annotations, the description carries the burden of conveying side effects. It clearly states the destructive action ('Delete') and what is affected ('bank statement'), but it does not mention irreversibility, permissions, or any consequences beyond the deletion itself.

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

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

One compact sentence with no filler. The action and target are front-loaded, making the description easy to parse quickly.

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

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

For a low-complexity delete operation with a fully described two-parameter schema, the description is sufficient to invoke the tool correctly. It lacks deeper context like return behavior or permanent effects, but those are largely implied by the 'Delete' verb and are not essential for a basic call.

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?

Input schema coverage is 100%, so the schema fully explains both parameters. The description simply repeats 'by ID and year' without adding new meaning, matching the baseline for well-covered schemas.

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 ('Delete'), a specific resource ('bank statement'), and the key identifiers ('ID and year'). This clearly distinguishes the tool from siblings such as m3_create_bank_document and m3_bank_documents.

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: use this tool to delete a bank statement identified by ID and year. It does not enumerate exclusions or sibling alternatives, but for a focused delete operation the intended usage is readily apparent.

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 disclose behavioral traits. It only says 'Delete', which indicates mutation but provides no information about irreversibility, authorization, side effects, or failure behavior. A destructive tool with zero annotation coverage should mention consequential aspects.

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 minimal, front-loaded with the action and resource, and contains 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?

For a mutation tool with no annotations and no output schema, the description is too sparse. It does not explain the delete semantics (hard/soft), consequences, or handling of missing records, so an agent cannot fully predict the tool's behavior.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description's 'by ID and year' adds a hint that the two fields jointly identify the record, but overall it contributes little beyond the schema.

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

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

The description states a specific action ('Delete') applied to a specific resource ('a cash voucher') with the identifying keys (ID and year). It distinguishes this tool from sibling delete tools (e.g., m3_delete_bank_document, m3_delete_stock_document) at a glance.

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, when not to use it, or prerequisites. The description only restates the function, leaving an agent to infer the appropriate conditions from the tool name and context.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure. It does state the core destructive fact ('Delete'), but it discloses nothing about permanence, reversibility, cascading effects on linked accounting records, permission requirements, or behavior on failure. For a mutation in an accounting system, this is a significant gap.

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

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

A single front-loaded sentence with zero waste. Every word ('Delete', 'internal document', 'by ID and year') earns its place, and the action is stated first. Appropriately sized for the tool's simplicity.

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 delete operation, the description plus schema covers the invocation fully (what, which resource, which keys). However, with no output schema and no annotations, it omits what happens on success or error, and whether deletion can be blocked by document state. Adequate for basic use, but a safe full picture is missing.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (record ID, accounting year). The description adds only marginal meaning by grouping them as a composite identifier ('by ID and year'), but provides no additional format, constraints, or contextual detail beyond the schema.

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

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

The description states a specific verb ('Delete'), a specific resource ('internal document'), and the identifying scope ('by ID and year'). This distinguishes it from the large family of delete siblings (delete_invoice, delete_liability, delete_bank_document) and names the exact key an agent must supply.

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. It does not mention the related m3_internal_documents / m3_create_internal_document tools, nor does it state any prerequisites or conditions (e.g., document must not be posted) or exclusions (when not to delete). Usage context is left entirely to inference 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?

Annotations are absent, so the description carries the full burden of behavioral disclosure. It indicates a destructive operation but does not state whether deletion is permanent, whether associated lines are affected, or what permissions are required.

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. It communicates the action, resource, and selection method efficiently.

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

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

For a one-parameter delete operation with full schema coverage, the essential invocation path is present. However, the missing annotations leave gaps around permanence and side effects, and the 'stocktaking' phrasing creates potential confusion with adjacent stock-document tools.

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

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

Schema coverage is 100% and the 'id' parameter is already described as 'Inventory document record ID' with exclusiveMinimum 0. The description merely restates 'by ID' and adds no meaningful parameter information, 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 action ('Delete') and a resource ('stocktaking document') with the selection key ('by ID'), so an agent can infer the operation. However, it uses 'stocktaking document' instead of the tool name's 'inventory document' and does not explicitly distinguish it from sibling m3_delete_stock_document.

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. The description also leaves the 'stocktaking' vs 'inventory' terminology unresolved, which matters because sibling tools include delete_stock_document and delete_stock_card.

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 carry the behavioral disclosure burden. It does disclose a critical behavior: the deletion fails if dependent records like stock movements exist. However, it does not state whether deletion is permanent, whether there are any side effects, or what happens on success.

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 brief, front-loaded with the core action, and includes only the essential additional context about dependent records. Every sentence contributes useful information without clutter.

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 covers the core operation and the main failure condition, but since there is no output schema or annotations, an agent is left without information about success responses, permanence, or any further behavioral implications. This is adequate but not fully complete for a destructive tool.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description adds little beyond restating the ID and year as identifying criteria and does not explain the role of the 'type' parameter, which is also required.

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 ('Delete an invoice'), the target resource, and the identifying fields (ID and year). It is distinct from sibling delete tools that target liabilities, receivables, or documents, so an agent can tell this tool apart from other m3_delete_* 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?

No guidance is provided about when to use this tool versus alternatives, nor are any exclusions or prerequisites mentioned. The description implies deletion of an invoice but does not say when an agent should prefer this over related create/update/list operations or other delete tools.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure. The verb 'Delete' conveys destructive intent, but that is already visible in the tool name. Nothing is disclosed about permanence, cascading effects on related records, idempotency, or behavior when the id/year combination does not exist. For a destructive operation, this is a meaningful 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 terse sentence with the verb front-loaded and no filler. Every word earns its place for a two-parameter delete tool, though it is so minimal it borders on under-specification rather than efficient 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 destructive operation with no annotations and no output schema, this description is thin. It identifies the resource and required identifiers, which is enough to attempt an invocation, but it leaves the agent blind to post-conditions: success/failure behavior, permanence of deletion, and whether related records are affected. A simple tool needs less, but this falls below the minimum viable bar.

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%: 'id' is documented as 'Liability record ID' and 'year' as 'Accounting year' with explicit bounds. The description's 'by ID and year' adds no semantic detail beyond the schema, so the baseline 3 applies. It earns minor credit for implying both parameters jointly identify the record.

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 ('Delete'), a resource ('liability'), and the identifying scope ('by ID and year'). This is clear enough to distinguish it from sibling read/create tools like m3_liabilities and m3_create_liability, and the resource name separates it from other m3_delete_* tools. However, it never explicitly contrasts with any sibling, so it stops short of a 5.

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

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

No when-to-use guidance, alternatives, prerequisites, or exclusions are provided. An agent must infer from the tool name and sibling listing that this is the deletion counterpart to m3_liabilities/m3_create_liability, and there is no guidance about when not to use it. The basic operation is implied, but nothing more.

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 conveys only that this is a delete operation, a fact already evident from the tool name, and adds nothing about permanence, cascade effects on related records, behavior when the record does not exist, or permission requirements. For a destructive operation, this is a significant disclosure 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 seven-word sentence with the verb front-loaded and zero filler. Every word carries meaning, making it maximally efficient for an agent to parse.

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

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

For a simple tool with two flat integer parameters and full schema coverage, the description is largely adequate for constructing a call. However, it is a destructive mutation with no annotations and no output schema, so the absence of notes on deletion consequences, error behavior, or return values leaves a clear gap. 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?

Schema coverage is 100%, so the schema already documents both parameters: id as 'Receivable record ID' and year as 'Accounting year' with a 2000–2100 range. The description adds only that the two jointly identify the receivable, which is marginal value beyond the schema. Baseline 3 applies 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 states a specific verb ('Delete'), a specific resource ('receivable'), and the identifying key ('ID and year'), which unambiguously tells an agent what the tool does. In a sibling list containing nine other delete_* tools for different resources, this clearly distinguishes it as the receivable-targeting one. The explicit dual-key detail sets the correct invocation expectation.

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 such as m3_create_receivable or m3_receivables, nor does it mention the nine sibling delete_* tools. It provides no exclusions, prerequisites, or conditions (e.g., verifying the receivable exists before deleting). Usage context is left entirely to inference 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 for behavioral disclosure. 'Delete' conveys the core action, but it does not state whether deletion is permanent, what side effects occur on related data, or whether special permissions are required. This is a significant gap for a destructive 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, clear sentence with no wasted words. It front-loads the action and the resource, making it immediately scannable.

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

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

For a tool with one required parameter and complete schema coverage, the call inputs are sufficiently clear. However, the total absence of usage guidance and behavioral side-effect information, especially for a destructive action with no annotations, leaves the agent under-informed about important operational 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 only parameter, id, is already fully documented in the schema as 'Stock card record ID' with an exclusiveMinimum constraint. The description's 'by ID' adds no additional meaning beyond what the schema already provides, so baseline 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 clearly names the exact action ('Delete'), the specific resource ('stock card'), and even clarifies the domain term ('article'). This is enough to distinguish it from sibling delete tools like m3_delete_stock_document, since the object is explicitly identified.

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 m3_delete_stock_document or when deletion is appropriate. The agent must infer usage entirely from the tool's name and minimal 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the destructive action and target but does not mention whether deletion is permanent or irreversible, any permission requirements, or potential side effects on related records.

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, tightly written sentence with no filler. The verb and target are front-loaded, making the tool’s purpose immediately understandable.

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 delete operation, the schema fully documents the inputs and the description conveys the core action. However, the lack of annotations, output schema, and any behavioral caveats means the description is minimally adequate rather than 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 input schema already describes both parameters with types and constraints, and schema description coverage is 100%. The phrase “by ID and year” reinforces the schema but adds no meaningful detail, 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 states a specific action (“Delete”), a concrete resource type (“stock document”), and clarifies the resource with the parenthetical “received slip.” It also specifies the lookup key (“by ID and year”), which is enough to distinguish it from sibling delete tools like m3_delete_stock_card or m3_delete_inventory_document.

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 alternative delete-related siblings, nor are any exclusions or prerequisites mentioned. The agent is left to infer usage context from the tool 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?

No annotations are provided, so the description carries the full behavioral burden. It explicitly states 'Read-only', which tells the agent there are no side effects, and it lists the data scope ('full detail: address, contact, employment dates, cost center, employment type'). It does not mention rate limits or response shape, but for a simple query tool this is acceptable.

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 part contributes either to identifying the resource, specifying the returned fields, or signaling safety ('Read-only').

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 read-only query with four optional parameters and no output schema, the description covers the essential return fields and the non-mutating nature. The schema handles pagination and filtering mechanics. A more complete description might include GraphQL clause syntax examples or response structure, but the definition is largely sufficient 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?

The description adds no parameter-level detail; it only describes the returned employee fields. The schema covers 'order' and 'where' with descriptions and 'skip'/'take' with defaults, so an agent can invoke the tool safely with defaults. With 50% schema description coverage and no parameter explanation in the description, there is a clear gap, but the conventional parameter names and optionality make it minimally viable.

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 ('Query') and resource ('employees') and enumerates the exact fields returned: address, contact, employment dates, cost center, employment type. It clearly distinguishes this query tool from the many mutation-oriented siblings in the list. The 'Read-only' label further reinforces its scope.

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: use this tool when you need detailed employee data. The 'Read-only' marker also signals it is a safe retrieval operation rather than a mutation. It does not name alternatives or explicit exclusions, but no dedicated employee-query sibling exists, so the guidance is adequate.

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?

There are no annotations, so the description must carry the behavioral burden. It explicitly says 'Read-only', which is useful, but it does not disclose pagination behavior, response shape, or any limitations beyond what the schema already exposes.

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 purpose is front-loaded and the read-only note is immediately after the action, making the tool easy to scan among a long list of siblings.

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 list tool, the description states what is returned and that the call is safe, which is the minimum viable. However, with no output schema and no annotations, it does not explain response contents, pagination defaults, or how the where/order GraphQL clauses should be used.

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?

Only order and where have schema descriptions; skip and take are undocumented. The description adds no meaning for any parameter and does not compensate for the missing semantics, leaving the agent to infer skip/take solely from their names.

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

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

The description uses a specific verb ('List') and names a clear resource ('flags/labels used for document tagging'). It also distinguishes this tool from the many create/delete and other list siblings in the toolset. The read-only note reinforces the nature of the operation without blurring the purpose.

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

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

No guidance is given about when to prefer this tool over alternatives or when not to use it. The phrase 'used for document tagging' implies a context, but there is no explicit statement that this is the canonical way to fetch valid flag values or how it relates to other list tools.

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

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

With no annotations, the description must carry the behavioral burden. It explicitly discloses that the tool can execute both queries and mutations, which signals side-effect potential, and 'raw' implies arbitrary/unrestricted operations. However, it does not mention cache invalidation consequences, error behavior, or the need for caution with mutations beyond the schema's isMutation note.

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 main action is front-loaded and the usage context immediately follows.

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 high-complexity escape-hatch tool with no output schema and no annotations, yet the description gives minimal guidance beyond the purpose. It does not explain how to discover valid GraphQL operations, authorization or rate-limit expectations, or what the response looks like, leaving an agent to guess at critical invocation details.

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 query and isMutation are already documented in the schema. The description adds no parameter-level detail, so it neither improves nor harms the baseline provided by 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 begins with a specific action and target: 'Execute a raw GraphQL query or mutation against the Money S3 API.' It also distinguishes the tool from the many domain-specific m3_* siblings by classifying it as the raw/advanced fallback.

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 advanced use when built-in tools don't cover a specific need' gives a clear selection condition and implies that the domain-specific siblings should be preferred for normal use. It does not name particular alternatives, but the sibling list makes those obvious.

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?

There are no annotations, so the description carries the full disclosure burden. It only states that the tool queries and alludes to certain fields, but does not disclose return format, pagination behavior, filter syntax, or whether these inner-document attributes are always returned.

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

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

The description is a single compact sentence with the action front-loaded. It wastes no words, but the final phrase is a compressed list that may be jargon-heavy.

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 query tool with four generic parameters and no output schema or annotations, the description is too thin. It does not explain the where/order syntax, the meaning of 'controlling variables', or how the VAT breakdown and payment-status features are accessed, so an agent may struggle to call it correctly beyond a default unfiltered query.

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

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

Schema description coverage is only 25%, and the description does not compensate: skip, take, and especially where are left without meaning. The mention of VAT breakdown, payment status, and controlling variables is not mapped to any parameter or syntax, so an agent cannot infer how to filter.

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

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

The description names a specific verb ('Query') and resource ('internal documents'), which distinguishes it from sibling write tools like m3_create_internal_document and m3_delete_internal_document. The appended features (VAT breakdown, payment status, controlling variables) add some specificity, though it is unclear whether those are filter fields or returned data.

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

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

Usage is implied by the verb 'Query': the tool is for retrieving internal documents, not creating or deleting them. However, there is no explicit guidance about when to prefer this tool over the generic m3_graphql or other document query tools, and no mention of exclusions.

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

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

No annotations exist, so the description carries the burden. It clearly states a read-only query and gives return-content context (line items, expected vs real amounts). However, it discloses no side-effect/safety caveats, authorization needs, or pagination/filtering 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?

A single focused sentence with the operation and resource front-loaded and no filler. Every word adds information.

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

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

With no output schema and no annotations, an agent still lacks the syntax for the 'where'/order parameters and the exact return shape. The description makes an unfiltered call possible (no required params) but is insufficient for anything beyond default usage.

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

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

Schema description coverage is only 25% (only 'order' is described as a GraphQL clause), and the tool description adds no parameter meaning. 'where' remains completely opaque, and skip/take are only inferable from defaults and min/max. The description must compensate for low schema coverage but does not.

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 an explicit verb ('Query'), names the specific resource ('inventory (stocktaking) documents'), and adds distinguishing content ('line items and expected vs real amounts'). This clearly separates it from sibling create/delete inventory document 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?

Usage is implied by the 'Query' verb and resource name, but there is no explicit when-to-use guidance or comparison to alternatives such as m3_stock_documents or m3_graphql. It does not state when not to use 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 provided, the description carries the full disclosure burden. 'Query' clearly conveys a non-destructive read operation, and naming the returned content (VAT breakdown, payment status, controlling variables) adds useful behavioral context beyond the schema. But it omits response shape, pagination defaults/limits, and failure or edge-case behavior, so the transparency is adequate rather than rich.

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

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

A single front-loaded sentence that places the core verb+resource first and appends a compact, informative capability list. There is no filler or redundancy. The only minor blemish is the somewhat jargon-y 'controlling variables,' but overall every element 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 low-complexity query tool with four optional, fully-documented parameters and no nested objects, the description covers the main capabilities and partial return contents. Since there is no output schema and no annotations, a bit more detail about result shape and pagination limits would strengthen the agent's confidence, but nothing critical is missing for a simple filtered query.

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 all four parameters are already fully documented by the input schema, establishing the baseline of 3. The description's mention of 'filtering and pagination' loosely maps to where/order and skip/take but adds no new semantic detail beyond what the schema's own parameter descriptions already state.

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

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

The description opens with a specific verb ('Query') tied to a precise resource ('issued (outgoing) invoices'), and the parenthetical '(outgoing)' actively disambiguates direction from the sibling m3_received_invoices. The appended scope list (VAT breakdown, payment status, controlling variables, filtering, pagination) further pins down what the tool returns, clearly separating it from create/delete siblings like m3_create_issued_invoice and m3_delete_invoice.

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

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

The description signals a read-only retrieval context, which implies when an agent would call it. However, it never names alternatives or exclusions — there is no explicit statement like 'use m3_received_invoices for incoming invoices' or 'use m3_create_issued_invoice to create one.' The usage context is inferable but left to the agent to derive.

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 present, the description carries the full burden of behavioral disclosure. 'Query' signals that this is a read-only operation, and the listed attributes give some indication of what will be returned. However, it does not describe behavior such as default pagination, filter semantics, response shape, or the meaning of the vague 'controlling vars' term, leaving 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, compact sentence that leads with the action and resource. It avoids unnecessary wording and conveys the core purpose efficiently. The only minor flaw is the cryptic phrase 'controlling vars,' which is concise but not clearly explained.

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 four parameters, no annotations, and no output schema, so the description needs to carry substantial context. It provides only the high-level purpose and some output-ish fields, but leaves critical invocation details undetermined: how to build a 'where' clause, what ordering options exist, how pagination behaves, and what the response looks like. This is a clear gap for a query 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 only 25%, so the description must compensate for the sparse parameter documentation. It mentions domain fields like VAT, payment status, and maturity dates, which may indirectly inform what can go into the 'where' clause, but it does not explain skip, take, order, or where syntax. This is not enough to help an agent construct a correct query.

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 ('Query') and a clear resource ('liabilities'), with a parenthetical clarification that liabilities are payables/obligations. It also lists relevant queryable dimensions (VAT, payment status, maturity dates), making the tool's focus understandable. However, it does not explicitly distinguish itself from related siblings such as m3_received_invoices or m3_create_liability, 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?

The verb 'Query' implies this is the tool for reading liabilities rather than creating or deleting them, providing some usage context. But the description does not state when to prefer this over m3_received_invoices, m3_receivables, or the create/delete liability siblings, nor does it give any exclusion criteria or alternative routing.

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

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

Since no annotations are provided, the explicit 'Read-only' statement carries important behavioral weight and assures the agent that the operation has no side effects. The description also indicates that it lists across all document types. It could add pagination or response-format details, but the core behavioral traits are 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 two terse sentences with no filler. The core verb and object are front-loaded, the parenthetical adds useful clarification, and 'Read-only' is a compact safety signal. Every word contributes 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?

For a simple listing tool with four optional parameters and no output schema, the description provides adequate context: it names the resource, clarifies the numbering-rule meaning, and states the operation is read-only. The remaining details, such as pagination defaults and filtering syntax, are left to the schema, which is acceptable for this low-complexity 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 description provides no information about skip, take, order, or where; two of the four parameters are only documented by the schema's sparse 'GraphQL order clause' and 'GraphQL where filter' descriptions. Because schema coverage is only 50%, the description needed to compensate, but it does not explain pagination semantics or how filtering by document type relates to the 'all document types' claim.

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 ('List') with a clear resource ('numerical series (numbering rules)') and states the scope ('for all document types'). The parenthetical clarifies what a numerical series is, and the description is distinct from the many document- and finance-oriented sibling 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?

There is no guidance about when to use this tool instead of alternatives such as m3_graphql or other listing tools. The description does not state whether this is the preferred read-only lookup or what conditions would make a different tool 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 provided, the description carries the full behavioral burden, yet it only says 'Query' and 'with pagination'. It implies a read operation but does not state return format, implicit ordering, default scoping, or error behavior, and 'graphql filter' semantics are left entirely to the schema rather than explained.

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; 'Query order documents (objednávkové doklady) with pagination' gets straight to the point and the parenthetical adds useful precision. The brevity is partly a symptom of under-specification, but as prose 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 there are no annotations, no output schema, and only partial parameter documentation, the description is too thin. It fails to explain the meaning of an 'order document' in the M3 domain, what the GraphQL where filter accepts, what the paginated response looks like, or how this relates to invoice documents.

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

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

Schema description coverage is only 33% (only 'where' is described). skip and take rely on self-evident names and numeric defaults, which is weak documentation. The description adds only 'with pagination', which reinforces the skip/take intent but does not explain syntax, defaults, or how 'where' integrates with the pagination 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?

Uses a specific verb 'Query' and resource 'order documents' with a Czech gloss (objednávkové doklady) that sharpens the meaning. However, it does not explicitly distinguish itself from overlapping siblings like m3_issued_invoices, m3_received_invoices, or the generic m3_graphql, so an agent cannot fully disambiguate 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 about when to use this tool versus alternatives. The sibling list includes m3_graphql, m3_issued_invoices, and m3_received_invoices, which could plausibly overlap, but the description offers no selection criteria, exclusions, or prerequisites.

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

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

With no annotations provided, the 'Read-only' statement in the description carries important safety information and clearly signals that no mutation occurs. However, the description does not disclose response shape, pagination behavior, or any operational characteristics beyond being a read operation, so some behavioral detail is still missing.

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

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

The description is two short sentences with no filler. The core action and resource are front-loaded, and the read-only qualifier is stated efficiently. 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?

For a simple query tool with no required parameters, the description is minimally adequate for selecting the tool. However, with no output schema and no annotations, the description does not clarify what the returned data looks like, how ordering works, or whether the response is a list or a single object. These gaps leave the agent without full 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?

Only one of the three parameters ('order') has a schema description, giving only 33% schema coverage. The description adds no parameter-level meaning, and 'skip' and 'take' are left to be inferred from their names. Since coverage is low, the description should have compensated by explaining these parameters, but it does not.

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 a specific action ('Query') and a specific resource ('predefined accounting entries'), with the Czech term 'předkontace' adding domain precision. It is also easily distinguished from the sibling m3_create_predefined_entry, which is for creating entries rather than querying them.

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

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

The description implies the tool is for reading predefined entries and not for creating or modifying them, especially given the sibling m3_create_predefined_entry. However, it does not explicitly state when to prefer this tool over alternatives or call out any conditions or exclusions, so usage context is only 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. It says 'Read/write' but does not clarify what write behavior is available, what the side effects are, or whether authentication is needed. The internal tension between 'Query' and 'Read/write' makes behavior less transparent, not more.

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

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

The description is short and front-loads the action phrase 'Query projects.' However, 'controlling variable' and 'Read/write' are cryptic fragments that raise questions rather than earning their place, so the brevity comes at the cost of 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?

There is no output schema, no annotations, and no description of the return format, pagination behavior, or what fields a project object contains. For a simple query tool this is a notable gap, and the ambiguous read/write claim raises additional unanswered questions about mutating behavior.

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