TimeTree MCP Server

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 hints at a 'verified' endpoint (suggesting auth) and the schema notes the silent/push-notification default, but the description itself never states permissions required, mutation side effects, or what happens on invalid event_uuid.

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?

One tightly front-loaded sentence with no padding. The only slack is the endpoint reference, which does not help an agent decide or invoke.

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

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

This is a mutation tool with no annotations and no output schema; the description does not cover permissions, whether the comment can be edited later (via update_event_comment), or failure modes. For a write operation it is too thin.

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 four parameters (including the silent default and the calendar_id sourcing note) are already documented in the schema. The description adds no parameter meaning beyond that, so the baseline 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?

States a specific verb (add) and resource (comment on a TimeTree event), which distinguishes it from the sibling read/update/delete comment tools by name alone. The trailing 'using the verified event activity endpoint' is implementation detail rather than purpose, so it falls short of 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?

No guidance on when to use this versus update_event_comment or delete_event_comment, and no mention of prerequisites such as needing a valid event_uuid from get_events. Usage context is only implied by the 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?

With no annotations, the description carries the full burden. It does disclose useful traits: the CSRF token is automatically managed and the call returns the created event with a UUID. However, it omits permissions required, whether attendees are notified, and error behavior for an 18-param mutation.

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 and the CSRF/return facts are front-loaded effectively, but the full ten-color label enumeration duplicates the schema's own label_id description and bloats the text without adding meaning. The middle 'Supports...' sentence is a bare parameter recital.

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

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

For an 18-parameter mutation with no annotations and no output schema, the description covers the essentials: it states the return value, the auth handling, and the feature scope. Only permissions and side effects (attendee notifications) are missing, which keeps it just short of 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 100%, so the schema already documents all 18 parameters, including the label_id color mapping. The description's feature list (checklist, attendees, alerts, RRULE, category override) and the color legend largely restate what the schema provides, adding little semantic value beyond the baseline.

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

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

States a specific verb and resource ('Create a new event in a TimeTree calendar'), which immediately distinguishes it from siblings like update_event, delete_event, and create_memo. An agent can route to this tool without opening any schema.

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

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

Usage is only implied by the verb 'create' — there is no explicit guidance on when to prefer this over update_event or create_memo, and no stated prerequisites beyond the CSRF note. The CSRF mention adds a precondition but no alternatives or exclusions are named.

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 implies a write ('Create') but discloses nothing about permissions, what a memo is relative to an event, reversibility, or side effects. The 'category=2 event payload' phrase is internal jargon that hints at an implementation detail rather than telling the agent anything actionable.

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, so structurally efficient. The back half ('using the verified category=2 event payload') spends words on confusing internal terminology that does not earn its place for an agent deciding to call the tool.

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

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

This is a nine-parameter mutation tool with no annotations and no output schema, so the description must shoulder most of the contextual load. It omits permissions, return behavior, and how memos relate to events, leaving significant gaps for an agent to fill.

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 nine parameters are documented in the schema itself and the baseline is 3. The description adds no additional parameter meaning, but none is needed given the schema's completeness.

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+resource ('Create a TimeTree memo in a calendar'), which is better than a tautology. However, it offers no differentiation from the sibling create_event or the memo family (update_memo/delete_memo/list_memos), and the trailing 'category=2 event payload' phrase muddies rather than clarifies the purpose.

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

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

There is no indication of when to create a memo versus an event, no prerequisites, and no reference to alternatives such as create_event or update_memo. Usage must be entirely inferred from the tool 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?

With no annotations, the description carries the full burden and does disclose the most critical trait for a destructive tool: the action cannot be undone. It also notes the CSRF token requirement is automatically managed, removing a potential stumbling block. It stops short of covering permission requirements or behavior when the event does not exist.

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 short sentences, front-loaded with the operation, immediately followed by the irreversibility warning and then the CSRF note. No sentence is 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 delete with no output schema, the description covers the operation, its irreversibility, and the auth mechanism. Minor gaps remain around permission requirements and error/not-found behavior, but nothing essential to invoking 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 100% and both parameters are documented with provenance (get_events, list_calendars), so the baseline of 3 applies. The description adds no further parameter semantics beyond what the schema already provides.

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

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

States a specific verb (Delete) and resource (event from a TimeTree calendar), which cleanly distinguishes it from delete_memo and delete_event_comment in the sibling list. An agent can identify the operation without opening either schema.

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

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

