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

Annotations already declare readOnly, idempotent, non-destructive, so the description is not required to restate safety. It adds return-field names (periodStart, totalAmount, etc.), but doesn't add behavioral context like timezone, auth constraints, or error behavior beyond what annotations provide.

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

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

The description is short and front-loaded with the core purpose, and the Returns line adds value because no output schema exists. The Args block is somewhat redundant against the input schema but not verbose enough to be a serious problem.

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

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

For a read-only, two-parameter tool with strong annotations and a return-format note, the description together with the schema covers everything needed to call it. The only missing piece is explicit sibling differentiation, which is already penalized under usage guidelines.

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

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

Schema covers 100% of parameters with descriptions and enums. The description's Args section repeats those same allowed values and defaults without adding meaning beyond the schema.

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

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

The description names a specific verb and resource ('Get spending summary for a preset period') and lists four concrete presets. It does not explicitly contrast with same-domain siblings, but the preset scoping is enough to identify the tool's purpose.

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

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

There is no 'when to use' guidance, nor any comparison with siblings like ogarniai_get_weekly_summary or ogarniai_get_summary_by_period. The reader must infer the right choice from tool names and enum values.

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

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

Annotations already cover the read-only/non-destructive safety profile. The description adds value by disclosing the response shape (JSON with full document fields, items, categories, tags, and duplicate info), which is not available from an output schema since none is present.

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

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

Clear, front-loaded summary followed by argument details and return type. Minor redundancy between 'Returns full document details...' and the later 'Returns...' line, but overall compact and scannable.

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

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

For a read-only get-by-ID tool with one parameter and rich annotations, the description provides enough information to invoke it correctly. It does not explain error behavior or auth requirements, but those are not essential for this simple read operation.

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

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

The only parameter is fully documented in the schema with type, format, and resource ID description; the description restates it as 'id (string): Document ID (UUID format)' without adding much new meaning. Schema coverage is high, so baseline 3 is appropriate.

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

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

States a specific verb ('Get'), resource ('details of a single purchase document'), and access pattern (by ID). It also enumerates the returned content, making it easy to distinguish from list or image siblings.

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

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

The description clearly implies this tool is for retrieving one purchase document by ID, but it does not explicitly contrast with sibling tools like ogarniai_list_categories or ogarniai_get_document_image. Context is present, but no explicit when-to-use or when-not-to-use guidance is given.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds the return format ('JSON with duplicate document suggestions and confidence scores'), which is useful, but it does not disclose any additional behavioral details such as possible empty results or data sources.

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

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

The description is compact, front-loaded with the main purpose, and cleanly structured with Args and Returns sections. Every sentence contributes useful information with no redundancy.

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

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

For a simple single-parameter read-only tool with rich annotations, the description covers the key elements: what it operates on and what it returns. Since there is no output schema, the explicit return summary is helpful, though alternative-tool guidance is missing.

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

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

Schema description coverage is 100%, so the schema already documents the single 'id' parameter. The description restates it as 'Document ID (UUID format)' and adds the purchase-document context, but it adds no meaningful semantic detail beyond the schema.

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

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

The description states a clear action ('Get duplicate suggestions') on a specific resource ('a specific purchase document'). It is distinct from generic document retrieval, though it does not explicitly differentiate from the sibling 'list_dedup_suggestions' tool.

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

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

There is no guidance on when to use this tool versus alternatives such as ogarniai_list_dedup_suggestions or ogarniai_get_document. The phrase 'for a specific purchase document' implies per-document usage, but no explicit conditions, exclusions, or alternative routing are provided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that the return is base64-encoded image data, which is useful behavioral context beyond the annotations. However, it doesn't disclose details like potential size limits, whether the image is a thumbnail or full-resolution, or error behavior for missing documents.

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

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

The description is compact and front-loaded with the core purpose in the first sentence. The Args/Returns structure is clear and scannable. Minor redundancy: the id description in Args duplicates the schema's description, but overall it's efficient and well-organized.

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

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

For a simple single-parameter read-only tool with rich annotations, the description is mostly complete. It states the input and the return format (base64). However, it doesn't mention what the image represents beyond 'receipt photo' (e.g., whether it's the original scan or a processed version), and there's no output schema to clarify the response structure. Given the tool's simplicity, this is adequate but not exceptional.

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

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

