Vifo

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

Annotations already mark the operation read-only, and the description adds meaningful context: the tool reports tier, quota usage, and the special meaning of a null cap (unlimited). It does not describe exact response fields, but for a simple read-only status tool the added context is adequate.

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 tight sentences with no filler. The core purpose is front-loaded, followed by a concrete usage trigger and the one non-obvious semantic detail (null cap). 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 parameterless read-only tool with no output schema, the description covers what it reports (tier and quota usage), why to call it (pre-flight check), and how to interpret an important value (null cap). It is complete enough for an agent to decide when to call it, though exact response fields are not enumerated.

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?

There are zero parameters, so there is no schema burden. The description goes beyond schema by explaining the meaning of the cap field (null means unlimited), which helps interpret results.

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 clearly identifies the tool as reporting this account's tier and quota usage, with a specific use case (checking before large batch uploads). It distinguishes itself from sibling tools, none of which report account status or quota.

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 states when to check it: before large batch uploads, to warn at the quota wall rather than failing midway, and to answer 'how much room do I have left'. No exclusion or alternative is needed since no sibling tool serves this role.

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

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

Annotations are all false (not read-only, not idempotent, not destructive), and the description does not contradict them. It adds useful behavioral context: the DAY_MARKER rule for separating days and the fact that this is the sole write mechanism. It doesn't disclose retry semantics, but those are implied by idempotentHint=false and the client_id param in the schema. This is a reasonable amount of added context 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?