Usage is implied by the destructive verb and the referenced siblings, but there is no explicit when-to-use guidance, no conditions for choosing delete_event over e.g. update_event, and no note about prerequisites beyond the CSRF mention.

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 not say whether deletion is permanent, whether it requires ownership/permissions, or whether the comment_id and 'activity ID' are interchangeable identifiers — the only hint is the ambiguous 'comment/activity ID' phrasing.

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?

One short sentence, front-loaded with verb and resource, no filler. It is appropriately sized but arguably too terse for a destructive operation.

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?

A destructive three-parameter mutation with no annotations and no output schema needs more: irreversibility, permission requirements, and how to discover the comment_id are all absent.

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 three parameters are already documented, including the calendar_id sourcing note. The description's 'comment/activity ID' adds nothing beyond the schema's own 'The comment/activity ID' text, so baseline 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?

States a specific verb (Delete) and resource (TimeTree event comment) and identifies the selector (comment/activity ID). It is clearly distinguishable from add_event_comment and update_event_comment, though it does not note that the calendar and event context are also required.

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 on when to use this versus update_event_comment or how to obtain a valid comment ID (e.g., via list_event_comments). The agent must infer the workflow entirely.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the single most important trait for a destructive tool – 'This action cannot be undone' – but says nothing about required permissions, whether deletion cascades to associated data, or what the response looks like.

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 zero filler, and the destructive warning is front-loaded immediately after the purpose statement. Nothing is redundant.

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

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

For a two-parameter, fully-documented tool with no output schema, the description covers purpose and the critical irreversible consequence. Only minor gaps remain, such as auth requirements or whether confirmation is expected before calling.

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 both calendar_id and memo_uuid are already documented in the schema, including the note that memo UUID equals event UUID. The description adds nothing beyond that, which is the expected baseline when the schema does the heavy lifting.

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 ('Delete') and resource ('TimeTree memo'), which cleanly separates it from delete_event and delete_event_comment in the sibling list. It does not explicitly contrast with update_memo or the event-deletion tools, but the resource noun is unambiguous.

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 no when-to-use context, no prerequisites, and no guidance on choosing between this and update_memo or the event-deletion siblings. The only implicit signal is that the action is irreversible, which hints at caution but is not usage 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 burden. 'Get' implies a read operation, and the field list (IDs, names, colors, ordering) usefully discloses the shape of the result. However, it says nothing about auth requirements, failure modes, or empty-label 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?

A single front-loaded sentence that packs the verb, resource, and return fields with zero 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 one-parameter read tool, the description is nearly sufficient: it names the returned fields in lieu of an output schema. The only gap is the absence of usage guidance against the sibling update 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% and the calendar_id parameter is thoroughly documented in the schema, including the note about numeric strings. The description adds no parameter detail beyond that, 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?

States a specific verb (Get) and resource (TimeTree calendar labels) and enumerates the returned fields (IDs, names, colors, ordering). It is clearly distinguishable from the sibling update_calendar_labels by the read verb, though it does not explicitly name that sibling.

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 no when-to-use context, no prerequisites, and no mention of the alternative update_calendar_labels. It relies entirely on the reader inferring usage from the verb.

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. 'Get' weakly implies a read operation, but nothing is said about permissions, pagination, deactivated-member handling, or the meaning of 'verified v2 users endpoint' — a significant gap for an unannotated 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?

A single front-loaded sentence with no filler. The closing clause about the 'verified v2 users endpoint' is jargon that does not help the agent select or call the tool, costing a point.

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

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

There is no output schema, so the description should indicate what a 'member' record contains (IDs, names, roles, activation state) and how results relate to include_deactivated. None of that is covered, leaving the tool under-specified for a read call an agent must interpret.

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

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

Schema coverage is 100% and both parameters are fully documented in the schema (calendar_id source, include_deactivated default). The description adds no syntax, format, or edge-case detail beyond the schema, so the baseline 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?

States a specific verb ('Get') and resource ('calendar members'), so the agent knows exactly what it fetches. It stops short of distinguishing itself from the sibling get_calendar_virtual_members, and the trailing 'verified v2 users endpoint' is implementation detail rather than 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?

No when-to-use guidance, no prerequisites, and no reference to the closely named alternative get_calendar_virtual_members. The agent is left to infer usage entirely from the 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?