Schema description coverage is 100%: the schema already documents the id parameter as 'Resource ID (UUID format)' with format and pattern constraints. The description repeats the id parameter with the same meaning, adding no new semantic information beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool retrieves the scanned image of a purchase document (receipt photo), which is a specific verb+resource combination. It distinguishes from siblings like ogarniai_get_document (which likely returns document metadata/data) by specifying 'image' and 'receipt photo', though it doesn't explicitly name the sibling it differs from.

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

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

The description implies usage: call this when you need the scanned image of a document. It doesn't explicitly state when to use this vs ogarniai_get_document or other siblings, nor does it mention alternatives. The context is clear enough for a simple retrieval tool, but no explicit when/when-not guidance is provided.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds behavioral context by detailing the return structure (JSON with specific fields), which goes beyond the annotations. It does not disclose error handling or authentication, but given the annotations, this added return-format context earns a 4.

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

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

The description is compact and front-loaded with the primary action, followed by a structured Args/Returns docstring. Every sentence contributes to caller understanding without redundancy or irrelevant detail, making it highly efficient.

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

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

For a simple single-parameter read operation with no output schema, the description is complete: it specifies the exact parameter, the return format with all fields, and is backed by annotations covering idempotency and read-only behavior. Nothing essential for an agent to successfully invoke the tool is missing.

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

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

The input schema already fully documents groupId with a description and UUID format (100% coverage). The description repeats 'groupId (string): Group ID (UUID format)' without adding new meaning, so per the rubric the baseline of 3 is appropriate; it adds no semantic value beyond the schema.

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

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

The description clearly states 'Get details of a specific finance group,' specifying the verb, resource, and that it targets a single group. The Returns line enumerates the fields (id, name, description, owner, isActive, isArchived, memberCount), making the purpose precise and distinguishing it from the sibling ogarniai_list_groups which lists all groups.

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

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

Usage is implied: to retrieve a single group's details, this tool is used with a groupId. However, the description does not explicitly mention when to prefer this over the sibling ogarniai_list_groups, nor does it state any preconditions or alternatives. There is no when-not guidance, so it relies on the agent to infer the appropriate context.

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

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

Annotations already cover the safety profile with readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to repeat those. It adds the return field list, but it does not disclose behavior for missing/invalid IDs or error cases. Overall this is adequate but not above and beyond the annotations.

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

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

The description is cleanly structured with a one-line purpose, an Args block, and a Returns breakdown. It is appropriately sized for a one-parameter read-only getter and has no filler, though the Args section is slightly redundant alongside the input schema.

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

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

This is a simple one-parameter read-only tool with rich annotations and an explicit return-field list, which is enough for a correct basic invocation. The main gap is the absence of error/not-found behavior and a hint that IDs should come from ogarniai_list_notifications, but this is minor for a getter of this complexity.

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

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

Schema coverage is 100% and the schema already fully describes the id parameter with format, pattern, and description. The description's 'Notification ID (UUID format)' adds only a marginal semantic label over the schema's generic 'Resource ID,' so it does not meaningfully go beyond what structured data already provides.

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

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

The description clearly states a specific action and resource: 'Get details of a specific notification.' This distinguishes it from list-oriented siblings such as ogarniai_list_notifications and ogarniai_get_unread_count, so an agent can select it as the single-object retrieval tool.

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

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

The intended usage is implied: use it when you have a notification ID and need full details for one specific notification. However, there is no explicit when-not-to-use guidance or mention of alternatives like ogarniai_list_notifications for finding IDs, so this dimension only reaches 'implied usage,' not explicit routing.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds a useful disclosure of the exact response shape, including field names such as frequency, category, and nextOccurrenceDate. No contradicting behavior is described.

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

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

The description is compact and well-structured: purpose and examples first, then parameter, then return shape. Every sentence adds useful information and nothing is redundant.

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

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

The tool is simple with one optional parameter amenable to the schema 100%. The description adds the return field list explicitly, compensating for the absence of an output schema. Combined with annotations covering safety and idempotency, nothing important is missing.

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

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