Two sentences, zero filler. The purpose is front-loaded, the key domain rule (DAY_MARKER) is included, and the reference to learn is concise. Every clause 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 tool with 8 params, a nested payload object, and an enum, the description is concise but sufficient because it defers to learn('block_types') for the complex payload details. It doesn't describe return values, but there's no output schema, so that's not required. It covers the core action and provides a clear path to the necessary knowledge.

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 each parameter described, so the schema carries the heavy lifting. The description adds value by pointing to learn('block_types') for payload shapes, which directly addresses the most complex parameter (payload). It also implicitly reinforces the client_id deduplication purpose by mentioning 'only way to write,' though it doesn't restate the schema details.

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 ('Add'), resource ('block'), and scope ('to a trip's timeline'). It also declares 'This is the only way to write to a timeline,' which distinguishes it from read-only siblings like get_timeline and update_block. This makes the tool's purpose unmistakable.

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 explicitly establishes when to use this tool: 'This is the only way to write to a timeline.' It also directs the agent to learn('block_types') for layout specifics, which is a clear pointer for payload construction. It doesn't mention alternatives for updating existing blocks, but given that it's the only write path, the usage context is clear.

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?

Beyond the annotations, the description adds valuable behavioral context: anyone with the link can read the trip without signing in, coordinates are withheld, and the address is stable across calls. It does not fully explain whether the first call creates the link or what happens when expires_in_days is set on an existing link, but the schema and idempotentHint cover part of that.

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

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

The description is compact and front-loaded: the main action appears in the first sentence, followed by access semantics, stability, and lifecycle guidance. A little could be trimmed, but each sentence contributes useful information for invocation.

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

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

For a simple two-parameter tool with no output schema, the description provides the key facts needed to call it correctly: what the returned link is, who can access it, that it is stable, and how to turn it off or change it. The main gap is not distinguishing this tool from revoke_share_link more explicitly.

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

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

Schema description coverage is 100%, and both parameters (trip_id, expires_in_days) are already described in the input schema. The tool description adds no parameter-level meaning, so the baseline score of 3 applies.

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

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

The description states a specific action and resource: 'Get this trip's public link', then describes the link's key properties (public read access, no sign-in, coordinates withheld, stable address). This clearly differentiates the tool from update_share_link and revoke_share_link, and the idempotent get-or-create behavior is strongly implied by 'calling again returns the same one'.

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

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

The description gives a clear intended use case and explicitly routes lifecycle changes ('Turning it off or changing it') to update_share_link. However, it does not mention revoke_share_link, a sibling that likely also relates to disabling/invalidating the link, so the when-not guidance is slightly incomplete.

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 carry the safety profile (readOnly=false, idempotent=false, destructive=false). The description adds context that a trip acts as a notebook holding photos and timeline blocks, though it does not disclose behavioral details such as default date/timezone handling or duplicate-trip 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?

Two short sentences with no filler. The action is front-loaded and the conceptual model is conveyed in one clause, so every phrase earns its place.

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

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

For a simple create-with-title tool with full schema coverage and annotation context, the description plus schema is sufficient for correct invocation. It provides useful anchoring of what a trip represents, though a short pointer to update_trip for later modifications would round it out.

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 title, end_date, start_date, and default_tz_offset all already described. The tool description adds no parameter-level meaning beyond the schema, so the baseline of 3 applies.

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

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

The description uses 'Start a trip' as the verb+resource and adds a conceptual model with 'one journey, one notebook,' making it clear this is the trip-creation entry point. It does not explicitly differentiate from update_trip, but 'start' versus update is reasonably distinct.

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

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

No guidance is provided about when to use this tool versus alternatives like update_trip or set_trip_*. An agent must infer from the name alone that this is the creation operation.

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 and openWorldHint=false, so the safety profile is covered. The description adds real behavioral value beyond them: it discloses that inactive content is returned under a flag but must not be used for generation, a caveat an agent could not infer from the 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?

Two sentences, front-loaded with the core action before the flag guidance, and nothing is padding. Minor grammar slip ('a experience') and no wasted clauses.

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 does state what comes back (evidence and versions) and flags the inactive-content caveat. It is nearly sufficient for a two-parameter read tool; only the relationship to list_experiences is left implicit.

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

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

Schema coverage is only 50% – include_inactive has no schema description – and the description compensates by explaining exactly what that flag does and when to set it. The experience_id constraint is carried by the schema, so this is a net-positive contribution rather than a repeat.

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 ('Read') and resource ('experience') and names what the payload contains ('evidence and versions'), which distinguishes it from list_experiences and the memory/timeline readers. However it never explicitly contrasts itself with the nearest sibling list_experiences, so it stops short of full sibling differentiation.

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

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

Gives a concrete usage condition: set include_inactive=true when a review bundle is wanted, plus the constraint that inactive content must not be used for generation. It does not state when to prefer this over list_experiences or review_experience, so it is clear context without 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?

Annotations already establish readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds genuinely new context: the return contents (evidence and versions) and the constraint that inactive content is not valid for generation, which is real behavioral guidance.

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 tight sentences with no waste; the core action is front-loaded and the parameter guidance follows immediately.

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 2-param read tool with no output schema, the description covers the action, the key param, and the inactive-content caveat. It runs slightly short on explicit sibling differentiation but nothing needed to call it correctly 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 coverage is only 50%: memory_id has only constraint text and include_inactive has no description at all. The description compensates by explaining what include_inactive does (review bundle) and its downstream generation constraint, filling the gap the schema leaves.

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 (read) and resource (memory) and adds that it returns evidence and versions, which distinguishes it from list_memories and create/update_memory. It doesn't explicitly contrast itself with the closest siblings like get_experience or review_memory.

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 conditional guidance: set include_inactive=true for a review bundle, and warns inactive content must not be used for generation. It doesn't state when to prefer this tool over siblings such as review_memory, but the parameter-level guidance is actionable.

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?

Beyond the readOnlyHint annotation, the description discloses the return content (full block payloads and media summaries) and the editorial workflow implication. It adds useful behavioral context 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?

Two sentences, front-loaded with the purpose and return contents, followed by a directly actionable caveat. Every clause contributes information and there is no filler.

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

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

For a read-only tool with a readOnlyHint and fully documented parameters, the description covers the key behavioral details and the read-before-edit workflow. It does not explicitly describe pagination, but limit and cursor are already documented in the schema.

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

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

The input schema already documents all four parameters with full descriptions and constraints, so the description need not repeat them. The description adds no parameter-level detail beyond what the schema provides, earning the baseline score.

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 ('read'), identifies the resource ('a trip's timeline'), and details what is returned ('every block with its full payload, plus a summary of the media it references'). It also distinguishes itself from update_block by explaining the replacement semantics.

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?

It explicitly tells the agent to read from this tool before editing because update_block replaces a payload whole, which is clear usage guidance. It does not mention other siblings like list_media or get_trip_state, so it is not exhaustive.

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 have readOnlyHint=true and openWorldHint=false, so the tool is read-only. The description adds the media_quota cap semantics (cap null means unlimited), which is beyond annotations and gives important behavioral context for a trip capacity check. It doesn't contradict annotations. It also explains the media_quota field directly in the description, which is beyond the schema (schema only says 'must not be empty' for trip_id). This adds value for the agent, but it could be more explicit about what happens when a trip is not found (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 two sentences, which is appropriately concise. It front-loads the purpose ('Where a trip stands') and then gives usage context. The media_quota detail is relevant but perhaps could be trimmed, but it's not excessive. Every sentence serves a purpose: the first describes the tool's output, the second gives usage guidance. It's well-structured.

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 one parameter (trip_id) and no output schema, the description covers the main relevant aspects: what the tool reports (progress, cover, media quota). The only missing piece is error behavior (e.g., invalid trip_id), but since the schema enforces non-empty, and the read-only nature is in annotations, this is sufficient for the agent to call it correctly. The description is complete for a simple check tool.

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

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

Schema description coverage is 100%, so the schema documents trip_id. The description does not elaborate on trip_id format, but it's a simple ID with a must-not-be-empty constraint. The description adds value by clarifying the media_quota field (a parameter-like construct) even though it's not in the input schema. Since the coverage is high, a baseline 3 applies, but the description adds context about the quota semantics, which nudges it to a 4.

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 clearly states it checks trip progress: how much is written, what's missing, whether cover exists. It also mentions the media_quota field, which is a specific aspect. This is a specific verb+resource (check trip state) and the main purpose is unambiguous. The title is an adequate shorthand already, but the description adds specific details like cover and media_quota.

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 says 'Call this when picking a trip back up' and mentions to check media_quota before a big batch. This gives clear when-to-use guidance. It also differentiates from the start, though it doesn't explicitly say 'don't use for X', but the context of picking up a trip is specific enough. Words like 'where a trip stands' and 'before a big batch' give actionable scenarios.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds value by explaining that remarks are returned verbatim and that the default is pending (unprocessed) remarks, which is useful context about the output content. It also clarifies the source of pending remarks (upload page or companion via upload link). No contradiction 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 two sentences with no filler. It front-loads the core action ('Read what the traveller said, verbatim'), then provides context on the default and the recommended workflow. Every clause serves a purpose, making it highly efficient and well-structured.

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 list tool with no output schema, the description explains the content (verbatim remarks), the default filter (pending), and the intended use case (organising before filing). It doesn't explicitly describe the output structure or pagination, but the schema covers cursor and limit. The description is sufficient for an agent to understand the tool's role and how to invoke it correctly, though a bit more on the output shape would be ideal.

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% – all four parameters have descriptive comments. The description itself does not elaborate on parameter details, but it does reinforce the default state behavior ('Default shows pending remarks') which aligns with the state parameter default. Since the schema already documents the parameters, the description adds only marginal semantic value beyond the schema, warranting the baseline score of 3.

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

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

The description clearly states the tool's function: reading the traveller's remarks verbatim. It specifies the default behavior (pending remarks) and distinguishes it from related tools by mentioning the follow-up action of filing remarks, making it easy to tell apart from siblings like file_remark.

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

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

The description provides a clear workflow: 'Start here when organising' and then 'file_remark each one', which signals when to use this tool (the reading step) versus filing. It also implies that the state parameter controls whether you see pending or filed remarks, though it doesn't explicitly state when to use other tools. The guidance is strong but could be more explicit about alternatives.

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 include readOnlyHint=true, so the read-only nature is known, but the description adds that the server queries and caches results ('you never call a geocoder yourself') and that it returns administrative levels while the landmark name is left for the user to write into location_name. This is useful behavioral context beyond annotations, though it doesn't detail response format.

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?

Three sentences, each purposeful: purpose, usage context/behavior, and output handling. The most important information (what it does) is front-loaded. No redundancy or filler.

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

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

For a simple two-parameter read-only tool with no output schema, the description covers purpose, when to use, server-side behavior, and what the tool returns (administrative levels). It also clarifies that the landmark name must be written by the caller. Minor gap: exact structure of administrative levels is not specified, but this is acceptable given simplicity and annotations.

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 already documents lat and lng with ranges (100% coverage). The description does not add parameter-specific meaning beyond what the schema provides; it mentions 'lat/lng' in context but not new semantics. Baseline 3 is appropriate since schema handles parameter documentation.

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

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

The description states a specific action ('Turn coordinates into a place name') with a clear resource (coordinates) and output (place name). It also distinguishes itself from sibling tools by noting that media filing does this automatically, making it the manual alternative for old photos. This is a precise, non-tautological statement.

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 says when to use: 'reach for this tool when filling in old photos' and clarifies that automatic filing already performs this task, implying a fallback scenario. It gives clear context and implicitly tells the agent not to use it when filing media automatically.

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=false, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context: the link stops opening immediately, the address is kept, and it can be reopened later. This clarifies the reversible nature beyond what annotations convey, though it doesn't explicitly mention idempotency (already covered by 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?

Two sentences with zero waste. The primary action is front-loaded ('Stop sharing.'), followed by a concise behavioral explanation and a clear alternative. Every word earns its place.

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

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

For a simple one-parameter mutation tool with annotations covering safety and idempotency, the description covers the effect, the retention behavior, and the alternative. Nothing critical for calling the tool correctly 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 only parameter, trip_id, has a minimal schema description ('must not be empty') and the tool description does not add any further semantics. Since schema coverage is 100%, the baseline of 3 applies; the parameter is self-explanatory from its name and context.

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

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

The description clearly states the action (stop sharing) and the resource (share link). It distinguishes from the rotate alternative, so an agent can immediately understand what this tool does versus the sibling tool for rotating links.

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 explicitly gives the condition for using an alternative: 'To make the old address permanently useless instead, rotate it.' This tells the agent when NOT to use this tool and points to the correct alternative, leaving no ambiguity.

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 indicate readOnlyHint=false, destructiveHint=false, and idempotentHint=true, so the safety profile is covered. The description adds valuable behavioral context: it should be written in the traveller's language, grounded in actual trip events, and a forced ending is worse than none. This goes beyond annotations and helps the agent produce appropriate content.

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 concise and front-loaded with the core purpose. Each sentence adds value: the primary action, the contrast with summary, the timing requirement, and the quality guidance. No wasted words, and it flows logically.

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 three parameters are fully documented in the schema and the description explains the tool's role and usage conditions, it is largely complete. It doesn't explicitly mention the clear parameter for removing a closing, but the schema covers that. The description gives enough conceptual context for an agent to decide when and how to invoke it.

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

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

Schema description coverage is 100%, so all parameters (text, clear, trip_id) are well-documented. The description does not add any parameter-specific semantics beyond the schema, but it does hint at the 'clear' concept via 'leave it out' (though it doesn't explicitly link to the parameter). Baseline of 3 is appropriate given full schema coverage.

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

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

The description clearly states the tool writes the closing passage for a trip's page, using a specific verb ('write') and resource ('closing passage'). It explicitly differentiates this from a summary, noting the summary opens the page while the closing comes after the whole journey is seen, which distinguishes it from sibling tools like set_trip_head or set_trip_theme.

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

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

The description provides clear context on when to use it: write it once the timeline is finished, and skip it if nothing comes to mind to avoid a forced ending. It also explains the distinction from the summary, which guides when not to use it for that purpose. However, it doesn't name other sibling tools like set_trip_head or set_trip_theme, but the summary contrast is a strong enough alternative.

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

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

Beyond the annotations, the description explains key behaviors: summary is the only original writing, refs must point to existing blocks, and calls are merge-like after the first. This is valuable context that annotations alone do not provide, and it is consistent with readOnlyHint=false and idempotentHint=true.

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, opening with purpose and then providing constraints, call pattern, and guidance. Every sentence earns its place and there is no filler or redundant restating of the title.

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?

Covers purpose, ref semantics, partial-update behavior, reading current state, and external guidance. Minor ambiguity remains about which four fields are required on the first call, and the replace behavior is only in the schema, but the overall definition is complete enough for such a complex tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds cross-parameter meaning by clarifying that ref fields reference existing blocks, that summary is original, and that partial updates are allowed after the first call. It does not repeat each parameter's schema text, which 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?

Description states a specific verb and resource: sets a trip's cover and highlights, and characterizes it as the curated layer above the timeline. This clearly separates it from siblings like set_trip_ending, set_trip_theme, and update_trip without needing to open 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?

Gives explicit workflow guidance: first call needs all four fields, later calls may send only changes, and the current head should be read via get_trip_state. It also points to learn('head') for further guidance. It does not explicitly state when not to use this tool versus alternatives, but the usage 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?

Beyond the annotations, the description discloses that colours are contrast-checked and rejected if unreadable, and that styling is constrained to a fixed set of tokens. This adds meaningful runtime behavior; it does not contradict the idempotent or non-destructive hints.

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?

Four short sentences, each earning its place: the action, the token scope, the validation behavior, and the way to get the full list. No filler or repetition.

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 moderately complex tool with nested token objectsys, the description covers the key behavioral and partial-update aspects and directs the agent to learn('theme') for the authoritative token list. The schema covers the remaining parameter details, and no output schema is required for a restyle 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 description adds useful partial-update semantics ('Send only the tokens you want to change') and categorizes tokens as colours, heading face, and photo treatment. However, the schema already documents most parameters, and the description does not explain the replace flag or individual token constraints.

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 ('Restyle') and resource ('one trip's page') and scopes the work to a fixed set of tokens. This clearly separates it from sibling tools like set_trip_head or set_trip_ending, which target different aspects of a trip.

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 an explicit usage rule ('Send only the tokens you want to change') and points to learn('theme') for the full token list. It does not explicitly contrast with sibling tools, but the purpose statement and sibling names make the appropriate context clear.

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

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

The description discloses key behaviors beyond annotations: link expiry (24 hours, 1–72), no sign-in needed, live-view behavior for trip_id and unfiled, item numbering, and idempotent regeneration with the same link and updated note. This complements the idempotentHint annotation and clarifies the read-only nature of the resulting page.

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 long but dense and front-loaded with the core purpose. It uses examples and clear scope rules; some sentences could be tightened, but each contributes either usage guidance, behavioral context, or a distinction from alternatives.

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?

Despite having no output schema, the description conveys what the agent gets back: a short-lived link, the same link on repeat calls, item numbering for reference, and the note display. It also addresses authentication, expiry, and live-view behavior, making it sufficiently complete for correct invocation.

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

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

The schema already covers all parameters at 100%, but the description adds selection semantics: exactly one of media_ids, trip_id, or unfiled:true, ordering for media_ids, and why unfiled:true is preferable to passing a pool of ids. This goes beyond the schema's per-parameter descriptions without duplicating them.

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

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

The description states a specific verb and resource: 'Show the traveller a set of their own photos and videos: a short-lived link, no sign-in needed.' It clearly distinguishes itself from share links and other siblings by emphasizing this is for the owner, read-only, and temporary.

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?

It gives explicit when-to-use guidance ('Use it when you want them to look before you decide') with concrete examples, and provides exclusions: 'Not a share link' and 'use unfiled rather than listing the unclaimed pool and passing its ids back.' It also names related tools like search and list_media, making the choice of scope clear.

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

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

The description discloses that the transcript is 'stored on the media and returned', adding a side-effect beyond the annotations. It also warns the output is 'raw speech-to-text' and should be treated as source material, which is useful for how the agent handles the result.

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?

Three sentences, each carrying a distinct function: purpose, usage condition, and output/behavior. No redundant phrasing, and the core purpose is front-loaded.

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

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

For a two-parameter tool with annotations for idempotence and destructiveness, the description covers the key behavioral facts: when to invoke, what gets stored, and what the returned data is like. The lack of an output schema is mitigated by the explicit statement that the transcript is returned.

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 fully documents both parameters (media_id, redo) with descriptions, so the description does not need to repeat them. The description adds no parameter-level detail, 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+resource ('Transcribe what is said in a video') and immediately clarifies it is a written-record operation, not just video handling. This differentiates it from sibling media tools like view_media or update_media, so an agent can identify when this tool is relevant.

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 conditions use: 'ask for it only when the traveller wants what was said kept' and says it is 'Not done automatically'. It also contrasts transcription with 'keeping the video', giving a clear when-not-to-use signal without needing a sibling name.

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

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

Annotations already mark the operation as non-read-only, non-destructive, and idempotent. The description adds valuable behavior beyond that: the payload replaces the old one whole, and switching layout requires type plus a matching payload. This warns the agent about an important side effect 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?

Two tight sentences with no filler. The most important behavioral fact, full payload replacement, is placed early and immediately followed by the required precondition.

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 complex 9-parameter mutation with a nested payload and no output schema, the description plus schema covers the core flow: fetching current state first, replacing the payload, switching layouts, and version guarding. It is not fully complete—return behavior and sort_key semantics are not addressed—but it is strong enough for correct invocation in most cases.

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

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

Schema description coverage is only 56%, so the description needs to compensate. It does clarify payload semantics and the type/payload relationship, and 'badge or time' maps to some fields. However, it leaves sort_key, tz_offset, and occurred_at_utc semantics largely implicit, so the low coverage is not fully compensated.

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

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

The description opens with a specific verb and resource, 'Edit one timeline block', and enumerates the editable aspects: content, badge, time, or layout. This clearly separates it from siblings like add_block and get_timeline.

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?

It gives an explicit precondition: 'read it with get_timeline first', which is essential before replacing a payload. It does not explicitly name alternatives or when-not-to-use cases, but the edit-vs-add distinction is strongly implied by the wording.

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

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

The description contradicts the annotations. Annotations declare idempotentHint: true, but the description says 'rotate - issue a new address... this cannot be undone' and implies each call generates a new address, which is non-idempotent. This inconsistency is significant because it misleads the agent about the tool's side effects. Thus, score is 1 and annotation_contradiction is true.

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, front-loaded with the main purpose, and organized by the three operations. Each sentence contributes meaning, though the final sentence ('To simply stop sharing...') partly repeats earlier guidance and could be trimmed. Overall, it is efficient and readable, earning a 4.

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

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

For a mutation tool with 5 parameters and no output schema, the description covers the main behaviors and the confirm_rotate requirement. It explains the three distinct actions and their side effects. However, it does not specify how parameters interact when combined (e.g., setting both public and rotate), nor what the tool returns. Given the schema's completeness and the description's coverage of key semantics, it is adequately complete, though not exhaustive.

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

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

Schema description coverage is 100%, so all parameters already have detailed descriptions. The tool description adds some narrative context (e.g., 'Every copy already sent stops working' for rotate), but the schema already captures the core semantics (e.g., rotate description says 'Requires confirm_rotate'). The description adds marginal value beyond the schema, so it stays at the baseline of 3.

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

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

The description clearly states the tool 'Change a share link' and enumerates three specific operations (public, rotate, expires_in_days). It is specific about the verb and resource. However, it does not explicitly differentiate from sibling tools like create_share_link or revoke_share_link, so the agent might not know when to choose this over those. That prevents 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?

The description provides clear internal guidance on when to use public vs rotate, such as 'To simply stop sharing, set public to false' and 'Rotating punishes everyone you already sent it to.' It also warns about the irreversible nature of rotate. However, it does not explicitly state when to use this tool instead of alternatives like create_share_link or revoke_share_link, leaving some ambiguity for tool 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?

Annotations already provide readOnlyHint=false, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds context about what can be changed but doesn't disclose additional behaviors like validation between start/end dates or partial-update semantics. Since annotations are strong, the description's marginal value is sufficient for a 3.

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 redundancy. It names the three key actions (rename, correct dates, correct timezone) efficiently. Slightly more specific language about partial updates would push it higher, but it's already concise and well-structured.

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

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

The tool has 5 parameters but only one required, and no output schema. The description explains the purpose but doesn't cover edge cases like what happens if only end_date is provided, validation between start/end dates, or the meaning of default_tz_offset (though the schema defines it). For a mutation tool with multiple optional fields, this is a moderate gap.

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

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

The schema provides 100% coverage with descriptions for all five parameters. The description groups them (title, dates, timezone) which adds minor organization but no new semantic meaning beyond the schema. It doesn't hint at relationships between fields (e.g., date ordering). Baseline 3 is appropriate when the schema carries the bulk of the load.

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 ('rename/correct') and resource ('trip'), and specifies the exact attributes (title, dates, default timezone). It distinguishes from sibling tools like create_trip, update_block, and set_trip_ending, though it doesn't explicitly name a sibling as an alternative.

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

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

The description implies when to use this tool (to rename or correct a trip's dates/timezone) but doesn't explicitly contrast it with siblings like set_trip_ending or set_trip_head, which modify specific fields. An agent would infer usage from context but without explicit exclusions, it's adequate but not exceptional.

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

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

Annotations are minimal (readOnlyHint=false, idempotentHint=false, openWorldHint=true), providing little behavioral info. The description adds crucial context: the link is tied to this account only, the response names the account (masked email) and instructs to tell the traveller. It is non-idempotent but doesn't detail side effects (e.g., generating a unique link), but given the context, this is sufficient.

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: 3 sentences, front-loading the core action and key constraint (no sign-in needed), then usage conditions and plan details. Every sentence adds value: purpose, behavior, when-to-use, and parameters. 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?

Given the tool's simplicity (1 parameter, no output schema), the description covers the essential elements: what it does, when to use it, the plan options with pricing, and the behavioral nuance (account-tied link). The only minor gap is not describing the response format fully, but it mentions the masked email. It's complete enough for an agent to call 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 schema has only one parameter (plan) with an enum, so it's fully specified in the schema. The description adds pricing details ($6.9/$39.9) which help the agent communicate, but the parameter semantics are already clear from the enum. Since schema coverage is 0% but the parameter is self-explanatory, the baseline is 3.

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

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

The description clearly states the verb (generate) and resource (Paddle checkout link for upgrading THIS account to Plus), and adds a key differentiator: no sign-in needed. It distinguishes itself from sibling tools like create_share_link and create_upload_link by specifying the upgrade context.

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

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

The description provides explicit usage conditions: 'Only call when the user explicitly asks to upgrade or after a quota error told you to offer it.' This gives clear when-to-use guidance and implicitly excludes other scenarios. It also specifies the plan parameter options (monthly/yearly) with pricing, helping the agent decide.

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

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

The description discloses critical behavioral traits beyond the readOnlyHint annotation: images enter the model's context, the server runs no image analysis itself, videos return as cover frames, and metadata (time and place) is attached. This tells the agent exactly what to expect from the call and how to interpret results.

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

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

Three tight, front-loaded sentences cover purpose, usage, and behavior with zero redundancy. Every sentence earns its place, and the most important information (what the tool does) leads off.

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 sufficiently explains what the agent receives (images, metadata, cover frames) and how to request them (media_ids or trip_id). It also states the no-analysis limitation, which is critical for the agent to know it must interpret images itself. Nothing essential 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 baseline is 3. The description adds minor value by explaining the relationship between media_ids and trip_id ('Name specific media_ids, or give a trip_id to pull a batch') and the concept of batching, but does not add significant meaning beyond what the schema already defines.

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 'Look at the pictures themselves' – a specific verb and resource – and clarifies that it returns actual media content with time and place attached. This distinguishes it from listing tools like list_media (metadata only) and conveys its core function clearly.

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?

It gives clear usage instructions: name specific media_ids or provide trip_id for a batch, and notes the 'filter' option with trip_id. While it implies this is for viewing actual content ('you can only describe what you have seen'), it does not explicitly name alternatives or state when not to use this tool, leaving some inference to the agent.

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