With no annotations, the description carries the full behavioral burden. It implies a read via 'Get' but says nothing about permissions, whether the operation is safe/idempotent, what a 'virtual member' is, or what the response contains. The phrase 'verified virtual_users endpoint' is internal jargon that adds no actionable behavior for an agent.

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 efficient sentence with the resource front-loaded. It is slightly under-specified rather than padded, and the trailing 'verified virtual_users endpoint' clause is low-value jargon.

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?

A simple two-parameter read tool with no output schema and full schema coverage needs only modest description. The purpose is conveyed, but the definition fails to clarify the domain concept of 'virtual members' or how this differs from plain calendar members, leaving a real comprehension gap for the agent.

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 both calendar_id and include_deactivated are already documented in the schema (including the default for include_deactivated). The description adds no parameter meaning beyond that, so the baseline 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?

States a specific verb ('Get') and resource ('TimeTree virtual members for a calendar'), which is meaningful. However, it never differentiates itself from the sibling get_calendar_members, so an agent cannot tell from the description alone whether 'virtual members' is a subset or a distinct concept.

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

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

No when-to-use guidance, no prerequisites, and no mention of the obvious alternative get_calendar_members. The only usage signal is an implicit one from the verb 'Get'.

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 so well: it discloses automatic pagination handling, the default that memos are included, default recurring expansion, and critically that expanded occurrences share a series uuid so editing one edits the whole series — a side effect an agent must know before acting.

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 purpose, then behavior, then filter/legend detail; almost every sentence earns its place. The label color enumeration is long but is information not present in the schema, so it is defensible.

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

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

For an 8-parameter read tool with no output schema and no annotations, the description covers return fields, defaults, pagination, and recurring semantics, so an agent can call it correctly. It is only slightly short on any ranking/limit interaction with pagination.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds genuinely new meaning the schema lacks: the label_id 1-10 color mapping and the recurring-expansion behavior tied to start_before. It leaves the limit/pagination interaction unspecified, which keeps it from a 5.

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

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

States a specific verb+resource ('Get events from a specific TimeTree calendar') plus ordering semantics ('sorted by start time'), which is more than a tautology. It does not, however, distinguish itself from the sibling get_updated_events, so an agent cannot tell which listing endpoint to prefer from the description 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?

The description enumerates the available filters (time range, keyword, label, memos) which implies when the tool is useful, but it never states when to use it versus get_updated_events or list_memos, nor any prerequisites. Usage is implied rather than guided.

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 must carry the full behavioral burden. It usefully discloses the read-only nature and the maximum 2-year window, which are real operational constraints. However, it says nothing about auth requirements, rate limits, pagination, or how results are aggregated/deduplicated across multiple countries, leaving meaningful gaps for a multi-country query 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?

Three short sentences, front-loaded with the core action and scope, then a usage cue, then the safety trait. No redundancy or filler; every sentence carries information.

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

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

For a 4-parameter tool with no output schema and no annotations, the description covers purpose, range limit, and read-only status but stops short of clarifying the return shape (e.g., grouped per country, holiday type fields) or permission needs. Adequate but with clear omissions.

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

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

Schema description coverage is 100%, so the schema already documents format (YYYY-MM-DD, UTC), ISO codes, the max-5 limit, and the days_off_only default; baseline is 3. The description adds only the 2-year range cap and the observance-vs-day-off concept, which is marginal value beyond the schema.

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

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

Names a specific verb (Get) and resource (public holidays and memorial days) with explicit scope: one or more countries within a bounded date range. This is clearly distinguishable from siblings like get_events or list_calendars, which return user calendar items rather than national holidays.

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 sentence 'Useful for scheduling around days off' hints at the intended use case but never states when to choose this tool over get_events or how the two relate. No exclusions, prerequisites, or alternative-routing guidance are given, so usage is only implied.

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 reasonably well: it declares the tool is 'Read-only', states the ordering ('newest first'), and discloses a meaningful limitation ('TimeTree keeps only the last few activities per event'). It stops short of noting auth requirements, rate limits, or what the returned shape looks like.

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 dense, front-loaded sentence that leads with purpose, then change types, then the retention caveat, closing with 'Read-only.' No wasted words.

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

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

No output schema exists, so the description must characterize returns; it does name the actors and change categories but not the response structure or pagination. Combined with the read-only and retention notes, it is sufficient for a correct call but not fully 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 limit, since, and calendar_id are already fully documented in the schema. The description adds no parameter-specific meaning (e.g., how 'since' interacts with the retention window), so the 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 clear verb ('Get') and resource ('recently changed events and memos in a calendar') and enumerates the change types covered (created, title/date/label/... updated, deleted), so an agent knows it is an activity/audit feed. It does not, however, explicitly distinguish itself from the similar-looking sibling get_updated_events, 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 when-to-use, when-not-to-use, or alternative guidance. The closest siblings (get_updated_events, get_events) are never mentioned, so an agent must guess which retrieval tool to pick.

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

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

