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

No annotations are provided, so the description carries the full behavioral burden. It discloses the side effect of opening a terminal window (implying a Kitty dependency), which is useful, but says nothing about whether the call blocks, whether it requires Kitty to be installed, or what the response contains. That is thin for a UI-launching tool with zero annotation coverage.

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

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

The core action is front-loaded in a single sentence, followed by a compact Args block. It is efficient, though the 'Args:' header and repetition of the parameter name add mild overhead.

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

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

An output schema exists, so return values need not be described. Purpose and the single parameter are covered, but the description omits usage context and the blocking/async behavior of the call, leaving the picture only partially complete for a tool that spawns an external terminal UI.

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 largely does: it explains that filter_template selects which template to display at startup, gives concrete examples ("lyra_task", "movie", "download"), and states the default behavior when omitted. This adds real meaning beyond the bare string type in the schema.

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

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

It states a specific verb and resource: opens the tracking dashboard in a Kitty terminal. This is clearly distinguishable from the CRUD-oriented siblings (tracking_create, tracking_list, etc.), which manipulate tracking data rather than launch a UI. It stops short of explicitly naming a sibling to contrast against, so 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.

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 launcher versus the many tracking_* data tools, nor any prerequisites or exclusions. Usage is only implied by the name and by 'dashboard'.

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 discloses one behavioral effect (progress forced to 100%) but says nothing about permissions required, whether the action is reversible, what happens to already-completed sessions, or whether the optional message is persisted.

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

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

A single front-loaded sentence with no filler; the state change is stated immediately. Brevity is appropriate, though it comes at the cost of detail elsewhere.

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

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

An output schema exists so return values need not be explained, but for a mutation tool with zero annotations and zero parameter coverage the description should at minimum explain the message argument and the effect on already-closed sessions. It leaves an agent with real gaps before invoking.

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 nothing documents session_id or message. The description only obliquely implies a session identifier and never mentions the message parameter or what it is used for, leaving the agent unable to use it meaningfully.

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 ("Marque") and resource ("session") plus the resulting state ("terminee", "progression a 100%"), so the agent knows this is a terminal-state transition. It does not distinguish itself from close siblings like tracking_stop or tracking_kill, which also end sessions, leaving the agent to guess which one to pick.

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 versus tracking_stop, tracking_kill, or tracking_update, all of which likely touch session state. No prerequisites or conditions (e.g., only for in-progress sessions) are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses some behavior (template-specific extra fields, pid consumed by tracking_stop/tracking_kill), but says nothing about what creation returns, whether failures occur on duplicate names, or permission/auth requirements for a mutation-style tool.

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

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

Front-loaded with a one-line purpose, then a structured Args block where each line earns its place by documenting a parameter the schema leaves bare. Slightly verbose formatting for what is essentially param documentation, but no wasted 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?

An output schema exists, so return values need no explanation, and parameters are well covered. What is missing for a 7-parameter creation tool with no annotations is usage context and creation-side behavior (idempotency, error cases), leaving the definition merely adequate.

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

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

With 0% schema description coverage, the description nearly compensates fully: it explains all seven parameters with concrete examples (total=15300 MB, unit, items as a nested step list with its own fields, extra as template-specific keys). It falls short of 5 only because 'extra' is described vaguely ('champs specifiques au template') rather than mapping keys to specific templates.

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 and resource: 'Cree une nouvelle session de tracking' (creates a new tracking session), which is unambiguous on its own. However, it never names the sibling it differs from (e.g., tracking_update vs create), so the agent must infer the create/update boundary from the name alone.

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

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

Usage is only implied (create a session when starting tracked work). It cross-references siblings tracking_templates() for valid template values and tracking_stop/tracking_kill for the pid, which is useful, but there is no explicit statement of when to prefer this tool over alternatives or what prerequisites exist.

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

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

With no annotations provided, the description must carry the behavioral burden. It adds useful context by clarifying that the operation does not affect the process, which distinguishes destructive intent. However, it doesn't state whether the deletion is permanent, what permissions are required, or what happens to related data.

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

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

The description is a single, efficient sentence that front-loads the action and includes a clarification. It's concise and does not waste words, though it could be slightly more informative without becoming verbose.

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

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

