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 usefully discloses what the call returns (title + members) and implies validation failure on a bad link, but says nothing about error behavior, auth requirements, or whether a connection/session is persisted for later tools.

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

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

Two short, front-loaded sentences plus a compact Args line; the purpose comes first and every sentence adds operational value with no filler.

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

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

With no output schema, the description correctly covers the return values (title, members) and the cross-tool contract for acting_as, which is the key missing piece an agent would otherwise not know. Minor gaps remain around failure modes and session persistence.

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

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

Schema coverage is 0% for the single parameter, so the description must compensate, and it does: it gives the accepted formats (https://tricount.com/tXXXX link or tricount key). It could still clarify how to obtain a key or what happens with malformed input.

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

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

States a concrete verb+resource: it validates a tricount link/key and returns its title and members, and frames itself as the entry point ('primer paso'). It does not explicitly contrast with get_tricount_summary, which plausibly overlaps, so sibling differentiation is only implicit.

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

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

Gives clear sequencing guidance ('first step when working with a tricount') and a follow-up workflow: ask the user which member they are and pass that name as acting_as to the write tools. It points at the class of alternatives (write tools) but does not name the other read siblings or state when this tool is unnecessary.

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

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

With no annotations, the description carries the full burden and does well: it discloses the two-phase preview/commit semantics via confirm=true, the default-equal-split fallback, and the sum constraint on exact_amounts. It still omits permission/auth requirements and whether a preview returns a stable identifier for a later commit.

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

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

Front-loaded with the confirm/preview rule, then a scannable bulleted split block, then an Args section. Slightly verbose and mixes prose and PyDoc-style Args, but every section carries non-redundant 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?

For an 11-parameter mutation tool with no annotations and no output schema, the description covers the critical unknowns: confirmation gating, split mutual exclusivity, and the exact_amounts sum invariant. What it lacks is any statement about the preview's return shape and what errors to expect on a mismatched sum.

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

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

Schema coverage is 0%, so the description must compensate, and it does: it defines acting_as, description, amount (positive, tricount currency), paid_by, tricount, category (with a full enum listing plus free-text fallback), expense_date format and default, plus the three split strategies. This is nearly a complete parameter glossary.

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

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

States a specific verb+resource ('Crea un gasto en un tricount') and immediately distinguishes behavior from siblings by disclosing the preview-by-default semantics ('Sin confirm=true solo devuelve una vista previa'). An agent can tell this apart from list_expenses or create_reimbursement without opening any schema.

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

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

Explicitly explains the default no-split behavior ('si no se da ninguna, se reparte en partes iguales entre todos los miembros') and enumerates three mutually exclusive ways to define the split. It does not, however, state when to prefer exact_amounts over ratios, nor does it reference siblings for related flows.

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

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

With no annotations, the description carries the full behavioral burden and does disclose the key trait: without confirm=true it only returns a preview (non-mutating), and acting_as must be confirmed via connect_tricount. It omits permissions, error behavior, and what the preview actually returns.

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

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

The purpose and the preview/save rule are front-loaded in the first two sentences, followed by a readable Args block. The Args list is somewhat verbose but each line earns its place given 0% schema coverage; minor redundancy with field names.

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?

No output schema and no annotations, so the description must cover behavior and params, which it largely does, including the preview/commit distinction and all parameter meanings. It is slightly incomplete on return shape of the preview, error cases, and required permissions for a mutation-capable tool.

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

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

Schema description coverage is 0%, so the description must compensate, and it does so for all eight parameters: acting_as is defined with pronoun mapping ("Yo", "me" refer to this member), from/to member roles are disambiguated (payer vs receiver), amount is constrained positive, date defaults to today, and confirm means real save. This is meaning well beyond the bare schema titles.

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

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

"Registra un reembolso (transferencia) de un miembro a otro" states a specific verb (register) and resource (a reimbursement/transfer between two members), which an agent can distinguish from create_expense. It stops short of explicitly naming or contrasting itself with the sibling expense/transfer tools.

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

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

"Sin confirm=true solo devuelve una vista previa" gives a clear conditional for the dry-run vs commit mode, which is real usage guidance. However, it never says when to prefer this over create_expense or delete_entry, nor any prerequisite beyond the acting_as note.

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

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

With no annotations, the description carries the full burden, and it delivers the critical behavioral trait: the default is a non-destructive dry-run and confirm=true is required to actually delete. It omits irreversibility and permission requirements, but the safety pattern is well communicated.

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

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

Front-loads the destructive behavior and dry-run default in the opening sentences, then lists args compactly. The Args block is slightly verbose but each entry earns its place given the 0% schema coverage.

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?

No output schema and no annotations, but the description explains what the dry-run returns and what confirm does, and covers all parameters. Complete enough for an agent to invoke correctly, with minor gaps around permissions and reversibility.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents all four params. The acting_as explanation (the conversant member confirmed after connect_tricount, with 'yo/me/conmigo' mapping) adds real semantic value; entry_id and tricount are covered only briefly.

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 (elimina) and resource (movimiento: gasto, ingreso o reembolso), identifying the entity precisely. It also links to list_expenses as the source of the id, which helps distinguish the workflow from create_expense/create_reimbursement, though it never explicitly contrasts with those 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?

Clearly describes the two-step usage: without confirm=true it only shows what would be deleted, and confirm=true performs the deletion. It also tells the agent where to obtain entry_id via list_expenses. No explicit when-not-to-use vs alternatives, but the operational context is strong.

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

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

With no annotations, the description carries the full burden. It discloses the returned data shape (balance, debts, per-category expenses), which is useful since there's no output schema, but says nothing about error behavior when a member doesn't match, permissions, or how an omitted tricount is resolved.

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 body is a single front-loaded sentence that earns its length by enumerating the returned fields, followed by compact standard Args. Little waste, though the field enumeration is slightly list-heavy.

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

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

For a 2-parameter read tool with no output schema and no annotations, the description adequately covers both parameters and the returned content. Missing only minor behavioral details (error/not-found handling).

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

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

Schema coverage is 0%, so the description must compensate, and it does: 'member' accepts partial matching and 'tricount' accepts either a link or a key. These format details add real meaning the bare schema (plain strings) does not provide.

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

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

States a specific verb+resource (get member detail) and enumerates exactly what the detail contains — paid, owed, balance, debts in both directions, and per-category expenses. It is clear, though it doesn't explicitly contrast itself with siblings like get_tricount_summary or list_expenses.

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

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

No when-to-use guidance is given — nothing says when to pick this over get_tricount_summary or list_expenses, nor any prerequisite (e.g., that a tricount must be connected first). The use case is only inferable from the content list.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the returned content well (an overview with balances and settlement transfers), but it omits whether this is strictly read-only, whether authentication/connection is required, and any rate-limit or failure behavior.

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

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

The definition is two compact sentences, front-loading the purpose before the argument detail. No filler, though the Args block is minimal for a single parameter.

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 helpfully enumerates the return fields, which is a real strength. But with no annotations and no note about auth/connection requirements or why the sole parameter is optional, it is only adequate for a read tool in a connected service.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain the parameter accepts either a link (https://tricount.com/tXXXX) or a key, which adds real meaning beyond the bare string/null schema. However, it does not clarify that the parameter is optional (required=false, default null), which is a meaningful gap.

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

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

The description states a specific verb+resource ('Resumen de un tricount') and enumerates exactly what the summary contains (title, currency, members, total, balances, suggested transfers). This distinguishes it from sibling tools like list_expenses or get_member_detail, though it never names those siblings explicitly.

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

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

There is no guidance on when to use this tool versus alternatives such as list_expenses or get_member_detail. Usage is only implied by the word 'summary', and no prerequisites or exclusions are 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?

With no annotations, the description carries the full burden. It discloses ordering, inclusivity of date filters, and the meaning of each filter, but omits permissions, rate limits, and 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?

Front-loads the purpose, then uses a compact Args list. Every line earns its place given the parameter count and lack of schema descriptions.

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 list tool with 8 optional parameters and no annotations or output schema, the description covers purpose and parameter meanings well but does not describe the return structure or pagination.

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

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

Schema description coverage is 0%, so the description must compensate. It explains all 8 parameters in detail, including accepted formats (YYYY-MM-DD) and filter semantics, adding substantial meaning beyond the bare schema titles.

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

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

States a specific verb ('Lista') and resource ('movimientos de un tricount') and ordering ('más recientes primero'). It doesn't explicitly name alternatives (e.g., get_tricount_summary) to differentiate, so it's clear but not sibling-differentiating.

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

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

The description implies usage by explaining filters and scope, but offers no explicit when-to-use or when-not-to-use guidance, nor does it point to alternative tools like get_tricount_summary for aggregated views.

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