With no annotations, the description carries the full burden, and it does disclose one important behavioral trait: deleted events are returned with deleted: true. It also enumerates returned fields. However, it says nothing about permissions/auth, result ordering, pagination, or how limit defaults, all relevant for a read 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?

Purpose is front-loaded, followed by the deleted-event caveat and the returned-field summary. The trailing label-color enumeration is a long tail, but since there is no output schema it plausibly helps interpret returned label_id values rather than being pure padding.

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 the work of listing returned fields and the deleted:true marker, which is exactly what an agent needs. It is only missing result ordering and limit/pagination behavior for a filtered list endpoint.

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%, so calendar_id, updated_after, and limit are already documented with format guidance including the ms-timestamp conversion example. The description adds no parameter-level detail beyond what the schema provides; the label-color mapping is reference data, not parameter semantics. Baseline 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?

States a specific verb and resource with scope: events from a specified calendar updated after a given time. The 'recently modified' framing implicitly distinguishes it from get_events, but it never names that sibling explicitly, so the differentiation must be inferred.

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?

'Useful for finding recently modified events' implies the use case but gives no explicit when-to-use/when-not guidance and never mentions the obvious alternatives (get_events, get_recent_activity). The condition that selects this tool over a plain event listing is left 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 provided, and description does not disclose behavioral traits like auth requirements, rate limits, or return format beyond listing fields. Basic read operation implied.

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 purpose, no redundant information.

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

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

Given no parameters and no output schema, description covers return fields and a practical use case, fully adequate for a simple list 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?

No parameters exist, so schema coverage is 100%. Description adds no extra parameter meaning, but baseline for 0 parameters is 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 'list all active TimeTree calendars' with specific verb and resource, and it distinguishes from sibling tools by focusing on calendars rather than events or memos.

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?

Provides explicit context on when to use (identify calendar when user mentions a person), though lacks explicit when-not-to-use or 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?

No annotations are provided, so the description carries the full burden. It does add real behavioral context by disclosing that results are derived from the activity feed and narrowed to comment activities, but it says nothing about ordering, pagination, or required permissions.

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

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

Two short, front-loaded sentences with zero filler; the core purpose comes first and the filtering semantics follow. Nothing reads as padding.

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 with a fully documented schema, the definition is adequate but not complete: it omits return ordering, whether replies/threading are included, and pagination behavior, and there are no annotations to fill those gaps.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (event_uuid and calendar_id) with useful notes like 'numeric string; numbers are also accepted'. The description adds no parameter-level detail beyond that, so baseline 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 gives a specific verb and resource ('List comments for a TimeTree event') that immediately identifies the operation. It does not explicitly differentiate from related siblings like get_recent_activity or add_event_comment, though the second sentence hints at that relationship.

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: by saying it 'filters activity feed entries to comment activities only', it suggests use when you want comments rather than the full feed. There is no explicit when-to-use vs. get_recent_activity, no prerequisites, and no 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?

No annotations are provided, so the description carries the whole burden. It usefully discloses that memos are category=2 all-day events, which is real domain context, but says nothing about permissions, ordering, pagination, or return shape for a list operation.

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 zero filler; the purpose comes first and the clarifying definition of memos 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 3-parameter list tool with no output schema and no annotations, the description covers purpose and the memo/event relationship adequately, but leaves list behavior such as ordering and paging unaddressed.

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 three parameters (limit, calendar_id, updated_after) are already documented in the schema. The description adds no parameter-level detail beyond that, so the baseline 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?

States a specific verb (List) and resource (memos) scoped to a calendar, and the second sentence adds a real definition: memos are category=2 all-day events. That distinguishes it from generic event tools, though it never names get_events as the sibling it is not.

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 when-to-use guidance and no alternatives mentioned. An agent must infer from the name that this lists memos rather than events, with no condition that selects one over the other.

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 disclose a genuinely non-obvious trait: it reads existing labels first and merges, preserving omitted ones. That tells the agent this is a partial, non-destructive update. It still omits auth requirements, error behavior for invalid label IDs, and idempotency.

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 waste. The core action is front-loaded and the behavioral caveat follows immediately, with every clause earning 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 mutation tool with no annotations and no output schema, the description covers the critical non-obvious behavior (merge/preserve semantics) and the resource acted upon. It could add permission or failure-mode context, but nothing essential to calling 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 description coverage is 100%, so `id`, `name`, `color`, and `calendar_id` are already documented in the schema. The description's merge note about omitted labels adds context but no per-parameter syntax beyond what the schema provides, so baseline 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?