With only one boolean parameter and 100% schema coverage, the schema already documents includeInactive and its default. The description repeats this information without adding extra meaning, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb-resource pair ('List recurring expenses') and adds clarifying examples ('subscriptions, bills, regular payments'). This clearly distinguishes the tool from siblings like get_summary_by_period or list_documents, which target different resources.

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

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

The description makes the tool's scope clear and includes the optional includeInactive parameter with its default behavior. It does not explicitly name alternative tools for the same resource, but none of the siblings provide a competing recurring-expense listing, so no exclusion is needed.

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

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

Annotations already declare read-only, idempotent, and non-destructive. The description goes beyond that by enumerating the actual return shape (periodStart, periodEnd, dailySummaries, categoryTotals, detailedCategoryTotals) and the granularity effect on breakdowns, which is useful behavioral information not present in the input schema or annotations.

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

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

Purpose is front-loaded; the parameter block is scannable; the return block is compact. The parameter list is slightly redundant with schema, but it is still short and does not bury the main point.

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

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

With no output schema, the description correctly fills the return-structure gapholistically. It could be more explicit about how granularity affects the returned 'dailySummaries' (e.g., weekly grouping), but for a simple 3-parameter read-only tool the description is almost fully sufficient.

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

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

Schema coverage is 100%, with descriptions and an enum/default for granularity. The description merely mirrors that information (parameter names and one-line hints) without adding parameter-level context such as date formats, constraints, or maximum range. Baseline 3 is appropriate.

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

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

The description states a specific verb ('get'), a specific resource ('spending summary'), and key constraints ('custom date range', 'configurable granularity') in one sentence. It clearly separates this tool from the weekly-summary sibling by emphasizing the custom range.

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

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

The description gives contextual context ('custom date range') that implies when this tool is appropriate, but it never mentions alternatives such as get_weekly_summary or get_current_period, and it does not offer explicit selection criteria (e.g., use this for arbitrary periods, use weekly for predefined weeks). Relies on inference.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior Mend. The description adds a clear return contract ('JSON with count (number)'), which is valuable because no output schema exists. It doesn't contradict annotations.

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

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

The description is two short sentences, front-loads the action, and every word adds value. The return format note is useful and there is no fluff.

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

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

With zero parameters, read-only/idempotent annotations, and an explicit return description, this is nearly complete for such a simple endpoint. It could add a sentence about what 'unread' means or whether the count is scoped to the authenticated user, but that is a minor gap.

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

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

The tool has zero parameters, so the baseline of 4 applies. The description doesn't need to explain parameter semantics, and the empty input schema is consistent with the tool's simple purpose.

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

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

The description clearly states a specific verb ('Get') and resource ('count of unread notifications'), which unambiguously distinguishes it from siblings like list_notifications and get_notification. It could earn a 5 if it explicitly contrasted with those sibling tools, but the purpose is still obvious.

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

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

There is no guidance on when to prefer this tool over alternatives. It doesn't mention that list_notifications should be used when actual notifications are needed, or that this is a lightweight count/check endpoint. The usage context is left entirely to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety and side-effect profile. The description adds useful behavioral detail by specifying the exact return fields (period dates, total, daily breakdowns, category totals, AI summary), which is not redundant with annotations. It doesn't contradict annotations; 'Get' aligns with readOnlyHint. The additional return-structure detail justifies a 4.

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

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

The description is two short sentences plus a 'Returns:' line that enumerates fields. It is front-loaded with the core purpose and immediately clarifies the output. No unnecessary words; every sentence contributes to understanding the tool's function and result. This is exemplary conciseness.

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

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

Given the tool has no parameters and no output schema, the description effectively explains the return value by listing the JSON fields. It covers all essential aspects: period dates, total amount, daily breakdowns, category totals, and AI summary. It does not discuss edge cases like empty data or error handling, but that is not critical for a simple read-only fetch. Slight room for improvement in mentioning possible absence of data, but overall complete for its complexity.

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

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

The input schema has no properties (0 parameters), so there is no parameter documentation burden. Per the rubric, 0 params warrant a baseline of 4. The description doesn't need to explain parameters, and its mention of the return structure is sufficient. No gap exists here.

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

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

