Norman Finance MCP Server

Official

by norman-finance

Overview Schema Related Servers Score Discussions

Python

Hybrid

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes, but there is some overlap between create_transaction and categorize_transaction, and between send_invoice and send_invoice_overdue_reminder, which could cause minor confusion. However, descriptions clarify their specific roles, and the majority of tools target unique resources or actions.
Naming Consistency5/5
All tool names follow a consistent snake_case pattern with a clear verb_noun structure, such as create_client, list_invoices, and update_transaction. This uniformity makes the tool set predictable and easy to navigate.
Tool Count3/5
With 34 tools, the count is borderline high for a finance server, potentially overwhelming for an agent. While the domain is broad (clients, invoices, transactions, taxes, attachments), some tools might be redundant or overly specialized, making the set feel heavy.
Completeness5/5
The tool set provides comprehensive coverage for financial management, including full CRUD operations for clients, invoices, transactions, and attachments, plus tax reporting, validation, and email functionalities. There are no obvious gaps, and tools support end-to-end workflows.
Average 3.1/5 across 34 of 34 tools scored. Lowest: 1.3/5.
See the Tool Scores section below for per-tool breakdowns.
- 2 of 4 community issues answered or closed in the last 6 months
- 34 commits in the last 12 weeks
- Last stable release on August 25, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior1/5
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 but provides none. It doesn't indicate whether this is a partial or complete update, what permissions are required, whether changes are reversible, what happens when null values are provided, or what the response looks like. For a mutation tool with 11 parameters and no annotation coverage, this is critically insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
While technically concise with just three words, this is under-specification rather than effective conciseness. The description fails to provide necessary information that would help an agent use the tool correctly. A single sentence with basic context would be more valuable than this minimal statement.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 11 parameters, no annotations, no output schema, and 0% schema description coverage, the description is completely inadequate. It provides no information about what the tool actually does beyond the obvious, no guidance on usage, no parameter context, and no behavioral transparency. This leaves an agent with insufficient information to properly invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage and 11 parameters, the description provides no information about any parameters. It doesn't mention what fields can be updated (name, address, tax information, etc.), their purposes, or relationships. The schema shows many fields but the description offers zero semantic context to help an agent understand what each parameter means or how to use them effectively.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Update company information' is a tautology that essentially restates the tool name 'update_company_details'. It provides the verb 'update' and resource 'company information', but lacks specificity about what aspects of company information can be updated or how this differs from other company-related tools like 'get_company_details' or 'update_client'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides absolutely no guidance on when to use this tool versus alternatives. There are multiple sibling tools that deal with company data (get_company_details, get_company_balance, get_company_tax_statistics) and client data (update_client), but the description offers no differentiation or context for when this specific update tool should be selected.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. 'Update an existing transaction' implies a mutation operation, but it doesn't specify required permissions, whether updates are partial or full, what happens on failure, or any side effects. For a tool with 10 parameters and no annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with a single sentence: 'Update an existing transaction.' It's front-loaded and wastes no words, making it easy to parse quickly. However, this conciseness comes at the cost of completeness, as noted in other dimensions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (10 parameters, 1 required, no output schema, and no annotations), the description is inadequate. It doesn't explain what a 'transaction' entails in this context, what fields are updatable, or what the tool returns. For a mutation tool with rich input schema but no supporting documentation, more detail is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, meaning none of the 10 parameters have descriptions in the schema. The tool description adds no information about parameters beyond the generic 'update' action. It doesn't explain what 'amount', 'category', 'date', etc., represent or how they're used, leaving all parameters undocumented. This fails to compensate for the lack of schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Update an existing transaction' clearly states the verb ('update') and resource ('transaction'), but it's quite generic. It doesn't specify what aspects of a transaction can be updated or distinguish this tool from potential alternatives like 'update_client' or 'link_transaction' among the siblings. The purpose is understandable but lacks specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. With siblings like 'create_transaction', 'search_transactions', and 'link_transaction', there's no indication of prerequisites (e.g., needing an existing transaction ID) or scenarios where this is preferred over other tools. It's a bare statement with no contextual usage information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions a return ('Company balance information') but doesn't disclose behavioral traits like whether this is a read-only operation, if it requires specific permissions, rate limits, or what format the balance information comes in (e.g., numeric value, structured object).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief (two sentences) but could be more front-loaded. The first sentence states the purpose, but the second ('Returns: Company balance information') is redundant and doesn't add value beyond what might be inferred. It's concise but not optimally structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (financial data tool with no annotations and no output schema), the description is incomplete. It doesn't explain what 'balance' entails, the data format, or any prerequisites. For a tool in a financial system with many siblings, more context is needed to ensure correct usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description doesn't add parameter semantics, but that's appropriate here. Baseline is 4 for zero-parameter tools as they require minimal parameter explanation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool's purpose ('Get the current balance of the company') which is clear but generic. It doesn't distinguish this from other financial tools like 'get_company_details' or 'get_company_tax_statistics', nor does it specify what 'balance' means in this context (e.g., cash balance, accounting balance, etc.).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. With siblings like 'get_company_details' and 'get_company_tax_statistics', the description doesn't clarify if this is for real-time vs. historical data, or if it's part of a broader financial reporting workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions the tool returns 'Company tax statistics data', but doesn't disclose behavioral traits like whether it's read-only, requires authentication, has rate limits, or what the data format is. This is inadequate for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences, but the second sentence ('Returns: Company tax statistics data') is redundant and could be integrated more efficiently. It's front-loaded with the main purpose, though slightly verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete. It doesn't explain what 'tax statistics' includes, the return format, or any behavioral context. For a tool in a financial context with siblings like tax reports, more detail is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so no parameter information is needed. The description doesn't add param semantics, but this is acceptable given the baseline of 4 for zero parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool's purpose ('Get tax statistics for the company') with a clear verb ('Get') and resource ('tax statistics'), but it doesn't distinguish it from similar siblings like 'get_tax_report' or 'list_tax_reports'. The purpose is clear but lacks sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as 'get_tax_report' or 'list_tax_reports'. The description only states what it does without 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states 'Delete a client' which implies a destructive mutation, but doesn't disclose critical behavioral traits: whether deletion is permanent or reversible, what happens to associated data (e.g., invoices, transactions), authentication requirements, or error conditions. The 'Returns' line mentions confirmation but gives no details about format or content.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with three short lines. It front-loads the core purpose ('Delete a client'), then lists Args and Returns in a structured format. Every sentence earns its place, though the Returns line could be more informative. No wasted words, but the structure is minimalistic rather than optimally explanatory.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (destructive operation with no annotations, 0% schema coverage, and no output schema), the description is incomplete. It lacks crucial context: irreversible nature, side effects on related data, permission requirements, and detailed return values. For a delete tool in a financial system with many siblings, this leaves significant gaps for safe and correct usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds the parameter 'client_id' with a brief explanation 'ID of the client to delete', which provides basic semantics beyond the schema's title 'Client Id'. However, it doesn't specify format (e.g., numeric, UUID), validation rules, or where to obtain it, leaving gaps. With only one parameter, this partial compensation earns a baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Delete' and the resource 'a client', making the purpose unambiguous. It distinguishes from siblings like 'update_client' or 'get_client' by specifying deletion. However, it doesn't explicitly differentiate from other destructive operations like 'delete' actions that might exist in other contexts, keeping it at 4 rather than 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites (e.g., ensure client has no active invoices), warn about irreversible effects, or suggest alternatives like archiving. With siblings like 'update_client' and 'list_clients', this lack of context leaves the agent guessing about appropriate usage scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 describes key behaviors: generating a PDF preview, including a file path link, and advising user confirmation before submission. However, it misses critical details like whether this is a read-only or mutating operation, error handling, or any side effects (e.g., if it creates temporary files). For a tool with no annotations, this leaves significant gaps in understanding its operational impact.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is poorly structured and verbose, mixing usage instructions, implementation details, and behavioral notes in a disorganized way. Sentences like 'Always suggest to check the preview...' and 'You could add short summary...' are prescriptive and clutter the core purpose. It's front-loaded with the main action but loses focus with tangential guidance, reducing clarity and efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of generating a tax report preview with no annotations and no output schema, the description is incomplete. It mentions a PDF output and link but lacks details on return format, error cases, or dependencies. The references to other tools (@get_tax_report, @submit_tax_report) hint at a workflow but don't fully explain integration or prerequisites, leaving the agent with insufficient context for reliable use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds minimal semantics beyond the input schema: it defines 'report_id' as the 'Public ID of the tax report,' which clarifies the parameter's purpose. However, with schema description coverage at 0% and only one parameter, this provides basic but insufficient detail (e.g., format examples or constraints). The baseline is 4 for zero parameters, but here the single parameter's description is too vague to fully compensate for the lack of schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate a test Finanzamt preview for a tax report.' It specifies the verb ('Generate'), resource ('test Finanzamt preview'), and target ('tax report'), making the intent unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'submit_tax_report' or 'get_tax_report' beyond implied usage context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool by referencing other tools (e.g., 'Get the report data from @get_tax_report' and 'Ask follow up question to file the tax report to the Finanzamt @submit_tax_report'), suggesting it's part of a workflow. However, it lacks explicit guidance on when to choose this tool over alternatives or any prerequisites, leaving usage context somewhat inferred rather than clearly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states it retrieves detailed information. It lacks behavioral details such as required permissions, error handling (e.g., invalid client_id), response format, or whether it's a read-only operation, which is critical for a tool with no structured safety hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise and well-structured with clear sections for Args and Returns, using minimal sentences that each serve a purpose without redundancy. It's front-loaded with the core purpose, making it efficient for an agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't explain what 'detailed client information' includes, error cases, or behavioral traits, leaving significant gaps for a tool that interacts with client data in a financial context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, but the description adds basic semantics by explaining 'client_id' as 'ID of the client to retrieve'. This compensates partially, though it doesn't specify format (e.g., numeric, string) or constraints, keeping it at a baseline level of adequacy.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('detailed information about a specific client'), making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'list_clients' or 'update_client', which would require explicit scope clarification for a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'list_clients' for multiple clients or 'update_client' for modifications. The description only states what it does, not when it's appropriate, leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool retrieves information, implying a read-only operation, but doesn't cover aspects like authentication needs, rate limits, error handling, or what 'detailed information' includes. This is inadequate for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with three sentences that are front-loaded: the first states the purpose, and the next two outline args and returns. There's no wasted text, though the structure could be slightly more polished (e.g., integrating args/returns into a single paragraph).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (simple retrieval), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'detailed information' entails or address potential behavioral aspects like error cases, making it insufficient for reliable agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds minimal semantics by naming 'invoice_id' as the ID to retrieve, but with 0% schema description coverage and only one parameter, the baseline is 4. However, it doesn't explain the format or constraints of the ID (e.g., numeric, string pattern), so it slightly undercompensates, warranting a score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('detailed information about a specific invoice'), making it easy to understand what the tool does. However, it doesn't distinguish itself from sibling tools like 'list_invoices' or 'get_einvoice_xml', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 'list_invoices' for multiple invoices or 'get_einvoice_xml' for XML data. It lacks explicit context or exclusions, leaving the agent to infer usage based on the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 tool 'Returns: VAT next report amount data', which hints at read-only behavior but doesn't clarify aspects like authentication needs, rate limits, error handling, or data freshness. For a tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief with two sentences, but it could be more front-loaded. The first sentence states the purpose clearly, but the second ('Returns: VAT next report amount data') is somewhat redundant and doesn't add significant value. Overall, it's concise but not optimally structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'VAT next report amount data' includes (e.g., format, units, or structure), nor does it cover behavioral aspects like permissions or side effects. For a tool in a financial context, this leaves critical gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param details, which is appropriate. A baseline of 4 is applied since the schema fully handles parameters, and the description doesn't introduce confusion.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get the VAT amount for the next report period.' It specifies the verb ('Get') and resource ('VAT amount'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from siblings like 'get_tax_report' or 'get_company_tax_statistics', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites, context (e.g., related to tax reporting cycles), or comparisons to sibling tools like 'get_tax_report'. This lack of usage context leaves the agent with minimal direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 action ('Link') but doesn't describe what happens upon linking (e.g., whether it's reversible, if it affects data integrity, or if it requires specific permissions). The vague return statement ('Response from the link transaction request') adds no useful context about success/error behavior or output format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately brief and front-loaded with the core purpose in the first sentence. The Args/Returns sections are structured but somewhat redundant with the schema. The return statement is vague and could be more informative without adding length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a mutation tool with 2 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like side effects, error conditions, or return values, leaving the agent with insufficient context to use the tool safely and effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It lists both parameters ('attachment_id' and 'transaction_id') and specifies they are IDs, which adds basic semantics beyond the schema's type-only definitions. However, it doesn't explain ID formats, sources, or validation rules, leaving significant gaps in parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Link') and the resources involved ('a transaction to an attachment'), making the purpose immediately understandable. It distinguishes this from sibling tools like 'link_transaction' (which likely links transactions to other entities) by specifying attachment linkage. However, it doesn't fully explain what 'linking' means operationally (e.g., establishing a reference, metadata association).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites (e.g., existing attachment and transaction IDs), exclusions, or compare it to similar tools like 'link_transaction' or 'create_attachment'. The agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 tool validates a tax number but doesn't describe behavioral traits such as what validation entails (e.g., format checks, database lookups), error handling, rate limits, or authentication needs. This leaves significant gaps for a tool that likely interacts with external systems or data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, with the purpose stated first, followed by structured sections for args and returns. Each sentence adds value, such as the example for 'region_code,' but the 'Returns' section is vague ('Validation result') and could be more specific without sacrificing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is partially complete. It covers the basic purpose and parameters but lacks details on validation behavior, error cases, and output format. Without annotations or output schema, more context on what 'Validation result' entails would improve completeness for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaning by naming the parameters ('tax_number' and 'region_code') and providing an example for 'region_code' ('e.g., "BE" for Belgium'), which clarifies usage beyond the schema's basic types. However, it doesn't detail formats, constraints, or validation rules for 'tax_number,' leaving some semantics unclear.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Validate a tax number for a specific region.' It specifies the verb ('validate') and resource ('tax number'), and the regional scope distinguishes it from siblings like 'get_tax_report' or 'list_tax_settings.' However, it doesn't explicitly differentiate from all siblings, such as 'get_company_tax_statistics,' which might involve tax data but not validation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites (e.g., needing a valid tax number format), exclusions, or comparisons to siblings like 'get_company_details' that might include tax information. Usage is implied only by the purpose, with no explicit context or alternatives stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions 'using AI', which hints at non-deterministic behavior, but doesn't disclose key traits like accuracy, latency, rate limits, or authentication needs. For a tool with no annotations and AI involvement, this is a significant gap in 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by structured 'Args' and 'Returns' sections. Each sentence earns its place, with no redundant information. However, the formatting with quotes and line breaks slightly reduces readability, preventing a perfect score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no annotations, no output schema), the description is partially complete. It covers parameter semantics well but lacks usage guidelines and behavioral details. Without an output schema, the 'Returns' section is vague ('Suggested category information'), leaving the agent uncertain about the response format. This is adequate but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds substantial meaning beyond the input schema, which has 0% description coverage. It explains that 'transaction_amount' is the 'Amount of the transaction', 'transaction_description' is the 'Description of the transaction', and 'transaction_type' must be 'income' or 'expense'. This clarifies parameter purposes and constraints, compensating well for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Detect category for a transaction using AI.' This specifies the verb ('detect'), resource ('category'), and method ('using AI'), distinguishing it from sibling tools like 'create_transaction' or 'update_transaction'. However, it doesn't explicitly differentiate from 'search_transactions' or 'link_transaction', which is why it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites, such as needing an existing transaction or specific data format, nor does it compare to other tools like 'search_transactions' for filtering or 'update_transaction' for modifying categories. This leaves the agent with minimal context for decision-making.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It implies a read-only operation ('Get'), but doesn't disclose authentication requirements, rate limits, error conditions, or what 'detailed information' entails (e.g., structured data vs. raw text). For a tool with zero annotation coverage, this is inadequate transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with zero wasted words. It's front-loaded with the core action and resource, making it easy to parse. Every part of the sentence earns its place by conveying essential purpose without fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'detailed information' includes (e.g., company name, address, settings), potential return formats, or any side effects. For a tool that likely returns structured data, more context is needed to guide the agent effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here. A baseline of 4 is given since it avoids redundancy and correctly handles the lack of parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('detailed information about the user's company'), making the purpose understandable. It distinguishes itself from siblings like 'get_company_balance' or 'get_company_tax_statistics' by focusing on general company details rather than specific financial or tax data. However, it doesn't explicitly contrast with 'update_company_details', which would have made it a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites (e.g., authentication context), differentiate from similar tools like 'get_client' for client-specific data, or indicate when not to use it (e.g., for updating details). This leaves the agent with minimal context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the action ('link') but does not explain what linking entails (e.g., whether it's a mutating operation, if it requires specific permissions, or what happens on failure). This leaves critical behavioral traits unspecified, making it inadequate for informed use.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and concise, with a clear purpose statement followed by separate Args and Returns sections. Every sentence serves a specific function without redundancy, making it easy to parse and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a linking operation with no annotations and no output schema, the description is incomplete. It fails to explain the behavior, potential side effects, error handling, or return value details, leaving significant gaps for an agent to use the tool effectively in context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explicitly lists and names both parameters ('invoice_id' and 'transaction_id') in the Args section, adding meaning beyond the input schema, which has 0% description coverage. This clarifies what each parameter represents, though it does not provide format details or validation rules, keeping it from a perfect score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('link') and the resources involved ('transaction' and 'invoice'), making the purpose immediately understandable. However, it does not differentiate this tool from sibling tools like 'link_attachment_transaction', which might also involve linking operations, leaving some ambiguity about its specific role in the toolset.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 when linking is necessary compared to creating or updating transactions/invoices. It lacks context on prerequisites, error conditions, or typical workflows, offering minimal usage direction beyond the basic action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions the return type ('List of clients with their details'), which adds some value, but fails to describe critical behaviors such as pagination, sorting, filtering, rate limits, or authentication requirements. For a list operation with zero annotation coverage, 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the main purpose in the first sentence. The second sentence adds useful return information without redundancy. However, it could be slightly more structured by explicitly separating behavior from output.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states the purpose and return value, but lacks details on behavior (e.g., pagination) and usage context. For a list tool in a financial context with many siblings, more guidance would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the schema description coverage is 100%, so there's no need for parameter details in the description. The description doesn't add parameter semantics, but that's acceptable here. A baseline of 4 is appropriate since no parameters exist to document.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('list of all clients for the company'), making the purpose explicit. However, it doesn't distinguish this tool from sibling tools like 'get_client' or 'search_transactions', which might also retrieve client information in different ways.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention when to prefer 'list_clients' over 'get_client' (for a single client) or 'search_transactions' (which might filter clients indirectly), nor does it specify prerequisites like authentication or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions that the tool returns a list of company tax settings, which implies a read-only operation, but does not specify details like authentication requirements, rate limits, error handling, or data format. For a tool with no annotations, this is insufficient to fully inform the agent about its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, with the main purpose stated clearly in the first sentence. The second sentence adds return value information, which is useful. There is no wasted text, making it efficient, though it could be slightly more structured (e.g., bullet points) for a perfect score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no annotations, no output schema), the description is minimally adequate. It states what the tool does and what it returns, but lacks details on usage context, behavioral traits, or output structure. For a read-only list tool, this is acceptable but leaves gaps that could hinder optimal agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, meaning there are no parameters to document. The description does not add parameter information beyond the schema, but since there are no parameters, the baseline is 4. It effectively communicates that no inputs are required, which is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get list of tax settings for the current company.' It specifies the verb ('Get list'), resource ('tax settings'), and scope ('for the current company'), which is straightforward. However, it does not explicitly differentiate from sibling tools like 'get_company_tax_statistics' or 'update_tax_setting', which would be needed for a score of 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It does not mention when it is appropriate (e.g., for viewing all tax settings) or when not to use it (e.g., compared to 'get_tax_report' or 'update_tax_setting'), nor does it reference any sibling tools. This lack of context leaves usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions the return type ('List of tax states') but lacks details on format, pagination, error handling, or authentication needs. For a read operation with zero annotation coverage, this is insufficient, though it's not misleading.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise with two sentences, front-loading the purpose and then specifying the return. There's no wasted text, and it's appropriately sized for a simple tool. However, it could be slightly more structured by integrating the return info into the main statement, preventing a perfect score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does and what it returns, but lacks details on behavioral aspects like data format or usage context. With no output schema, it should ideally describe the return structure more fully, but it meets the bare minimum.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and it doesn't introduce any confusion. A baseline of 4 is appropriate for zero-parameter tools, as there's nothing to compensate for.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('list of available tax states'). It distinguishes itself from siblings like 'get_tax_report' or 'list_tax_settings' by focusing on tax states specifically. However, it doesn't explicitly differentiate from all possible alternatives, keeping it at a 4 rather than a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites, context, or exclusions, such as whether this is for reference data versus operational data. With many sibling tools like 'get_tax_report' or 'list_tax_settings', the lack of comparative guidance is a significant gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. While it states the action ('send an overdue payment reminder'), it lacks critical details: whether this triggers actual email delivery, requires specific permissions, has rate limits, affects invoice status (e.g., marks as reminded), or provides error handling. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized. It starts with a clear purpose statement, followed by a bullet-point list of parameters and a returns section. Each sentence earns its place by explaining functionality or parameters. However, the 'Returns' section is vague ('Response from the send overdue reminder request'), which slightly reduces efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (6 parameters, mutation action) and lack of annotations/output schema, the description is moderately complete. It covers parameter semantics adequately but misses behavioral aspects like side effects, error conditions, and usage context. For a tool that sends emails and potentially updates invoice states, more detail on outcomes and constraints would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds substantial meaning beyond the input schema, which has 0% schema description coverage. It explains each parameter's purpose: 'invoice_id' identifies the target, 'subject' and 'body' define email content, 'additional_emails' lists extra recipients, 'is_send_to_company' controls company copy, and 'custom_client_email' overrides default client email. This compensates well for the schema's lack of descriptions, though it doesn't detail formats (e.g., email validation).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Send an overdue payment reminder for an invoice via email.' It specifies the verb ('send'), resource ('overdue payment reminder'), and delivery method ('via email'), which distinguishes it from generic email-sending tools. However, it doesn't explicitly differentiate from sibling tools like 'send_invoice', which might handle initial invoice delivery rather than overdue reminders.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites (e.g., invoice must be overdue), compare it to 'send_invoice' for initial notifications, or specify conditions like invoice status. Without this context, an agent might misuse it for non-overdue invoices or duplicate communications.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It mentions that the tool 'Create[s] a new attachment' and returns 'Created attachment information', but doesn't disclose critical traits like whether this is a mutating operation (implied by 'Create'), error conditions, authentication requirements, rate limits, or side effects. The description is too basic for a tool with 17 parameters and no annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately front-loaded with the core purpose, but the parameter list is extremely verbose (17 items). While each parameter explanation is brief, the overall structure feels bloated. The 'Returns' section is minimal but adequate. Some parameters could potentially be grouped or explained more efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (17 parameters, no annotations, no output schema), the description provides excellent parameter semantics but lacks crucial behavioral context. It doesn't explain the return format beyond 'Created attachment information', error handling, or system constraints. For a creation tool with financial data implications, more guidance on validation, constraints, and typical usage patterns would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides extensive parameter documentation with clear explanations for all 17 parameters, far exceeding the 0% schema description coverage. Each parameter is listed with a brief semantic explanation (e.g., 'Path to file to upload', 'Type of attachment (invoice, receipt)', 'Country of supplier (DE, INSIDE_EU, OUTSIDE_EU)'), adding significant value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 'attachment', making the purpose unambiguous. It distinguishes from siblings like 'upload_bulk_attachments' by focusing on single attachment creation, though it doesn't explicitly compare to other attachment-related tools like 'list_attachments' or 'link_attachment_transaction'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'upload_bulk_attachments' for multiple files or 'link_attachment_transaction' for linking existing attachments. The description lacks context about prerequisites, such as needing existing transactions to link, or when this tool is appropriate compared to other creation tools like 'create_invoice'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 tool retrieves XML data but doesn't describe what happens if the invoice_id is invalid (e.g., errors, null returns), authentication needs, rate limits, or data format specifics. For a read operation with zero annotation coverage, this leaves significant gaps in understanding tool behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by structured 'Args' and 'Returns' sections. Every sentence earns its place: the first defines the tool, the second explains the parameter, and the third specifies the return value. It's appropriately sized with zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is minimally complete. It covers the basic purpose and parameter but lacks behavioral details (e.g., error handling) and usage context. Without annotations or output schema, the agent has incomplete information for reliable invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter: 'invoice_id: ID of the invoice to get XML for.' Since schema description coverage is 0% (the schema only provides a title 'Invoice Id' and type), this compensates well by explaining the parameter's role. With only one parameter, the baseline is high, and the description clarifies its purpose adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get the e-invoice XML for a specific invoice.' It specifies the verb ('Get') and resource ('e-invoice XML'), distinguishing it from sibling tools like 'get_invoice' which likely retrieves invoice details rather than XML data. However, it doesn't explicitly differentiate from potential XML-related tools (none are present in siblings), so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites (e.g., invoice must exist), exclusions (e.g., only for e-invoices), or compare it to siblings like 'get_invoice' or 'send_invoice'. 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It mentions retrieving 'details' but doesn't specify format, permissions required, error conditions, or whether it's a read-only operation. For a tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with only three sentences that each serve a clear purpose: stating the action, explaining the parameter, and indicating the return. There's no wasted text, and information is front-loaded with the core purpose stated first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter retrieval tool with no output schema, the description covers the basics but lacks important context. It doesn't explain what 'tax report details' include, whether authentication is needed, or how errors are handled. While adequate for simple retrieval, more completeness would help the agent use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explicitly documents the single parameter 'report_id' with semantic meaning ('Public ID of the tax report to retrieve'), which is valuable since schema description coverage is 0%. It clarifies what the identifier represents, though it doesn't provide format examples or validation rules that would justify a perfect score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'retrieve' and the resource 'specific tax report', making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'list_tax_reports' or 'get_vat_next_report', which would require explicit scope comparison to achieve a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'list_tax_reports' for browsing or 'get_vat_next_report' for specific report types. The description only states what it does, not when it's appropriate, leaving the agent to infer usage context from tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states the basic action without disclosing behavioral traits. It doesn't mention whether this is a read-only operation, if it requires authentication, how results are returned (e.g., pagination), or any rate limits, leaving significant gaps for a tool that likely interacts with sensitive tax data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It is front-loaded and appropriately sized for a simple listing tool, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema), the description is minimally adequate but lacks depth. Without annotations or output schema, it should ideally clarify what 'list' entails (e.g., format, scope) to be more complete, especially in a context with many sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate, earning a baseline score of 4 for not introducing unnecessary complexity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and resource ('tax reports'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_tax_report' or 'list_tax_settings', which would require more specificity to earn a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 like 'get_tax_report' or 'list_tax_settings'. It lacks context about prerequisites, timing, or exclusions, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions uploading files and an optional cashflow type, but fails to disclose critical traits like required permissions, rate limits, file format restrictions, or whether the operation is idempotent. For a bulk mutation tool, this lack of detail 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by clear sections for Args and Returns. Every sentence earns its place, with no redundant information, making it efficient and easy to parse for an agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description provides basic purpose and parameter semantics but lacks behavioral details (e.g., error handling, response format). For a bulk upload tool with mutation implications, this is minimally adequate but leaves gaps in understanding how to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for both parameters: 'file_paths' is explained as 'List of paths to files to upload', and 'cashflow_type' is clarified with its optional nature and allowed values (INCOME or EXPENSE). Since schema description coverage is 0%, this compensates well, though it doesn't specify path format (e.g., local vs. remote).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Upload') and resource ('multiple file attachments in bulk'), distinguishing it from siblings like 'create_attachment' (singular) and 'list_attachments' (read-only). However, it doesn't explicitly differentiate from 'link_attachment_transaction', which might involve attachments but with a different focus.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'create_attachment' (for single uploads) or 'link_attachment_transaction' (for linking existing attachments). The description lacks context about prerequisites, such as whether files must be pre-processed or if there are size limits, leaving the agent with no usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Create a new client' implies a write/mutation operation, the description doesn't disclose important behavioral traits: what permissions are required, whether creation is idempotent, what validation occurs, what happens on duplicate clients, or error conditions. The return statement is minimal without format details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (Args, Returns) and front-loaded purpose. Each parameter explanation is concise yet informative. The only minor inefficiency is repeating 'Client' before each parameter name, but this adds clarity. Overall, every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (9 parameters, mutation operation) with no annotations and no output schema, the description is partially complete. It excels at parameter documentation but lacks behavioral context for a creation tool. The return statement is minimal ('Newly created client record') without format details. For a mutation tool with significant parameters, more behavioral guidance would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides excellent parameter semantics beyond the schema. With 0% schema description coverage (titles only, no descriptions), the description fully compensates by explaining each parameter's purpose and providing examples ('DE' for country) and constraints ('defaults to "business"', 'Options: "business", "private"'). This adds substantial value over the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with 'Create a new client' - a specific verb+resource combination. It distinguishes from siblings like 'update_client' and 'delete_client' by specifying creation rather than modification or deletion. However, it doesn't explicitly differentiate from other creation tools like 'create_invoice' or 'create_attachment' beyond the resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, when to choose this over 'update_client' for existing clients, or how it relates to other client operations like 'get_client' or 'list_clients'. The agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this creates a transaction but doesn't mention permissions required, whether it's idempotent, error conditions, or what 'manual' implies operationally. The return statement is vague ('Information about the created transaction') without detailing format or structure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (Args, Returns) and uses bullet-like formatting. Every sentence adds value, though the opening line is somewhat redundant with the tool name. It could be slightly more front-loaded with key behavioral information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a creation tool with 8 parameters, no annotations, and no output schema, the description does well on parameters but lacks behavioral context. It explains what each parameter does but not how the tool behaves overall, what errors might occur, or what the return data contains. This leaves significant gaps for the agent to operate effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides excellent parameter semantics beyond the 0% schema coverage. It explains each parameter's purpose, format constraints (e.g., 'YYYY-MM-DD format'), default behaviors ('defaults to today'), value meanings (e.g., 'positive for income, negative for expense'), and special logic ('categorized automatically using AI' for category_id). This fully compensates for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 ('manual transaction'), making the purpose unambiguous. It distinguishes from siblings like 'update_transaction' or 'search_transactions' by focusing on creation. However, it doesn't explicitly differentiate from 'create_invoice' or 'create_recurring_invoice', which might be related transaction types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites, when manual transactions are appropriate versus automated ones, or how this differs from similar tools like 'create_invoice'. The agent must infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. While it mentions the tool retrieves a list with filtering capabilities, it doesn't address important behavioral aspects like whether this is a read-only operation, potential rate limits, authentication requirements, pagination behavior, or what happens when no filters are applied. The description is minimal and lacks crucial operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections for purpose, arguments, and returns. It's appropriately sized and front-loaded with the core purpose. While efficient, the 'Args' and 'Returns' sections could be slightly more concise, but overall it's a clean, organized presentation with minimal waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (5 optional parameters, no annotations, no output schema), the description is partially complete. It excels at explaining parameters but lacks important context about the tool's behavior, return format details, and usage guidelines. For a list/search tool without annotations or output schema, more operational context would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides excellent parameter semantics that fully compensate for the 0% schema description coverage. For all 5 parameters, it clearly explains their purpose, filtering behavior, and specific details like 'case insensitive partial match' for text fields and the allowed values for 'attachment_type'. This adds significant value beyond what the bare schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Get list of attachments with optional filters', which is a specific verb+resource combination. However, it doesn't distinguish this tool from other list/search tools on the server like 'list_clients' or 'search_transactions', which reduces the score from a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. With sibling tools like 'search_transactions' and 'list_clients' available, there's no indication of when this attachment listing tool is appropriate versus other search or listing operations. The description only explains what the tool does, not when to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('send an invoice via email') but lacks critical details: it doesn't mention authentication requirements, rate limits, whether the invoice status changes after sending, error handling, or what 'Response from the send invoice request' entails. This is inadequate for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a brief purpose statement followed by parameter explanations and a returns section. It's front-loaded and efficient, though the 'Returns' line is vague and could be more informative, slightly reducing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (6 parameters, mutation action) and lack of annotations/output schema, the description is partially complete. It excels in parameter semantics but falls short in behavioral transparency and usage guidelines, leaving gaps in understanding how and when to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant value beyond the input schema, which has 0% schema description coverage. It provides clear explanations for all 6 parameters, including optional behaviors (e.g., 'By default the email address of the client is used if it is set'), default logic, and purpose. This fully compensates for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Send an invoice via email,' which is a specific verb+resource combination. It distinguishes itself from sibling tools like 'send_invoice_overdue_reminder' by focusing on general invoice sending rather than reminders, though it doesn't explicitly contrast with other email-related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites (e.g., invoice must exist), compare with other tools like 'send_invoice_overdue_reminder,' or specify scenarios where it's appropriate, leaving usage context unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that submission may fail with a 403 status if a paid subscription is required, which is useful behavioral context. However, it lacks details on other potential outcomes (e.g., success codes, error handling beyond 403), side effects, or authentication needs, leaving gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose in the first sentence. The 'Args' and 'Returns' sections are structured clearly, though the return explanation could be more concise. Every sentence adds value, but minor verbosity in the return statement prevents a perfect 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description provides basic purpose, parameter semantics, and some behavioral transparency (403 handling). However, as a mutation tool with potential side effects (submitting to a tax authority), it lacks details on success responses, error scenarios beyond 403, and integration context, making it adequate but incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter 'report_id' by specifying it as a 'Public ID of the tax report to submit'. Since schema description coverage is 0% (schema only provides title 'Report Id' and type), this compensates well by clarifying the parameter's role and format. With 0 parameters beyond this, it meets the baseline of 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Submit a tax report') and the target ('to the Finanzamt'), which is a specific government tax authority. It distinguishes from siblings like 'get_tax_report' (retrieval) and 'generate_finanzamt_preview' (preview). However, it doesn't explicitly differentiate from other submission-related tools (none exist in siblings), so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites (e.g., needing a prepared report via 'get_tax_report'), exclusions, or comparisons to other tools. The only implicit context is that a report must exist, but this isn't stated explicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this is an update operation but doesn't mention permission requirements, whether partial updates are allowed (vs. full replacement), validation rules, error conditions, or what happens when null values are provided. The 'Returns' statement is minimal and doesn't describe the record structure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (Args, Returns) and uses bullet points for parameters, making it scannable. However, the parameter list is quite long (10 items), and the opening statement is minimal without additional context about the update operation's behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with 10 parameters, no annotations, and no output schema, the description provides good parameter documentation but lacks critical behavioral context. It doesn't explain update semantics (partial vs. full), error handling, or return value structure. The presence of sibling tools like 'create_client' and 'delete_client' suggests this is part of a CRUD system that needs more contextual explanation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides excellent parameter semantics despite 0% schema description coverage. Each of the 10 parameters is clearly documented with meaningful explanations, including the client_type enum values ('business' or 'private') and country code format example ('DE'). This fully compensates for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Update an existing client') and resource ('client'), making the purpose immediately understandable. However, it doesn't differentiate this tool from other client-related tools like 'update_company_details' or explain how it differs from 'create_client' beyond the obvious creation vs. update distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. While 'update_client' is clearly for modifying existing clients, there's no mention of prerequisites (e.g., client must exist), when to use 'update_company_details' instead, or how this relates to 'delete_client' or 'get_client' workflows.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions filtering and a default limit, but lacks critical details: whether this is a read-only operation, if it requires authentication, pagination behavior, rate limits, error conditions, or what happens when no filters are applied. For a list tool with 5 parameters, this leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a brief purpose statement followed by well-organized parameter and return sections. Every sentence earns its place by providing necessary information without redundancy. The formatting with clear headings makes it easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (5 parameters, no output schema, no annotations), the description is partially complete. It excels at parameter documentation but lacks behavioral context and usage guidance. Without annotations or output schema, the agent doesn't know the return structure beyond 'List of invoices', which is insufficient for proper tool invocation and result interpretation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds substantial value beyond the input schema, which has 0% description coverage. It clearly explains all 5 parameters: their purposes, allowed values for 'status', date format for 'from_date' and 'to_date', and the default for 'limit'. This fully compensates for the schema's lack of descriptions and provides essential context for parameter usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('List') and resource ('invoices'), and mentions optional filtering. It distinguishes from siblings like 'get_invoice' (singular) by indicating it returns multiple items. However, it doesn't explicitly differentiate from other list tools like 'list_clients' or 'list_attachments' beyond the resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It doesn't mention prerequisites, compare with 'search_transactions' or 'get_invoice', or specify scenarios where filtering is beneficial. The agent must infer usage from the tool name and parameters alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 mentions that results have 'sensitive data removed,' which is valuable behavioral context about data sanitization. However, it doesn't address other important behaviors like pagination (only mentions limit), sorting, error conditions, authentication requirements, or rate limits. For a search tool with 11 parameters, this leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (Args, Returns) and uses bullet-like formatting that makes parameters easy to scan. Every sentence serves a purpose - the opening statement defines the tool, and each parameter explanation is necessary. It could be slightly more concise by combining some parameter explanations, but overall it's efficiently organized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (11 parameters, no annotations, no output schema), the description is partially complete but has significant gaps. It excels at parameter documentation but lacks crucial context about the search behavior, result format beyond 'list of matching transactions,' error handling, and how this tool relates to sibling tools. For a search operation in a financial context, more behavioral transparency would be expected.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides excellent parameter semantics that fully compensate for the 0% schema description coverage. Each of the 11 parameters is clearly documented with meaningful explanations beyond just their names (e.g., 'Text to search for in transaction descriptions,' 'Start date in YYYY-MM-DD format,' 'Whether to exclude invoices'). The description adds substantial value by explaining what each parameter does, their formats, and default values where applicable.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search for transactions matching specified criteria.' This is a specific verb ('search') applied to a specific resource ('transactions'), making the function immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_invoices' or 'get_transaction' (though none exist), so it doesn't reach the highest tier of sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, when this search is appropriate versus other listing tools, or any context about transaction types. The agent must infer usage from the parameter list alone, which is insufficient for optimal tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses some behavioral traits like auto-generation of invoice numbers and default values (e.g., currency, dates), but lacks details on permissions, error handling, rate limits, or what 'create' entails beyond the PDF generation mentioned in returns.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is overly verbose and poorly structured, mixing usage prompts with parameter details in a long block. It could be more front-loaded and concise; for example, the conditional prompts could be summarized, and parameter explanations are exhaustive but not efficiently organized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex tool with 23 parameters, no annotations, and no output schema, the description is largely complete—it explains parameters thoroughly and specifies the return includes a PDF URL. However, it lacks details on behavioral aspects like authentication or error cases, leaving some gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Given 0% schema description coverage and 23 parameters, the description compensates fully by explaining each parameter's purpose, format, defaults, and examples. It adds significant meaning beyond the schema's basic titles, such as VAT rate options, date formats, and conditional dependencies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates a new invoice with the verb 'Create' and resource 'invoice'. It distinguishes from siblings like 'send_invoice' or 'create_recurring_invoice' by focusing on initial creation, though it doesn't explicitly contrast them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage through conditional prompts (e.g., 'If the client is not found...'), suggesting when to gather additional data. However, it lacks explicit guidance on when to use this tool versus alternatives like 'create_recurring_invoice' or 'send_invoice', and doesn't mention prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states this is an update operation (implying mutation) and mentions a preview requirement, which adds behavioral context. However, it lacks details on permissions needed, whether changes are reversible, rate limits, or error conditions. For a mutation tool with zero annotation coverage, this is a moderate gap, but the preview guidance adds some value.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose statement, usage guideline, and parameter/return sections. Every sentence earns its place: the first states the action, the second gives critical guidance, and the rest document inputs/outputs. It could be slightly more front-loaded by integrating parameter hints earlier, but it's efficient overall.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 6 parameters, 0% schema coverage, no annotations, and no output schema, the description does moderately well. It covers purpose, usage, and parameters, but lacks details on return values (only states 'Updated tax setting' vaguely), error handling, or side effects. For a mutation tool in a financial context, more completeness is needed, though the preview guidance helps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It lists all 6 parameters with brief examples (e.g., 'sales' for tax_type), which adds meaning beyond the schema's titles. However, it doesn't explain parameter relationships, constraints, or default behaviors (e.g., null handling), leaving gaps. The description provides basic semantics but doesn't fully cover the parameter complexity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Update' and the resource 'a tax setting', making the purpose immediately understandable. It distinguishes from siblings like 'list_tax_settings' (read) and 'submit_tax_report' (different action), though it doesn't explicitly contrast with 'update_company_details' which might handle related settings. The purpose is specific but could be more differentiated from other update tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance: 'Always generate a preview of the tax report @generate_finanzamt_preview before submitting it to the Finanzamt.' This specifies a prerequisite action and names the alternative tool, giving clear when-to-use context. It implies this tool is part of a workflow leading to tax submission.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 describes the creation of recurring invoices and mentions automatic generation, but lacks details about permissions, error handling, rate limits, or system behavior beyond the basic operation. The 'Always ask for...' and 'Ask for additional information...' sections provide some interaction guidance but not comprehensive behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately front-loaded with the core purpose, but becomes verbose with detailed parameter guidance and a full parameter list that duplicates the schema. While the information is valuable, the structure could be more streamlined by separating high-level guidance from exhaustive parameter documentation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex creation tool with 27 parameters, no annotations, and no output schema, the description does a good job of explaining the tool's purpose, usage context, and parameter semantics. It includes return value information ('always include the generated invoice pdf url from reportUrl field'), though it could benefit from more behavioral context about the recurring invoice system's operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Given 0% schema description coverage and 27 parameters, the description provides extensive parameter semantics beyond the schema. It explains the purpose of recurring configuration parameters (frequency_type, frequency_unit, starts_from_date, ends_on_date, ends_on_invoice_count), clarifies dependencies ('Either ends_on_date or ends_on_invoice_count should be provided'), and adds context for many other parameters through the 'Ask for additional information' section.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Create a recurring invoice that will automatically generate new invoices based on specified frequency.' It specifies the verb ('create'), resource ('recurring invoice'), and distinguishes it from sibling tools like 'create_invoice' by emphasizing the automated recurring nature.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('Useful for contracts or services that bill on a regular basis') and includes implicit guidance through examples of required information. However, it does not explicitly state when NOT to use it or name specific alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![norman-mcp-server MCP server](https://glama.ai/mcp/servers/norman-finance/norman-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/norman-finance/norman-mcp-server)

Score Badge

Copy to your README.md:

[![norman-mcp-server MCP server](https://glama.ai/mcp/servers/norman-finance/norman-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/norman-finance/norman-mcp-server)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/norman-finance/norman-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server