States a specific verb and resource: 'Update TimeTree calendar label names/colors.' An agent can tell this mutates labels, distinct from the read-only sibling get_calendar_labels. Sibling differentiation is implicit rather than stated by name.

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

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

Usage is implied (call it to change label names/colors) but the description never states when to use this over get_calendar_labels or what prerequisites exist. The merge behavior hints at context but no explicit when/when-not guidance is given.

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

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

With no annotations, the description carries the full disclosure burden. It usefully adds that a CSRF token is required (auto-managed) and that the updated event is returned, but it omits the destructive trait that the array fields replace existing values (only stated in the schema) and says nothing about permissions or irreversibility of the mutation.

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, front-loaded with the core operation and usage constraint. The trailing feature list is partly redundant with a fully-covered schema, but it is brief enough to earn its place as a scannable summary.

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 19-parameter mutation tool with no annotations and no output schema, the description covers the operation, partial-update semantics, auth requirement, and return value. The main gap is not flagging that array parameters destructively replace existing values, though the schema does document that.

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

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

Schema description coverage is 100%, so the schema already documents all 19 parameters including replacement/clear semantics. The description only groups the supported feature areas (checklist, attendees, alerts, RRULE, category) without adding format or constraint detail beyond the schema, so the baseline 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?

States a specific verb and resource ("Update an existing event in a TimeTree calendar") and the partial-update scope ("only provide the fields you want to change"), which cleanly separates it from the create_event/delete_event siblings. An agent can identify the operation without opening the schema.

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

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

The partial-update instruction tells the agent how to invoke it correctly (send only changed fields), and the mention of supported features frames the scope of use. It stops short of naming alternatives or when-not-to-use conditions (e.g., versus update_event_comment or create_event), 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation but says nothing about permissions, whether the update is full replacement or partial, whether the previous content is preserved, or what happens on an invalid comment_id. For a write tool with zero annotation coverage this is a substantial gap.

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 that identifies the operation and the identifying key with no filler. It is efficient, though it is arguably too terse to be maximally useful for a 4-parameter mutation.

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 no annotations, no output schema, and four required parameters, the definition is thin: it omits permission requirements, partial-vs-full update semantics, error behavior, and any reference to the companion comment tools. What exists is accurate but far from sufficient.

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

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

Schema description coverage is 100%, so all four parameters (calendar_id, event_uuid, comment_id, content) are already documented in the schema, establishing a baseline of 3. The description restates that comment_id is the comment/activity ID but adds no syntax, format, or validation detail beyond the structured fields.

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 (Update) and resource (TimeTree event comment) and identifies the keying mechanism (comment/activity ID), which is enough to distinguish it from add_event_comment, list_event_comments and delete_event_comment by action. However, it never explicitly contrasts itself with those siblings, so it falls short of the 5 level.

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 or when-not-to-use guidance, and no mention of the obvious alternatives (add_event_comment to create, delete_event_comment to remove). The agent must infer the edit-vs-create-vs-delete distinction purely from the verb, which the sibling set already supplies.

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 patch semantics (unmentioned fields are untouched), but says nothing about permissions, whether edits notify members, or that array fields like checklist/virtual_user_attendees are replaced wholesale rather than merged.

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, no filler, with the core action front-loaded and the partial-update rule immediately following. 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 nine-parameter mutation with no annotations and no output schema, the description is minimal but the schema compensates for the parameter detail. Missing are the mutation's side effects and any indication of what a successful update returns.

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

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

Schema description coverage is 100%, so all nine parameters including the empty-string/[] removal conventions are already documented in the schema. The description adds no field-level meaning beyond that, 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?

States a specific verb (Update) and resource (TimeTree memo), which cleanly separates it from the update_event and update_event_comment siblings. It stops short of naming those alternatives, so it is clear but not fully differentiated in prose.

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?

'Only provide the fields you want to change' is a real usage instruction that tells the agent this is a partial update, but there is no guidance on prerequisites (an existing memo must already exist) or when to prefer create_memo/delete_memo over this tool.

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