The description states a specific action (get the most recent weekly spending summary) and resource (weekly summary). It clearly distinguishes from sibling tools like 'get_weekly_summary_periods' and 'get_summary_by_period' by emphasizing 'most recent' and implying no arguments are needed. This enables an agent to choose it correctly over period-specific alternatives.

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

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

The description implies when to use this tool: when you need the latest weekly summary without specifying a period. While it doesn't explicitly name alternative tools or conditions for not using it, the term 'most recent' plus the existence of period-specific siblings provides clear contextual guidance. A minor gap is the lack of an explicit exclusion statement.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior. The description adds useful behavioral context by stating that the result is paginated and describing the returned fields (periodStart, periodEnd, totalAmount, summary text), which is especially valuable since no output schema exists.

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

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

The purpose is front-loaded in a single sentence, and the Args/Returns sections are compact and readable. There is minor redundancy with the input schema, but the description remains focused and appropriately sized.

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

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

For a simple paginated list operation with no output schema, the description covers the essential invocation context: endpoints, parameters, pagination, and return shape. It does not define what 'available' means or how periods relate to current/previous summaries, but this is not critical for calling the tool correctly.

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

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

Schema coverage is 100%, with both page and pageSize fully described, including defaults and bounds. The description repeats this information without adding additional meaning or constraints beyond the schema.

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

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

The description states a clear action ('List') and a specific resource ('available weekly summary periods'), and mentions pagination. It is distinguishable from sibling tools like get_weekly_summary or get_summary_by_period by the focus on listing periods rather than retrieving a specific summary.

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

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

The context of use is implied: call this when you want the list of weekly summary periods. However, there is no explicit guidance on when not to use it or which sibling tool to prefer for related operations, such as retrieving a specific period's summary.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable context by detailing the return structure (full tree, Polish/English names, emojis, subcategory details) and the JSON format, which helps the agent anticipate output. No contradictions with annotations.

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

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

The description is three concise sentences, front-loaded with the core purpose. It avoids fluff and quickly specifies the output details. Every sentence earns its place, making it highly efficient for an agent to parse.

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

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

For a zero-parameter, read-only listing tool with no output schema, the description fully specifies what is returned—the complete JSON structure with categories and subcategories, including names, emojis, and descriptions. No missing information is critical for invocation or output interpretation.

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

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

The tool has zero parameters, so the schema is fully covered by default. The description does not need to explain parameters. Baseline of 4 for zero-param tools is applied, and the description adds no unnecessary parameter-related noise.

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

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

The description clearly states the verb 'list' and the resource 'all available expense/income categories and subcategories', specifying scope and content. It distinguishes itself from sibling listing tools (e.g., list_tags, list_documents) by naming the exact category tree with language and emoji details.

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

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

The usage context is implied: an agent would use this when needing the category tree. However, the description does not explicitly mention when to use it over alternatives, nor exclusions (e.g., 'if you need tags, use list_tags'). No additional guidance is provided beyond the obvious purpose.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful output-shape context (field names, confidence range, statuses), but it does not disclose behavioral details such as ordering, pagination, or whether the list is system-wide. This is adequate but not rich.

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

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

The description is compact and front-loads the core purpose. The sentence 'Returns pairs of documents that may be duplicates...' partially overlaps with the subsequent 'Returns: JSON array...' line, creating slight redundancy, but overall it is clear and free of filler.

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

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

With no output schema present, the description compensates by listing exact output fields, the confidence range, and status enum. It does not mention ordering or pagination, but for a zero-parameter read-only list operation the provided information is sufficient for an agent to understand what the tool returns.

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

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

The input schema has zero parameters, so there are no parameter semantics to explain. The description appropriately focuses on the output contract instead, which is the correct use of the text.

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

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

The description uses a specific verb ('List') and names the resource ('duplicate document suggestions detected by the system'), and it enumerates the returned fields. However, it does not explicitly differentiate itself from the sibling tool ogarniai_get_document_duplicates, leaving some ambiguity about whether this is a global list or per-document.

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

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

There is no guidance on when to use this tool versus alternatives such as ogarniai_get_document_duplicates. The description does not state the scope of the suggestions (all suggestions vs. those for a specific document) or mention workflow context, so an agent must infer usage from the name alone.

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

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