Given a mutation tool with no annotations, one parameter, and an output schema (which the description needn't explain), the description is minimally adequate. It covers the key behavioral trait of not touching the process, but lacks details on irreversibility, permissions, or side effects that would make it more complete.

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

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

Schema description coverage is 0%, with one required parameter (session_id). The description doesn't elaborate on the parameter at all, but with only one obvious parameter, the baseline of 3 seems appropriate. An agent can infer session_id is the identifier of the session to delete.

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

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

The description states a verb of sorts ("Supprime" implies delete) and the resource (une session / a tracking session). It distinguishes itself from tracking_kill by noting it doesn't touch the process, which helps against that sibling. However, it's terse and doesn't explicitly name what a "session" is in this context, leaving some 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 explicit guidance on when to use this tool versus alternatives like tracking_stop, tracking_kill, or tracking_complete. The parenthetical hint suggests it's for deleting a session record without terminating the underlying process, but this is implied rather than stated as a use case.

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 falls short. It does not disclose that this is a mutating/terminal state change, whether it is idempotent, what happens to an already-errored or completed session, or any permission requirements.

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

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

The single sentence is front-loaded and free of padding, but its brevity reflects under-specification rather than disciplined conciseness. It is appropriately sized only because it conveys almost nothing.

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

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

Although an output schema exists (so return values need not be explained), this is a two-parameter mutation tool with zero annotation coverage and no parameter documentation. The description is far too thin for an agent to invoke it confidently over its many siblings.

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 both required parameters (session_id and message) are undocumented in both schema and description. The word 'session' loosely implies session_id, but the description adds no meaning for 'message' or formatting expectations, leaving the agent to guess.

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 gives a clear verb and resource ('Marque une session en erreur' = marks a session as errored), so the core action is inferable. However, it offers no differentiation from siblings like tracking_update, tracking_stop, or tracking_kill, which also mutate session state, so an agent cannot tell them apart from the text alone.

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

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

There is no indication of when to call this tool, when not to, or which sibling to prefer for related operations such as stopping or completing a session. The agent receives no routing guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It mentions that metrics are included in a formatted state, but says nothing about permission requirements, behavior when the session_id does not exist, or whether reads are side-effect free.

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

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

A single short sentence, front-loaded with the verb and the returned resource. No wasted words, though it is arguably too terse given the missing guidance.

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

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

An output schema exists, so return values need not be explained, but for a heavily-sibling-ed tool with a 0%-documented parameter and no annotations, the definition is under-specified. It omits when-to-use, parameter meaning, and error behavior.

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

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

Schema description coverage is 0% and the single parameter session_id is undocumented in both schema and description. The description refers to 'une session' but never explains what session_id is (format, source, or how to obtain it), so it fails to compensate for the coverage gap.

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

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

The description states a clear verb and resource ('Retourne l'etat formate complet d'une session') and adds scope detail ('avec metriques'), so it is more than a restatement of the name. However, it offers no differentiation from the many siblings (tracking_list, tracking_templates, tracking_get vs tracking_update), leaving the agent to infer which read tool to pick.

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 rather than tracking_list or tracking_templates, and no prerequisites or exclusions are stated. The only implied usage is that it requires a session_id, which comes from the schema, not the description.

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

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

With no annotations, the description carries the full burden and does well: it discloses SIGKILL delivery, the conditional on the session having a `pid`, and that the session is then removed from the dashboard. It stops short of stating irreversibility, permissions, or the failure mode when no pid 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?

Two compact, front-loaded sentences with the essential action first and the parameter note after. Very little waste, though the Args block is redundant given a single self-evident param.

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

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

An output schema exists, so return values need not be explained, and the destructive behavior is disclosed. Still, with no annotations and no sibling differentiation, an agent lacks enough to confidently choose kill over stop/delete.

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?

One parameter at 0% schema coverage, and the description only restates it as 'ID de la session', adding essentially no meaning beyond the parameter name. It does not specify format or source of the ID.

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

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

Specific verb+resource: a forced stop that sends SIGKILL to the process and removes the session from the dashboard. It conveys the destructive nature clearly. However, it does not differentiate itself from the close siblings tracking_stop and tracking_delete, which an agent must distinguish.

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 and no mention of alternatives, despite tracking_stop and tracking_delete being obvious overlapping siblings. The agent is left to infer that this is the forceful variant.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state that this is a read-only operation, whether results are paginated, permission requirements, or what happens with multiple active sessions. Only filter example values are disclosed.

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

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

The description is front-loaded and compact: one sentence states the purpose, then a short Args section documents both optional parameters. Every line earns its place 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 two-filter list tool with an output schema, the description covers purpose and parameter meanings. It still omits usage routing against sibling tools and behavioral details like pagination or read-only guarantees, so it is adequate but not fully complete.

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

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

Schema description coverage is 0%, and the description compensates well by explaining both parameters: 'template' and 'status', including example values for each. It falls short of perfect because it does not clarify whether values are exhaustive, case-sensitive, or how the filters combine.

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 and resource: 'Liste les sessions avec filtres optionnels.' This distinguishes it from sibling mutation tools like tracking_create and tracking_update. However, it does not explicitly differentiate it from tracking_get, which also retrieves tracking data.

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

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

The description says filters are optional but gives no guidance on when to use this tool versus alternatives such as tracking_get or tracking_templates. It also does not state any prerequisite context or exclusions.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the call does not alter tracking progression (a non-state-changing append), but omits any auth/permission requirements or rate-limit context.

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

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

A single front-loaded sentence with zero filler; the core action and its non-mutating constraint come first and nothing is wasted.

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

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

An output schema exists, so return values needn't be explained, and the tool is simple. However, the missing differentiation from tracking_error and the undocumented session_id leave gaps for an agent choosing among 12 siblings.

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. It supplies the level enum values (info | warn | error) that the schema lacks and clarifies 'message' as a log entry, but says nothing about session_id's role.

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 and resource ('Ajoute une entree de log') and names the allowed levels, so the agent knows it appends a log entry. It hints at scope with 'sans modifier la progression', but never names a sibling, leaving the overlap with tracking_error unresolved.

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, or alternative is given. The phrase 'sans modifier la progression' describes a behavioral property rather than telling the agent when to pick this over tracking_error or tracking_update.

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 a decent job: it discloses the mechanism (SIGTERM), the conditional trigger (only if the session has a `pid`), and the resulting state change ('paused', still visible in the dashboard). It omits permissions/auth requirements and whether the session can later be resumed, keeping it short of a 5.

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 in the first sentence and uses a compact Args block for the two parameters. No filler sentences, though the parameter list is somewhat redundant with the 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?

An output schema exists, so return values need not be explained, and the description covers the core mutation behavior. For a mutation tool with zero annotation coverage, the missing sibling differentiation (tracking_kill) and lack of any permission/reversibility note leave a meaningful gap.

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

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

Schema description coverage is 0%, so the description must compensate and it partially does, documenting both parameters ('ID de la session' and 'Raison de l'arret (optionnel)'). The added meaning is thin — it largely restates parameter names without format, constraints, or effect on behavior.

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 and resource with concrete mechanics: sends SIGTERM to the process and marks the session 'paused'. However, it never distinguishes itself from the sibling tracking_kill, so an agent cannot tell the two stop-like tools apart without further inference.

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

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

The label 'Arret propre' (clean stop) implicitly hints at a contrast with a forced stop, but the description gives no explicit when-to-use guidance and never names tracking_kill or tracking_complete as alternatives. The choice between these siblings 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?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the data sources (builtins plus ~/.config/tracking/templates.json), which is real context beyond the schema, but it never states that the operation is read-only, whether any permissions or files are required, or how missing config files are handled.

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

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

A single short sentence that front-loads the action and then the scope. Nothing is padded and nothing is wasted.

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

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

An output schema exists, so return values need not be described, and with no parameters the definition has little else to cover. The only real shortfall is the absence of usage context relative to its eleven sibling tools.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There are no argument semantics that the description could or should 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?

States a specific verb and resource ('Liste les templates disponibles') and even names the two sources it reads from, so the agent knows exactly what this returns. It does not explicitly differentiate itself from siblings such as tracking_list, though 'templates' is a distinct resource not covered by any other 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 description states what the tool does but gives no when-to-use guidance, no prerequisites, and no reference to alternatives. An agent must infer that this is a discovery step before tracking_create, since nothing in the text says so.

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. It does disclose a genuine behavioral trait — that speed, ETA, and elapsed time are derived automatically from 'processed' — which helps an agent avoid setting those manually. It omits whether the session must pre-exist, side effects on log/items, and auth requirements.

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

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

Purpose is front-loaded in the first sentence, then a compact Args list. Sized appropriately for six parameters 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?

An output schema exists, so return values need not be explained, and the parameter tour is fairly complete. The main gap is the absence of any routing context among the ten-plus tracking siblings, which an agent selecting among them needs.

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 largely does: it documents all six parameters, including the nested item_updates shape ({name?, id?, status?, processed?, note?}), the 'extra' passthrough for speed/eta/phase, and the level enum values. This is meaningful added meaning beyond the bare 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?

States a specific verb ('Met a jour') and resource ('la progression d'une session'), so an agent knows exactly what it does. However, it does not differentiate itself from any of the many siblings (tracking_log, tracking_complete, tracking_error, tracking_stop), which an agent must choose between.

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 versus tracking_log, tracking_complete, or tracking_error. The description only implies usage through the field list, leaving the agent to infer selection criteria.

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