Annotations already mark the operation as read-only and idempotent, and the description adds behavioral detail by stating the result is paginated, is a JSON array, and includes a concrete field list. It also clarifies which document subtypes are included, going beyond what the annotations alone provide.

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

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

The description is well-structured with a summary line, an Args list, and a Returns field list, with no filler. There is minor redundancy around 'receipts' and purchase documents, but the overall length is appropriate and front-loaded.

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

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

With no output schema, the description compensates by enumerating the exact return fields and documenting all four optional parameters. It would be slightly richer if 'categories' appeared in the return field list, but the tool can still be invoked and interpreted confidently.

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

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

Schema description coverage is 100%, and the Args section largely mirrors the schema. It adds ISO 8601 date examples and restates defaults for sortBy and sortDirection, but these are already present in the schema, so the description does not add substantial meaning beyond the structured input definitions.

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

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

The description opens with a clear action verb and resource: 'List receipts and purchase documents' with optional date filters and sorting. The returned paginated list and document subtypes make the tool's scope unambiguous and distinguish it from single-document siblings like ogarniai_get_document.

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

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

The description clearly frames this as the tool to use when a paginated list of purchase documents is needed, with date and sorting controls. It does not explicitly name alternatives, but the list-vs-single distinction is clear from both the description and the sibling tool names.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds the default behavior for showArchived (false) and enumerates the returned fields, which is meaningful beyond the schema.

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

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

The description is compact and front-loaded: one purpose sentence, one args line, one returns line. No boilerplate or redundant content.

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

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

For a simple, read-only list operation with one optional parameter and no output schema, the description covers scope, defaults, and return fields. Nothing needed for correct invocation is missing.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds the default value of showArchived and clarifies the result is scoped to the user, moving it above baseline.

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

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

Description states a specific verb ('List'), resource ('finance groups'), and scope ('the user belongs to'). This is clearly distinguishable from sibling list tools like list_documents or list_notifications.

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

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

The intended use is clear: list groups tied to the current user, with an optional flag for archived groups. It doesn't explicitly compare with alternatives like get_group, so it isn't a 5, but no guidance is missing for typical selection.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description usefully adds the return field list ('id, program, maskedLogin, status, createdAt'), but it does not disclose possible behavior like pagination, rate limits, or authentication needs. Overall it adds some value without conflicting with annotations.

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

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

The description is only two sentences with no filler. The action is front-loaded, and the 'Returns' line compactly lists the output fields. Every sentence earns its place.

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

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

For a zero-parameter list tool, the description supplies both the domain and the returning field list, and the annotations cover safety and idempotency. A full output schema is absent, but the listed fields are enough for the agent to invoke the tool correctly and interpret simple results. Some nuance like possible status values is missing, but it is not critical here.

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

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

The tool exposes zero parameters and the schema has 100% coverage, so there are no parameter semantics to fill in. The baseline of 4 applies for parameterless tools, and the description does not need to add parameter-level detail.

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

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

The description starts with 'List connected external loyalty program accounts', which names a specific verb and resource, and the parenthetical 'e.g. store loyalty cards' clarifies the exact domain. Among sibling list tools, it uniquely targets external loyalty accounts, so the agent can distinguish it without needing to inspect schemas.

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

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

No explicit when-to-use / when-not-to-use guidance or alternative routing is provided. The intended use is implied by the action verb and resource ('list connected external loyalty accounts'), but there is no exclusion or stated condition that would help the agent choose this over other list tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering safety. The description adds useful behavioral context about the mailbox purpose and specifies the returned JSON array and its fields, which goes beyond the annotation-only view.

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

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

The description is short, front-loaded with the core listing purpose, and every sentence adds value: purpose, usage context, and return shape. No filler or redundant restatement of the tool name.

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

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

For a parameterless read-only listing tool, the description is complete: it states the resource, the intended workflow, and the return structure including field names. There is no output schema, so the description appropriately carries the return-format burden.

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

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

The input schema has zero parameters, so there are no parameter semantics to document. The description appropriately avoids inventing parameters, and the baseline of 4 applies because the schema fully covers an empty parameter set.

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

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

The description names a specific resource ('inbound email addresses') and a clear use case ('forwarding purchase confirmation emails'), so an agent knows exactly what this tool returns. It is readily distinguishable from sibling list tools such as list_documents and list_categories.

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

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

The description explains when the tool is useful: users forward store emails to these addresses for automatic receipt processing. It does not explicitly name alternatives or exclusion cases, but the context is clear enough for selection among the siblings.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful return-shape details (JSON array with field names) and pagination defaults without contradicting the annotations.

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

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

The description is front-loaded with a clear purpose sentence, followed by a compact Args/Returns structure. It is well organized and scannable, though the parameter list partially duplicates schema information.

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

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

Since there is no output schema, the description compensates by listing exact return fields. All five optional parameters are documented with defaults and enum values, and annotations cover the read-only/idempotent behavior, so an agent has enough context to invoke the tool correctly.

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

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

Schema description coverage is 100%, and the description largely restates the schema's parameter names, types, enums, and defaults. It adds no substantial new meaning beyond what the schema already provides, so the baseline score applies.

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

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

The description uses a specific verb ('List') and resource ('user notifications'), and mentions optional filters. It is clear and distinguishable from sibling resources like documents or unread count, though it does not explicitly contrast with get_notification or get_unread_count.

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

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

There is no guidance on when to use this tool instead of alternatives such as get_notification or get_unread_count. Usage must be inferred from the name and first sentence; no exclusions or alternative-selection conditions are provided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered by structured data. The description adds value by disclosing the return format ('JSON array of supported bank names (strings)'), which is behavior beyond the annotations. No contradiction exists between the description and annotations. The added context is useful but minimal — it doesn't describe ordering, size limits, or error behavior, so a 3 is appropriate.

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

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

The description is two short sentences with no filler: the core purpose is front-loaded, followed by the return contract. Each sentence earns its place for a zero-parameter tool. It is appropriately sized and well-ordered, though slightly more compact than the top tier.

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

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

For a read-only, zero-parameter listing tool, the description covers what it lists (banks for statement import) and what it returns (a JSON array of strings). The annotations carry the safety profile and the simple return type is stated. Nothing an agent needs to call it correctly is missing, so this is complete for the tool's low complexity.

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

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

The tool has zero parameters, and the rubric sets a baseline of 4 for 0-param tools. Schema description coverage is 100% (there are no properties to document). Nothing further is needed here since there is no parameter surface for the description to clarify.

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

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

The description states a specific verb ('List') and a precise resource ('banks supported for bank statement import'), which clearly differentiates it from the many sibling list tools (documents, categories, tags, notifications, etc.). The qualifier 'for bank statement import' adds scope that disambiguates it from any other bank-related tool. This is explicit and immediately understandable.

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

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

The description implies when to use it — when the agent needs to know which banks are importable for statements — but provides no explicit when-to-use or when-not-to-use guidance, and names no alternatives. Given the large set of sibling 'list_' tools, explicit routing would have helped, but the specific resource phrasing carries the intent adequately. This is implied-at-best guidance.

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

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

Annotations already cover the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false). The description adds the return shape and the 'user-defined' scope, which is useful but minimal. It does not contradict the annotations and adds some behavioral context, but lacks depth such as auth constraints or error behavior.

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

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

The description is exactly two purposeful sentences: one for the action and one for the return format. Every element earns its place, and the primary verb and resource are front-loaded in the first three words.

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

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

For a zero-parameter, read-only list tool with no output schema, this description is complete: it states the resource, scope, and the shape of the return value (array of tags with id, name, authorId). An agent has enough information to invoke it and interpret the result correctly.

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

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

The tool has zero parameters, so schema coverage is trivially 100%. Per calibration basics, 0 parameters deserves a baseline 4 because there is nothing for the description to compensate. It does not need to explain parameter semantics.

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

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

The description names a specific verb and resource: 'List all user-defined tags'. This clearly distinguishes it from siblings like ogarniai_list_categories (different taxonomy) and ogarniai_list_documents (different resource). The purpose is stated in one sentence with no ambiguity.

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

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

There is no guidance about when to prefer this tool over siblings such as list_categories or list_groups, nor any exclusions. The phrase 'for organizing documents' gives slight context but does not help an agent decide between alternatives. This is effectively 'no guidance'.

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