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

Beyond the annotations (readOnlyHint=false, idempotentHint=false), the description reveals the upsert behavior: if the entry already exists, unspecified fields keep previous values rather than defaults. It also discloses that customLists and advancedScores are zeroed/replaced rather than merged, the response echo should be checked, and login is required. These are significant behavioral traits not inferable from annotations alone.

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 efficiently front-loaded with the core purpose, then covers usage prerequisites, upsert behavior, and response handling. Every sentence serves a purpose, though there is slight redundancy between the 'defaults ONLY if not already on the list' and the upsert explanation. It could be tightened by a sentence without losing clarity.

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 14-parameter tool with nested objects and output schema, the description covers all essential aspects: authentication, media resolution, upsert semantics, defaults, response verification, and the special handling of customLists/advancedScores. It also notes the echo trimming rationale. Nothing critical for an agent to invoke 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%, so the schema already documents all 14 parameters in detail. The description adds no new per-parameter semantics beyond what the schema provides. According to the calibration rule, high coverage yields a baseline of 3; the description's extra context about customLists/advancedScores is already mirrored in the schema's own param descriptions.

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: 'Add an anime/manga to the authenticated user's own AniList list.' It also provides the required input ('Use search_media first to resolve the title to its AniList media ID'). However, it doesn't explicitly distinguish this tool from sibling 'update_list_entry' — the upsert behavior overlaps with that tool, so an agent might not know which to prefer for modifying an existing entry.

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 clear context: it advises using search_media to resolve media IDs, and get_user_list to check for an existing entry when a guaranteed-fresh one is needed. It explains when defaults apply vs. when existing values are kept. However, it never mentions alternatives like update_list_entry or update_list_entries, nor does it state when to prefer this tool over those to avoid ambiguity. The guidance is context-rich but lacks explicit alternative routing.

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

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

Annotations already mark destructiveHint=true and idempotentHint=false, but the description goes beyond by warning that deletion 'cannot be undone' and that calling again on an already-deleted id 'errors rather than silently succeeding.' It also discloses the login and ownership requirements, adding meaningful behavioral context not present in 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 tightly written sentences with no filler. The most important constraints (login, ownership, irreversibility) are front-loaded, and the non-idempotency behavior is stated in the second sentence. 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 single-parameter destructive action with a rich schema and output schema present, this description is complete. It covers authentication, authorization scope, permanence, and error behavior, leaving no critical gap for an agent deciding whether to call and what to expect.

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

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

The input schema has 100% coverage and describes the id parameter thoroughly, including valid sources. The tool description adds extra semantic value by stating the id must belong to an activity the authenticated user owns, which constrains which ids are valid and is not explicitly in the schema's id description.

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 ('Delete'), a specific resource ('activity post'), and adds the crucial scope constraint ('the authenticated user owns'). This clearly distinguishes it from sibling delete tools like delete_thread and delete_thread_comment without needing to inspect their 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?

It clearly communicates that the tool requires login and can only be used on activities owned by the authenticated user, which defines the applicable usage context. It does not explicitly mention alternatives or exclusions, but the resource-specific wording makes the intended use obvious given the sibling names.

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

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

Annotations already mark destructive and non-idempotent, and the description reinforces and extends this by stating the operation cannot be undone and that repeated calls on a deleted id error rather than silently succeeding. It also adds the authentication and ownership constraints, which are behavioral details not present in 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 dense sentences with no filler; the login requirement is front-loaded and every clause adds information. The description is short but complete.

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 single-parameter delete operation, the description covers how to obtain the id, the ownership requirement, the irreversibility, and the behavior on repeated calls. An output schema is present, so documenting return values is not required; nothing necessary for correct invocation is missing.

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

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

The single id parameter is fully documented in the schema, so the baseline is 3. The description adds useful provenance for the id (from search_thread, get_thread, or post_thread), helping the agent know exactly where to obtain a valid identifier.

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 action (delete), a specific resource (forum thread), and the ownership restriction (the authenticated user owns it). This distinguishes it from sibling tools like delete_activity and delete_thread_comment without 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?

It states the login requirement and gives explicit sources for the required id parameter, which tells the agent how to obtain valid inputs. It does not explicitly exclude alternatives like delete_thread_comment for thread comments, but the thread/comment distinction and ownership condition make the intended use 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?

Annotations already indicate destructive and non-idempotent behavior, but the description adds meaningful context: login is required, only the owner's comment can be deleted, deletion cannot be undone, and repeating the call on an already-deleted ID errors instead of silently succeeding. This goes well 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 dense sentences front-load the critical login requirement, then cover ownership, ID source, irreversibility, and repeated-call behavior with no filler. 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 single-parameter destructive operation with an output schema and rich annotations, the description covers prerequisites, ownership rules, ID provenance, and idempotency semantics. Nothing needed for correct invocation is missing.

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

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

The schema fully documents the 'id' parameter with a clear description and range. The tool description adds valuable provenance information, explaining exactly where the ID comes from, which supplements rather than merely repeats 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?

States the exact operation (delete), the resource (a forum thread comment), and the ownership constraint (the authenticated user's own comment). This clearly distinguishes it from sibling tools like delete_thread and delete_activity.

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 says the comment must be owned by the authenticated user and tells the caller where to get the ID (from get_thread_comments or post_thread_comment). It does not explicitly contrast with delete_thread or delete_activity, but the context makes the applicable case 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?

Annotations already declare readOnlyHint=true, so the description does not need to restate safety. It adds modest context about activity types and included fields, but it does not disclose behavior around missing IDs, errors, or response shape beyond what the output schema would provide.

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

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

A single, front-loaded sentence that states the resource, the lookup key, and the notable returned fields with no redundancy or filler. It is appropriately concise for a simple getter.

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-only getter with a rich parameter schema and an output schema present, the description is complete. Nothing essential is missing for an agent to invoke the tool correctly.

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

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

The single parameter is fully documented in the schema with 100% coverage, including where the ID can come from. The description only says 'by its ID' and adds no semantic value 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?

The description uses a specific verb-resource pair ('Get a single ... activity post') and clarifies the resource by enumerating the activity types (list update, text post, or message). Stating 'by its ID' differentiates this tool from list-returning siblings like get_user_activity and search_activity.

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 the tool should be used when an activity ID is already known, but it does not explicitly contrast it with alternative tools or state when not to use it. The schema's ID provenance note helps, but the description itself provides only implied 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?

Beyond the readOnlyHint and openWorldHint annotations, the description discloses important behavioral traits: results are ordered soonest-airing first, data is 'confirmed live', and manga/non-anime IDs are rejected as not-found rather than silently returning an empty schedule. This adds meaningful context that the annotations do not convey.

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 focused sentences, with the primary action front-loaded and supporting usage details following. Every sentence earns its place; the note about manga mismatch is specific and valuable, not 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?

Given the presence of an output schema, the description appropriately focuses on call modes, ordering, and media-type constraints. It covers all necessary behavioral context for correct invocation and interpretation.

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

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

The input schema already provides 100% coverage for all four parameters. The description adds critical semantic nuance: omitting mediaId yields the site-wide schedule, while passing it (sourced from search_media/get_media) yields a single title's next air time. This explanation goes beyond the schema's field-level descriptions.

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: 'Get upcoming (or a specific title's) episode air times'. It clearly identifies this as the anime airing schedule tool and distinguishes it from siblings by referencing how it relates to search_media/get_media, making its role 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?

It explicitly tells the agent when to omit mediaId (site-wide upcoming schedule) versus when to pass it (single title's next-episode air time), and includes a clear exclusion: anime only, with manga IDs rejected as not-found. This is actionable routing guidance.

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

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

Annotations provide readOnlyHint and openWorldHint, so the base safety profile is known; the description adds substantial behavioral context beyond that: login is required, array fields are full-replace rather than merged, and advancedScoring is positionally interpreted. These traits materially affect how the agent should sequence calls.

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 dense and arguably long, but every sentence carries distinct operational value: confirming identity, read-before-write replacement semantics, and the positional advancedScoring risk. It is front-loaded with the core purpose and login requirement; only the extended update_user caveats keep it from being maximally tight.

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 parameters and an output schema present, the description only needed to cover access and use context. It does so thoroughly, including prerequisite (login), primary use, and the highest-risk interaction (update_user field replacement).

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

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

The tool has zero parameters and schema coverage is 100%, so there is nothing for the description to add about parameter meaning. The baseline of 4 applies because no parameter clarification is needed.

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: 'Get the profile of the AniList account currently authorized via login_anilist/ANILIST_ACCESS_TOKEN.' It also frames the purpose as confirming which account is connected, which clearly differentiates it from sibling profile/user tools like get_user_profile or get_full_user_info.

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 when-to-use guidance: use it to confirm the connected account, and as the mandatory read-before-write source before update_user calls touching specific fields. It goes further by explaining why (full array replace, positional advancedScoring), so an agent knows the precondition without inferring it.

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=true, covering the safety and external-data nature. The description adds valuable behavioral detail beyond annotations: the media list is limited to 25 entries and sorted by popularity, with each entry including characterRole. This clarifies the output structure and ordering without contradicting 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: the first states the action and scope, the second provides usage guidance. It is front-loaded with the primary purpose, avoids redundancy, and every sentence earns its place. No extraneous details.

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 an output schema available, the description doesn't need to detail every return field, but it mentions the key components (name, image, description, media with roles) and the popularity-based limit. Combined with the search_character prerequisite, an agent has everything needed to call this tool correctly. The one-parameter interface and annotations round out completeness.

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

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

The input schema has 100% parameter description coverage, including 'AniList character ID.' The description reinforces this by referencing the same ID and linking it to the search_character workflow, but it doesn't add significant new meaning beyond what the schema already states. This aligns with the baseline for high 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 retrieves a character profile by AniList ID and enumerates the included fields (name, image, description, media with roles). This distinguishes it from sibling tools like search_character (which resolves names) and get_media_characters (which fetches characters for a specific media).

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 instructs to use search_character first to resolve a name to an ID, setting clear when-to-use guidance and the prerequisite step. This is direct and unambiguous, leaving no room for an agent to misuse the tool without knowing its required input.

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?

Goes well beyond readOnlyHint and openWorldHint annotations by disclosing that account settings are returned regardless of viewer authentication, and that statistics can lag and read all-zero. These are non-obvious behaviors that could mislead an agent if not disclosed, so the description provides important context.

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

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

Every sentence earns its place: combination purpose, alternative routing, viewer-gating behavior, staleness warning, and input exactness are all packed efficiently without redundancy. It is front-loaded with the core function.

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 an output schema exists to specify return values, the description covers the essential context: when to use, input requirements, behavioral caveats, and sibling distinction. Nothing that an agent needs to invoke 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 already covers the param as 'AniList user ID, or username' (100% coverage). The description adds the nuance that the username must be exact and that fuzzy names require a prior search, which is useful 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?

States a specific verb and resource: 'Get an AniList user's profile AND statistics in a single call.' It explicitly distinguishes from siblings by saying 'use this instead of calling get_user_profile and get_user_stats separately,' making its purpose 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?

Provides explicit when-to-use guidance: replaces two separate calls, and clarifies when to skip search_user ('no need to call search_user first unless you only have a partial/fuzzy name'). Also conveys the staleness caveat as a usage consideration, so agents know stats may be inaccurate.

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=true, so the description adds limited behavioral transparency beyond confirming it lists genre names. It provides context about the data source (AniList) but doesn't disclose additional traits like return format or pagination. The description does not contradict annotations.

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

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

The description is extremely concise at two sentences, with the main purpose stated upfront. Every sentence adds value: the first defines the tool's output, and the second explains its practical use case. 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?

Given the tool has no parameters and an output schema exists, the description is fully adequate. It explains what the tool returns (genre names), why it's useful (to feed into search_media filtering), and references the relevant sibling tool. This covers all necessary context for an agent to correctly 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?

The tool has zero parameters, so the description need not explain parameter semantics. The baseline for zero parameters is 4, and the description appropriately focuses on the output and usage rather than parameters.

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 that the tool lists every genre name AniList uses to tag anime/manga, with examples like Action, Comedy, Slice of Life. It distinguishes itself from other tools by specifying its purpose in the context of filtering search_media by genre, making the purpose very clear and specific.

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 tells when to use the tool: call it before filtering search_media by genre, to ensure you pass a recognized genre name. While it doesn't explicitly state when not to use it or mention alternatives, the guidance is clear and actionable for its intended use case.

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

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

Annotations provide readOnlyHint and openWorldHint, and the description adds substantial behavioral detail: login-required mediaListEntry, batch ordering with null placeholders, ID clamping behavior, format size differences, and compact-mode field suppression. It reveals important edge-case behavior that structured fields alone cannot convey.

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 front-loaded with the core purpose and then builds outward to batch behavior, alternatives, and return shape. A few details, such as exact byte measurements, are arguably redundant with the parameter descriptions, but the structure is logical and every major section 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?

Given the complexity of ID-based batching, format switching, and sibling alternatives, the description covers all necessary operational context: when to use it, how to avoid wrong matches, how batches behave, what compact drops, and what requires login. The output schema covers return structure, and the description handles the rest.

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?

Even though schema coverage is 100%, the description enriches every parameter's meaning: exactly-one-of ids/malIds, MAL ID type sensitivity, compact-format implications, and streaming episodes' potential for huge responses. This goes well beyond the schema's own descriptions.

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

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

The description names a specific verb and resource: getting anime/manga details by AniList or MAL IDs. It clearly differentiates from search_media and other get_* siblings by focusing on ID-based lookup rather than search or relationship queries.

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 states when to use this tool versus search_media, tells the agent to prefer malIds when MAL IDs are already available, and explains when to use compact format for ID-to-title mapping. It also names alternatives and gives decision-relevant context without leaving 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.

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

With readOnlyHint and openWorldHint annotations present, the description adds valuable behavioral context: it discloses that results are not ordered by role or popularity, and that anime characters include voice actors. This goes beyond annotations and helps set correct expectations.

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. The primary action is front-loaded, followed by a precise usage note and a useful ordering caveat. 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?

Given the output schema and annotations, the description covers the essential aspects: what is returned, the prerequisite, and a critical ordering nuance. It does not describe pagination or error behavior, but those are handled by the schema and annotations, so nothing critical 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%, so parameters are already well documented. The description adds meaning by linking the id parameter to the search_media prerequisite and clarifying the type parameter's role, plus noting voice actors for anime. This enhances comprehension without redundancy.

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 lists an anime/manga's characters with roles and voice actors, and explicitly distinguishes it from get_character/get_staff's reverse-direction lookup. The verb 'List' and resource are specific, and the contrast with siblings makes its 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?

It provides an explicit prerequisite (use search_media first to resolve title to AniList ID) and clarifies when not to assume ordering, while contrasting with the popularity-sorted reverse lookup. It does not exhaustively enumerate alternatives, but gives sufficient context for correct usage.

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=true, so the safety and openness profile is covered. The description adds useful specifics about what the call returns (relation types and type) but does not cover edge cases like empty results or invalid IDs. This is comparable to baseline value beyond 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 concise sentences with zero redundancy: the first states the tool's function and output, the second gives the prerequisite. The most important scoping information is front-loaded before the usage note.

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 full schema coverage, an output schema present, and read/open-world annotations, the description provides the necessary purpose, output shape, and prerequisite. It is not exhaustive about edge cases, but nothing essential to correct invocation is missing.

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

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

Schema coverage is 100% and both parameters have descriptive definitions, so the schema carries the meaning. The description adds a small workflow hint that the ID comes from search_media, but it does not add syntax, format, or enumeration details beyond the schema. 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 uses a specific verb ('Get') and resource ('anime/manga related to a given title'), enumerates the relation types (prequels, sequels, side stories, adaptations, spin-offs), and clarifies it includes the relation type. This clearly distinguishes it from sibling tools like get_media_characters or get_media_reviews.

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 directs the agent to 'Use search_media first to resolve a title to its AniList ID', establishing a clear prerequisite workflow. It does not name exclusions or compare against alternative tools, but the sequential use case is unambiguous.

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 and openWorldHint annotations, the description discloses the ordering behavior ('most-helpful-voted first' with a live confirmation that it sorts by `rating`, not `score'), states that `summary` is always included, and warns that full review bodies can be long. This gives the agent useful expectations about output size and ordering.

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 dense sentences, each earning its place: the first states what the tool does and its ordering, the second covers output shape and optional payload, and the third gives the prerequisite workflow. No filler or redundant restatement of the schema.

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

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

With annotations covering safety and openness, an output schema for return values, and schema descriptions covering all parameters, the description fills the remaining gaps: prerequisite lookup, ordering caveat, and payload-size guidance. Nothing an agent needs to call this 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%, and each parameter already has a clear description. The tool description adds a little context around includeBody's payload-size tradeoff, but it largely restates what the schema already communicates, so the baseline of 3 is appropriate.

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

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

The description begins with a specific verb and resource: 'List user-written reviews for an anime or manga.' This clearly distinguishes the tool from sibling media-related tools like get_media or get_media_characters, and the title reinforces the same function.

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 explicit guidance: use search_media first to resolve a title to its AniList ID, and only set includeBody when the full review text is actually needed because it can be long. It also clarifies the default response content, so an agent knows when the tool is sufficient without extra payload.

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 and openWorldHint, but the description adds a non-obvious behavioral caveat: 'No explicit ordering is requested — don't assume results are sorted by role or popularity.' It also clarifies that get_staff is popularity-sorted, providing contrast beyond the annotations.

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

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

The description is two sentences with zero filler. The first sentence states the purpose immediately, and the second adds a critical usage prerequisite and an ordering caveat, all front-loaded and relevant.

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 listing tool with an output schema, the description covers the essential purpose, the ID resolution step, and a behavioral nuance. Annotations cover safety and world-persistence, and the schema handles pagination; the only minor gap is not explicitly stating 'use for a media's staff' as a selection rule, but that is inferable from the purpose.

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 only restates that search_media resolves a title to an AniList ID, which the `id` schema description already communicates; no new parameter semantics are introduced.

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 ('List') and identifies the resource ('anime/manga's staff') with concrete role examples (director, writer, character designer). It differentiates from the sibling get_staff by noting the reverse-direction lookup and its popularity sorting, making the tool's scope 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?

It explicitly instructs to 'Use search_media first to resolve a title to its AniList ID,' which is a clear prerequisite. It also contrasts with get_staff by pointing out the ordering difference, though it does not explicitly state 'use this when you have a media ID' or list other exclusions; the distinction is implied rather than fully spelled out.

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=true, so the read-only nature is covered. The description adds valuable context about the data returned (status counts and score distribution) and the global scope (across all AniList users), which goes beyond the annotations. No contradictions.

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 wasted words. The core purpose is front-loaded, and the usage guideline is appended concisely. Every sentence contributes necessary 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 simple tool with only two parameters, an existing output schema, and annotations covering safety and open-world behavior, the description provides all needed context: what it returns, the global scope, and the prerequisite to resolve IDs via search_media. 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?

The input schema has 100% description coverage for both parameters: 'AniList ID' and 'Whether id refers to anime or manga'. The description does not add any additional meaning to the parameters beyond what the schema already provides, 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 verb ('Get') and resource ('anime/manga's watch/read-status counts and score distribution histogram'), and specifies the scope ('across all AniList users'). It clearly distinguishes this from media-specific queries by requiring an ID and referencing search_media for title resolution.

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 instructs to 'Use search_media first to resolve a title to its AniList ID', which is a clear prerequisite for correct usage. It does not explicitly name alternative tools or when not to use it, but the guidance is direct and unambiguous.

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?

Even though the annotations already declare readOnlyHint=true and openWorldHint=true, the description adds valuable behavior details: it mentions the total count (~425 tags), the pagination behavior, and the critical detail that an unrecognized tag name 'doesn't error, it just silently matches nothing'. This is beyond what annotations provide and directly informs the agent of a non-obvious failure mode. The description discloses the pagination requirement and the silent matching behavior, which is excellent behavioral transparency.

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

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

The description is a single paragraph that is dense but well-organized: purpose first, then pagination note, then use case and the critical caveat. Every sentence adds value: the first defines the tool, the second explains pagination and the number of tags, the third gives a concrete use case with a behavioral warning. No fluff, front-loaded with purpose, and the most important caveat is placed at the end but still within a short paragraph.

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

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

For a simple paginated list tool with only two optional parameters, the description covers the purpose, pagination behavior, total count, and the exact use case with a behavioral warning. The output schema exists, so the return values need not be described. The tool's complexity is low, and the description is complete: an agent knows exactly what to expect, how to use it, and what pitfalls to avoid. There is nothing missing that an agent would need to call it 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 100% description coverage for both parameters (page and perPage), with detailed descriptions including pagination limits and clamping behavior. The description only adds the context that results are paginated and to use page/perPage, but the schema already covers the semantics thoroughly: the page description explains the 5000-entry limit, and perPage explains the max 50 with silent clamping. Since schema coverage is high, the baseline of 3 is appropriate, and the description does not need to add more.

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 purpose: 'List every descriptive tag AniList uses on anime/manga'. It specifies the resource (media tags), differentiates from genres with concrete examples, and mentions the adult-content flag and category. The wording 'List every...' is a specific verb+resource combo, and the pagination note distinguishes it from potential alternatives.

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

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

The description explicitly states when to use this tool: 'Use this to look up a tag's exact name before passing it to search_media's `tag_in`'. It even explains why (case-sensitive, unrecognized names silently match nothing). It gives clear context for when this tool is needed, which is a lookup step in a workflow, and indirectly implies it's not for direct media search. It does not name a sibling tool as an alternative, but it does state the exact use case, which is sufficient.

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 significant behavioral traits beyond the annotations: it requires authentication, the markAsRead side effect resets the unread badge, pagination depth limits are explained, and type-specific output fields are detailed. It also notes that account-level notification options can suppress types regardless of the filter. This far exceeds what the annotations (readOnlyHint=false, openWorldHint=true) imply, giving the agent a full behavioral picture.

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 information-dense and front-loaded with purpose, then explains output structure and side effects. It is somewhat long, but every sentence adds necessary detail about type-specific fields and pagination constraints. No filler; it earns its length, though a slightly tighter phrasing would push it to 5.

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 description is exceptionally complete for a tool with a rich output schema: it covers login requirements, pagination limits, filtering behavior, side effects, and the nested structure of each notification type. Given the output schema exists, the description does not need to repeat return values, but it still adds crucial guidance on parsing type-specific fields. Nothing an agent needs to call this 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?

All parameters are already described in the input schema with high detail (100% coverage), so the baseline is 3. The description does not add new parameter-level semantics; instead it focuses on the output structure and side effects. While this output context is valuable, it does not enhance the meaning of the parameters themselves beyond what the schema provides.

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

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

The description opens with a clear, specific verb and resource: 'Get the authenticated user's AniList notifications', and enumerates the exact notification types it covers. This distinguishes it from sibling activity/feed tools (get_activity, get_user_activity) without ambiguity. The purpose is unambiguous and actionable.

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

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

The description states the login requirement and the scope (authenticated user), and it clarifies that filtering only affects returned results, not generation. However, it does not explicitly name alternative tools or state when not to use it, leaving the agent to infer from context rather than receiving direct routing guidance.

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

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

Annotations already indicate readOnlyHint and openWorldHint, but the description goes beyond them by disclosing a known AniList-side inconsistency: a majority of IDs from get_recommendations_for_media's nodes[].id will 404 here, regardless of rating. This is critical behavioral context for error handling and prevents misinterpretation of 404s as non-existence. The description also clarifies the server's lack of voting capability, adding transparency.

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

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

The description is front-loaded with the core purpose and usage, but the 404 caveat adds length. It is structured logically: purpose, alternative, then a necessary caveat. While somewhat verbose, every sentence earns its place by conveying essential usage or behavioral information. It could be tightened slightly, but it remains well-organized and not bloated.

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 single-parameter read-only tool with an output schema, the description covers all necessary context: what it does, when to use it, the alternative, and a critical known issue. The output schema handles return format, and annotations cover safety. Nothing an agent needs to correctly invoke or handle this tool is missing.

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

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

The schema already provides 100% coverage with 'AniList recommendation ID' and integer constraints. The description adds context about the ID's source (from get_recommendations_for_media) and the 404 caveat, which clarifies that some IDs may not resolve. This goes beyond the schema's basic type/description, giving the agent insight into ID validity and expected behavior, though it doesn't add format or syntax 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 clearly states it fetches a single AniList recommendation pairing by its ID, explicitly defining the resource (media + recommended media) and the operation (get). It differentiates from get_recommendations_for_media by noting that tool is for discovery/browsing, while this is for re-checking a specific pairing. The verb and resource are specific and 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 provides explicit guidance on when to use this tool vs the sibling: use get_recommendations_for_media to discover IDs or browse, and use this tool to re-check a specific pairing's rating. It also notes a scenario (after voting on anilist.co) and clarifies the server has no voting tool. This is clear and 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?

Annotations already mark this as read-only and open-world. The description adds useful behavioral details: ranking order, login requirement for mediaListEntry, and the server-side filtering behavior of excludeInList. This goes beyond the annotations without contradicting them.

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 focused sentences with no filler. The main purpose and ranking order are front-loaded, followed by the prerequisite and a practical filtering tip. 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?

Given the rich input schema, output schema, and annotations, the description is complete for an agent to invoke the tool correctly. It covers the prerequisite workflow, auth-sensitive fields, and the key behavioral caveat about pagination filtering.

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 fully documents all parameters. The description adds workflow context and clarifies excludeInList's purpose, but does not substantially extend the parameter semantics already present.

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 lists user recommendations for a given title, ranked by rating. It is specific about the resource and action, but does not differentiate from the sibling tool 'get_recommendation'.

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 instructs to use search_media first to resolve a title to its AniList ID, and recommends excludeInList for server-side filtering. It provides clear context but does not mention when to prefer the sibling get_recommendation tool.

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 and openWorldHint annotations, the description reveals concrete behavior: daily counts, newest-first ordering, default last 7 days, and AniList's own silent perPage cap of 25. This is genuinely useful runtime behavior not encoded in the annotations.

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

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

The description is three sentences with no filler. The core function is front-loaded, followed by usage guidance and a practical cap clarification. Every sentence earns its place and the length is appropriate for the tool's complexity.

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 two optional parameters, no nested objects, an output schema, and strong annotations, the description covers purpose, scope, defaults, pagination, and behavioral quirks. Nothing necessary for an agent to correctly select and invoke this tool is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra meaning by explaining that page/perPage allows going further back in time and that perPage's cap is enforced by AniList itself, which clarifies why the parameters matter beyond their raw schema definitions.

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

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

The description uses a specific verb and resource: 'Get AniList's own site-wide statistics' including 'new users/anime/manga daily counts'. It also explicitly distinguishes itself from anime-data tools by saying 'not for anime data', making it clear which sibling tools 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?

The description gives clear context for when to use this tool: 'Useful for questions about AniList's growth/activity, not for anime data'. It states the default window and how to go further back with page/perPage, but it does not name a specific alternative tool, so it falls just short of a 5.

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 and openWorldHint, covering the safety profile. The description adds meaningful behavioral detail: the returned field set, the staffMedia limit of 25, ordering by popularity, and inclusion of staffRole. This goes beyond the annotations without contradicting them.

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 no filler; the core purpose and result details are front-loaded, and the usage hint is appended cleanly. Every sentence contributes useful 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 single-parameter read-only tool with an output schema and clear annotations, the description is complete. It specifies the input, the key returned fields, the media list behavior, and the prerequisite workflow to resolve names to IDs.

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 single id parameter is already fully documented in the schema with type, range, and the description 'AniList staff ID.' The tool description mostly repeats 'by AniList staff ID,' adding no new parameter semantics beyond the schema's high 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 operation ('Get a staff member's profile') and the exact resource identifier (AniList staff ID), while enumerating the contained fields. It is immediately distinguishable from siblings like search_staff (search vs. fetch by ID) and get_media_staff (staff profile vs. media-specific credits).

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 instructs agents to 'Use search_staff first to resolve a name to its ID,' which is a clear and valuable usage workflow. It does not enumerate when not to use it or mention alternative siblings beyond search_staff, so it stops short of full exclusion guidance.

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

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

Annotations already declare readOnlyHint=true, but the description adds substantial behavioral context beyond that: the top-10 fixed cap is non-paginated with no more exposed via AniList, name performs AniList's own fuzzy search (same mechanism as search_studio), and id takes precedence over name. The 'confirmed live' detail further signals verified behavior. 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 dense but every sentence earns its place: return payload, fixed cap, lookup modes, fuzzy-search behavior, alternative routing, and precedence rule. Core result is front-loaded, and the alternative guidance comes at the end without bloating. No filler or redundancy.

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

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

With an output schema present and full parameter documentation, the description still covers everything an agent needs to invoke the tool correctly: what is returned, how each argument behaves, what happens when both are supplied, and when to choose a sibling tool. The only unstated edge case (no arguments provided) is negligible given the schema's optionality and the descriptive parameter hints.

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 documentation already covers both parameters at 100%, giving the baseline of 3. The description adds real value beyond the schema: it explains the id-over-name precedence, clarifies that name resolves fuzzy partial matches, and connects name's search mechanism to search_studio. This lifts it above baseline, though it doesn't provide new syntax or format 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 opens with a specific verb ('Get') and a specific resource ('a studio's profile') followed by the exact data returned: name, animation-studio flag, and top 10 most popular produced titles. It distinguishes itself from the sibling search_studio by contrasting the direct lookup with the browse-multiple-candidates use case.

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 states the two lookup methods (by ID or by name), specifies the precedence rule when both are given, and names the alternative tool with the exact condition for choosing it: 'reach for search_studio instead only when you need to browse multiple candidates rather than take the closest match.' This is fully actionable guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is known. The description adds value by specifying exactly which metadata fields are returned (replyCount, viewCount, likeCount, isLiked), giving the agent a clear expectation of the response content 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?

A single sentence that is concise, front-loaded with the purpose, and contains no filler. Every phrase earns its place: resource, scope, and key return fields.

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 an output schema, so return values are already documented elsewhere. The description covers what the tool does and the primary data it returns, which is sufficient for a simple get-by-id operation. No critical information an agent needs 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 100% — the id parameter is fully documented in the schema, including how to obtain an ID via search_thread or a forum URL. The description adds no additional parameter meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('Get') and resource ('AniList forum thread') and lists the concrete data returned (title, body, metadata with replyCount, viewCount, likeCount, isLiked). It clearly distinguishes from sibling search_thread by requiring an ID, so an agent can tell them apart 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 description implies this tool is for fetching by ID but does not explicitly state when to use it versus alternatives like search_thread or get_thread_comments. No exclusions or alternative guidance is given in the description itself; the schema description mentions using search_thread, but that is not part of the tool description, so the guidance is implied rather than explicit.

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 known. The description adds valuable behavioral detail beyond that: replies are nested under their parent's childComments rather than appearing as separate entries, which materially affects how an agent should 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?

Two concise sentences, with the primary purpose front-loaded and the key behavioral nuance about nested replies following immediately. Every sentence earns its place with no filler.

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

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

Given the rich schema, read-only annotations, and an output schema for return values, nothing essential is missing. The description clarifies the only non-obvious behavior an agent needs to correctly interpret the results: the top-level vs. nested reply distinction.

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 provides 100% coverage, including rich context on pagination limits and how to obtain a threadId. The description adds only minor framing by mentioning the thread ID and parentCommentId; the schema carries the load, 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 states a specific verb and resource: 'List top-level comments posted on an AniList forum thread, by the thread's ID.' It distinguishes itself from sibling tools like get_thread (which fetches the thread itself) and post_thread_comment (which posts comments), and clarifies that only top-level comments are returned.

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

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

The description makes clear this tool returns top-level comments only and that replies are nested under childComments, referencing the related post_thread_comment tool. It gives clear context for what results will look like, though it does not explicitly state when to choose this over an alternative such as get_thread.

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 readOnlyHint/openWorldHint, but the description adds substantial behavioral disclosure beyond that: the fixed 50-result cap with silent omission, the lighter fetch omitting filmography, and the warning that a missing filmography should not be interpreted as 'none'. This is precisely the kind of non-obvious behavior an agent needs to know.

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 every sentence earns its place: it front-loads the core behavior (list up to 50 birthday people), then the cap caveat, then the lighter-fetch distinction and the alternative. No filler or repetition; it is dense but well-organized.

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

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

Given the output schema and annotations, the description covers the essential operational details: result cap, shape, omitted fields, and when to use siblings. The only notable gap is the missing timezone/date-source definition for 'today'; without that, an agent cannot know whose 'today' applies, which is a subtle but real ambiguity for a birthday 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 coverage is 100%, but the description adds real semantic value beyond the schema: it explains that kind maps to character-shaped vs staff-shaped results, and it gives a token-cost rationale for includeDescription along with an alternative ('use get_character/get_staff for a single entry's full bio instead'). This helps the agent choose parameter values wisely, not just syntax.

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 ('list'), resource ('AniList characters or staff members'), and temporal filter ('birthday ... is today'). It also explicitly differentiates from get_character/get_staff by noting the lighter fetch and omitted filmography, so an agent can distinguish this from siblings without opening 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?

The description gives clear when-to-use context: listing birthday characters/staff. It also provides explicit routing to alternatives: 'call get_character/get_staff by ID for an entry's full roles/works and bio, don't read a missing filmography here as none.' This tells the agent when not to rely on this tool and which sibling to use instead.

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 signal readOnlyHint=true, and the description adds meaningful context beyond that: no type filter in the underlying query, direct username resolution with one extra internal lookup, and the implied difference from search_activity's silent-empty behavior. These traits help an agent predict what will happen before invoking the 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 sentences with zero filler: scope, username-resolution behavior, and two sibling-tool routing rules. The main purpose is front-loaded, and every sentence carries information an agent would otherwise have to infer or test.

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 an output schema present, a rich input schema, and strong annotations, the description still adds the missing contextual glue: how username handling differs, when not to call search_user, and which siblings cover adjacent use cases. Nothing needed to invoke or select the tool correctly is left unspecified.

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 each parameter is already documented in detail, so the baseline is 3. The description adds real value for the 'user' parameter by stating that an exact username is accepted directly and that search_user is unnecessary, which clarifies a common usage decision beyond the schema's anyOf definition.

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

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

The description states a specific verb+resource: 'List recent AniList activity posts from a specific user,' and immediately clarifies scope ('every activity type… underlying query applies no type filter'). It also distinguishes itself from search_activity and get_user_recent_activity, so an agent can pick it without opening a 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?

Explicit when-to-use guidance is front and center: it says there's no need to call search_user first for exact usernames, points to search_activity when filtering by type or browsing without a user, and points to get_user_recent_activity for a non-paginated 5-item snapshot. Exclusions and alternatives are both 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe read. The description adds substantial behavioral detail: the default compact output size, the 10x size penalty of full format, pagination semantics with chunk/perChunk, and the ~11,000 entry ceiling. These are non-obvious traits that materially affect how an agent calls the 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?

The description is long but every sentence earns its place. It opens with the default and primary use case, then adds depth on formats, filtering, pagination, and edge cases. No fluff or redundancy—each clause adds a distinct piece of guidance an agent needs.

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 six parameters and an output schema, the description covers everything needed to call the tool correctly: default behavior, output size, pagination steps, filtering options, and the rare ceiling case. The sibling context (e.g., search_user) is addressed directly, and the description fully equips 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 coverage is 100%, so every parameter is already documented. The description goes well beyond the schema by explaining the trade-offs between compact and full, the meaning of perChunk being uncapped, and how chunk counting works across all statuses. It adds operational context that the schema alone does not convey.

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 precise verb and resource: 'Get a user's AniList anime or manga list.' It clearly distinguishes itself from search_user by stating that an exact username works directly, and it separates itself from other list-management tools by focusing on retrieval. This leaves no ambiguity about what the tool does.

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 explicit when-to-use guidance: it recommends the compact format for sync/comparison tasks, advises full format only when specific fields are needed, and instructs to use statuses for server-side filtering. It also explicitly says when search_user is unnecessary, which is a clear exclusion against an alternative tool.

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=true. The description adds useful behavioral context beyond that: it notes that account settings are NOT viewer-gated and are included for any user, not just the authenticated caller. This is a non-obvious fact that affects expectations. It does not mention response format or potential errors, but with readOnly covered by annotations, 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 front-loaded with the primary purpose, then adds the viewer-gating clarification, and ends with routing to alternatives. Each sentence earns its place with no redundancy or fluff. The structure logically guides an agent from what it does to when to use it.

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 is simple (one parameter), has an output schema, and read-only annotations, the description covers everything an agent needs: what data is returned, that no authentication is required, how to supply the parameter, and how to avoid unnecessary search_user calls. It is complete for safe and 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 input schema already documents the parameter as 'AniList user ID, or username' (100% coverage). The description adds operational nuance: it accepts an exact username directly and clarifies that search_user is only needed for partial/fuzzy names. This enriches the schema's static definition with usage semantics.

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

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

The description clearly states the tool retrieves an AniList user's public profile and enumerates specific data points (name, about, avatar, donator status, account settings). It explicitly distinguishes itself from get_full_user_info (statistics) and search_user (lookup), so an agent can differentiate it from siblings without inspecting other 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?

Provides explicit guidance: states that an exact username can be passed directly and that search_user is only needed for partial/fuzzy names. Also tells the agent to use get_full_user_info instead of calling get_user_stats separately when statistics are needed. This is clear when-to-use and when-not-to-use guidance.

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

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

Annotations declare readOnlyHint=true, and the description adds further behavioral context: it returns full content, not just IDs, has a fixed count of 5, applies no type filter, errors on unknown IDs/usernames (per param description), and costs an extra internal lookup when resolving usernames. This goes beyond the annotations and provides a clear model of the tool's behavior, though it doesn't mention rate limits or other edge cases.

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

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

The description is a single, well-structured paragraph that front-loads the core purpose and then clarifies limitations and alternatives. Every sentence adds value, though it's slightly dense; it remains efficiently scannable.

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

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

For a tool with one parameter and a rich output schema, the description covers all essential usage aspects: fixed count, activity type scope, error behavior, alternative tool, and username resolution cost. Nothing an agent needs to invoke 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?

The single parameter is fully described in the schema (ID or username, and error behavior), so schema coverage is 100%. The description adds guidance on when to resolve usernames via search_user, which complements the schema and gives the agent practical usage context beyond static type definitions.

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

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

The description clearly states the tool gets a user's 5 most recent activity posts with full content, covering all activity types, and explicitly differentiates from get_user_activity by noting the fixed count and non-paginated nature. This gives a precise, distinguishable 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?

The description explicitly instructs to use get_user_activity instead when a paginated full feed is needed, and advises not to call search_user unless the username is partial/fuzzy, explaining the extra lookup cost. This gives clear guidance on when to use this tool and when not to.

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 a real behavioral quirk: AniList's stats aggregation can lag and return all-zero statistics even for active accounts. It provides a concrete example and instructs the agent not to infer 'no list activity' without cross-checking, which is exactly the kind of non-obvious behavior an agent needs.

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?

Each sentence earns its place: purpose, direct-usage guidance, the zero-result caveat, and the alternative tool routing. It is front-loaded with the core purpose and keeps the caveat concise enough to remain scannable.

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

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

With a single fully described parameter, an output schema available, and annotations already covering read-only/open-world behavior, the description supplies the remaining operational context: when to skip search_user, when to cross-check get_user_list, and which sibling to use for profile data. Nothing an agent needs for correct invocation is missing.

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

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

The schema already fully documents the single parameter (user ID or username), so the baseline is 3. The description adds value by emphasizing that an exact username is accepted directly and that a prior search_user call is unnecessary, which affects how the agent should populate the parameter.

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: 'Get an AniList user's anime/manga statistics' and enumerates the returned categories (counts, mean score, time watched, episodes/chapters/volumes consumed). It also distinguishes itself from profile-related siblings, so an agent can tell it apart from get_user_profile and get_full_user_info.

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 says an exact username can be passed directly and that search_user is only needed for partial/fuzzy names. It also names the right alternative when profile data is needed and tells the agent to cross-check get_user_list before interpreting zeroed stats as no activity.

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 annotations (readOnlyHint=false, openWorldHint=true), the description discloses prerequisites (app registration, callback URL, env vars), warns that auto_capture is not a reliable detector of local browser access, and explains the remote/SSH headless scenario. This is rich behavioral context that prevents misuse.

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

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

The description is front-loaded with the core purpose, and every subsequent sentence delivers essential prerequisites, flow steps, or a pitfall warning. The length is justified by the complexity of the OAuth flow, and there is no filler or redundant content.

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

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

Given the OAuth orchestration, the presence of an output schema, and the need to coordinate with submit_anilist_redirect, the description is complete: it covers setup, the returned URL, automatic vs manual completion, and the meaning of the auto_capture field. No ambiguity remains.

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

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

The tool has zero parameters, so schema coverage is 100% and the baseline is 4. The description adds context about environment variables and port configuration, but since there are no input parameters to document, it cannot add more beyond that 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?

The description opens with 'Authorize the personal-list and social tools with your AniList account (one-time)', which is a specific verb and resource. It clearly distinguishes this from the follow-up tool submit_anilist_redirect, establishing the tool's role as the initial authorization step.

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 the complete flow: calling this returns an authorization URL, then either auto-completes if browser is local or instructs to pass the redirect URL to submit_anilist_redirect. It explicitly covers when to use the alternative and the conditions that determine which path to follow.

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 goes well beyond the annotations by revealing that the operation is publicly visible despite the 'message' framing, that the underlying AniList mutation supports a 'private' argument the tool does not expose, and that updates are possible. This directly addresses the most likely misconception about the 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?

The description is compact and front-loaded: the main purpose comes first, then the update mode, then the critical visibility warning. Every sentence earns its place and no unnecessary wording is present.

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 a detailed input schema and an output schema, the description provides the essential operational context: login requirement, public visibility, update behavior, and a clear confidentiality warning. Nothing critical is missing 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?

Schema description coverage is 100% and each parameter already has a clear schema description. The tool description adds context about 'id' meaning update mode, but largely restates what the schema already documents. It does not significantly enhance parameter-level understanding beyond the schema.

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

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

The description states a specific action ('Post a new message-style activity to another AniList user's profile') and a second mode ('or update an existing one by passing its id'). It also differentiates the tool from a private DM and references post_text_activity for comparison, making the tool's identity 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 explicitly states the login requirement, distinguishes create-vs-update usage, and gives a clear when-not-to-use rule: do not use it for anything the sender expects to stay confidential. This is strong practical guidance for an agent deciding whether to invoke it.

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 and destructiveHint=false, indicating a mutating but non-destructive operation. The description adds the login requirement and the dual post/update behavior, which are useful beyond the annotations. However, it does not disclose details like whether updating replaces the text entirely, rate limits, or error conditions. The added value is modest, so a 3 is appropriate.

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

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

The description is a single sentence with no filler. The login requirement is front-loaded, and the two use cases (post/update) are clearly separated. It is concise and well-structured, though it could be slightly clearer with separate sentences for each mode.

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 output schema exists, so return values need not be described. All parameters are fully documented in the schema, and the description covers the login requirement and the update capability. It does not mention that the tool only handles text-status activities (vs. other activity types), but this is implicitly clear from the tool name and sibling context. Overall, the definition is nearly complete for an agent to call it correctly.

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

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

Schema description coverage is 100%, with both 'id' and 'text' already described in the schema. The description mentions 'passing its `id`' for updates and refers to 'text', but these are already covered by the schema. It adds no new meaning beyond what the schema provides, so the baseline of 3 stands.

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 ('Post'/'update') and the resource ('text-status update on the authenticated user's own AniList profile'). It distinguishes itself from siblings like post_message_activity by explicitly scoping to text-status updates, and the mention of 'update an existing one' differentiates its dual-mode behavior. No ambiguity remains about what the tool does.

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 includes the prerequisite '[Requires login]' and specifies that it acts on the authenticated user's own profile, which is helpful context. However, it does not explicitly state when to prefer this over alternatives such as post_message_activity or update_list_entry, nor does it mention any exclusions. The usage context is partially implied but not fully explicit.

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

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

The annotations already flag this as a write operation (readOnlyHint=false) and not idempotent, but the description goes further: it warns that the tool's response omits categories/mediaCategories/isSticky/isLocked, that sticky/locked silently no-op without moderator permission, and that categories/mediaCategories are full-replace and can silently drop existing values. These live-tested caveats meaningfully extend beyond annotations, so an agent knows to verify changes via get_thread.

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

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

The description is three sentences, with the core action and update mode front-loaded. The subsequent sentence gives targeted usage routing, and the final note lists concrete verification steps and silent-failure risks. No filler or redundancy; 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?

Despite the tool's complexity (7 parameters, create vs update modes, silent no-ops, and response-field omissions), the description covers the key non-obvious behaviors: login requirement, duplicate-check guidance, response verification via get_thread, and full-replace semantics. Since an output schema exists, the tool description does not need to explain return values. The only minor omissions (e.g., categories required on create) are already handled in the schema, so completeness is high.

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 input schema already documents each parameter in detail, including the full-replace behavior of categories and mediaCategories and the required/optional conditions. The tool description adds no parameter-level information not already present in the schema; it mainly points to the schema ('see those fields' own descriptions below'). Per the rubric, baseline 3 applies when the schema carries 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 opens with a specific verb+resource: 'Post a new forum thread to the authenticated user's own AniList account, or update an existing one by passing its `id`.' This distinguishes the tool from sibling post tools like post_text_activity/post_message_activity by resource (forum thread) and from post_thread_comment by scope (thread vs comment). It also names search_thread and get_thread as related but different.

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 tells the agent when to use search_thread first ('if you want to check whether a similar thread already exists before posting a new one') and when to follow up with get_thread ('call get_thread with the returned `id` afterward to confirm whether a category/sticky/locked change actually applied'). It also scopes the tool to the authenticated user's own account, giving users a clear when-not condition. This is explicit usage routing with alternative tools, earning a 5.

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 convey that this is a mutating, non-destructive operation. The description adds the login requirement and clarifies that the action is tied to the authenticated user's account, which is useful operational 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?

The description is a single, compact sentence with no filler. It front-loads the login requirement and clearly states both creation and update behaviors.

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 100% schema coverage, helpful per-parameter descriptions, an output schema, and annotations covering mutation/destructiveness, the description is sufficiently complete. The only missing element—the reply behavior—is fully documented in `parentCommentId`'s schema description.

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%, with each parameter already well-documented, including the non-obvious distinction between `id` and `parentCommentId`. The description only adds marginal value by mentioning the update behavior via `id`, which the schema already explains.

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 (post), the resource (comment on an AniList forum thread), and adds the distinction between creating a new comment and updating an existing one via `id`. This differentiates it from siblings like post_thread (posting a thread) and delete_thread_comment.

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 notes the login prerequisite and the create-vs-update distinction, giving some usage context. However, it does not explicitly state when to choose this tool over alternatives such as posting an activity, nor does it mention the reply option via `parentCommentId`.

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 (destructiveHint=true, idempotentHint=false), the description explicitly states the operation cannot be undone and that repeating it on an already-deleted ID errors rather than silently succeeding. This is valuable behavioral context for an agent deciding whether to call the 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?

The description is two sentences with no filler. It front-loads the required login, states the action, clarifies the ID type, and then covers irreversibility and error behavior—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?

With one well-documented parameter, an output schema present, and annotations covering destructive and non-idempotent behavior, the description adds the remaining critical context: login requirement, ID source, and failure mode. 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 coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by pointing to get_user_list as the source for the list-entry ID and reiterating that it is not the media ID, which helps prevent a common misuse.

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 ('Delete an entry') on a specific resource (the authenticated user's own AniList list) and clarifies the key distinction from media IDs. This clearly differentiates it from sibling tools like add_list_entry and update_list_entry.

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 tells the agent where to obtain the required ID ('get it from get_user_list') and notes that login is required. It does not explicitly contrast with sibling delete tools, but the deletion purpose is unambiguous and the ID-source guidance is practical.

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 and openWorldHint, covering the safety profile. The description adds meaningful result-behavior context: each result is self-contained, includes all content, and a follow-up call is only needed to re-check mutable fields after a reaction. This is genuinely useful 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 dense sentences with the core capability front-loaded and the follow-up guidance placed right after. Every clause is actionable, and there is no filler or repetition 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?

With the output schema available cherry plus a 100%-covered input schema, the description covers all the essential decision points: what the tool returns, when a follow-up is unnecessary, and when to use get_user_activity. An agent has enough information to select and invoke this tool correctly.

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

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

Schema description coverage is 100% and the schema already provides detailed explanations for user, type, page, and perPage. The tool description restates the filters but adds little parameter-specific meaning beyond what the schema already carries, so it stays at the baseline rather than compensating further.

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 and resource: 'Search/browse AniList's activity feed,' and clearly states the optional user/type filters. It also distinguishes itself from the sibling get_activity tool by noting that results are already complete and no follow-up call is needed.

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 main description explicitly tells agents not to call get_activity afterward because results include full content, and only re-check after actions like liking. The schema further routes to get_user_activity when only a single user's feed is needed without a type filter, and clarifies that search_user is unnecessary for exact usernames.

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 this as read-only and open-world, so the safety profile is covered. The description adds valuable behavioral context beyond that: results omit bios by default, and the returned values are AniList IDs meant for downstream use with get_character. This is genuinely useful for invoking the tool correctly.

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, and the core purpose and primary behavioral caveat are both front-loaded. Every clause earns its place, and the description is easy to parse in a tool list.

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

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

The tool is a simple paginated search with a rich input schema, an output schema, and read-only annotations. The description covers the essential workflow (search → get_character), the notable token-saving default, and nothing important is missing 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?

Schema description coverage is 100%, and every parameter already has a detailed, self-explanatory description. The tool-level description largely repeats the includeDescription point already present in the schema, so it adds little semantic value beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Search AniList for characters by name.' It also clarifies the tool's role in a workflow by saying it 'Returns AniList IDs to use with get_character,' which distinguishes it from the get_character and other search siblings. The scope 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 makes the search-vs-fetch distinction explicit by framing the output as IDs to feed into get_character, and it tells the agent when to set includeDescription. It does not explicitly contrast with sibling search_staff, search_media, etc., but the resource-specific phrasing makes the intended use 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?

With only readOnlyHint and openWorldHint annotations, the description adds meaningful behavioral facts beyond structured data: adult results are included by default unless sfw is set, term-less ranking browsing is supported, and the tool returns IDs rather than full media objects. These are non-obvious behaviors that materially affect invocation and result interpretation.

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

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

The description is a single well-structured paragraph that front-loads the core purpose, then covers the two browsing modes, the critical NSFW caveat, and the output's downstream role. Every sentence earns its place; nothing is repeated from the schema or annotations. For a tool with 25 parameters, this is appropriately sized and skimmable.

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 25-parameter schema with 100% parameter coverage, an output schema, and read-only annotations, the description supplies the missing high-level context: how to choose between search modes, what the sort parameter is for when browsing without a term, the NSFW default, and how results connect to get_media. An agent has enough to select and call this tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value above that by grouping filter categories (genre, format, status, season/year), explaining the ranking use of `sort` with concrete examples (top-rated, most popular, trending), and flagging the important `sfw` default. It does not deeply explain every parameter, but the schema already carries that weight.

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 with a specific resource: 'Search AniList for anime or manga by title and/or filters'. It also distinguishes two distinct modes (title/filter search vs term-less ranking browse), and clarifies the tool's role in the workflow by stating it 'Returns AniList IDs to use with get_media and other ID-based tools.' This separates it clearly from sibling search tools like search_character and search_staff.

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 clear when-to-use context: use it when searching by title/filters, or when browsing without a title via ranking sorts. It also points to the downstream use with get_media and ID-based tools. It stops short of explicitly naming alternatives to avoid or stating exclusions (e.g. 'for character/staff search use search_character'), so it earns a 4 rather than a 5.

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 this readOnly and openWorld, and the description adds the key default behavior that bio/description fields are omitted unless includeDescription is set. It also frames the token-cost tradeoff, supplementing the annotations without contradicting them.

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 sentences lead with the core action, then the return-value relationship, and finish with the most important optional-parameter caution. No filler or redundant 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?

Given the rich output schema, exhaustive parameter documentation, and readOnly/openWorld annotations, the description covers the remaining operational context an agent needs: what results are for, what is omitted by default, and when to prefer get_staff. 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 parameters are already fully documented; the description mostly restates the includeDescription tradeoff. It adds some practical emphasis around get_staff, but does not provide substantial new meaning beyond the schema.

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

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

Description opens with a specific verb and resource ('Search AniList for staff members by name') and clarifies the result's role ('Returns AniList IDs to use with get_staff'). This clearly distinguishes it from sibling search tools (search_character, search_studio, search_user) and the companion get_staff tool.

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

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

It explicitly names get_staff as the follow-up for retrieving full bios of a single entry, and warns against setting includeDescription for bulk searches due to token burn. This gives concrete when-to-use and when-to-avoid guidance beyond the generic search description.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description adds relevant behavioral context: it returns multiple candidate matches and provides AniList IDs for use with get_studio. It does not contradict the annotations and does not need to re-explain read-only semantics.

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

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

The description is front-loaded with the core purpose and wastes no words, though the second sentence is slightly dense with comparative detail. Overall it is compact and readable.

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 output schema exists, pagination is documented in the input schema, and annotations cover the read-only/open-world profile, the description is complete enough for an agent to select and invoke the tool correctly. It covers purpose, use case, output relationship, and key alternative.

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

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

Schema coverage is 100%, and the schema already documents term, page, and perPage in detail including defaults, limits, and upstream paging behavior. The description reinforces term as a partial-name search but does not add meaning beyond the schema's parameter descriptions.

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-resource pair ('Search/browse AniList's animation/production studios by name') and explicitly contrasts itself with get_studio, which takes the closest match. This clearly differentiates it from its sibling search tools.

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

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

It gives an explicit when-to-use condition: when you want multiple candidates rather than the closest match. It also names the alternative (get_studio) and explains that get_studio's own name param already performs fuzzy matching, so an agent can decide correctly without opening either schema.

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=true, so the agent knows this is a safe read operation with potentially open-ended results. The description adds that it returns thread IDs with title/category context, but it does not disclose any error behaviors or edge cases (e.g., deep pagination failures) – though those are covered in the parameter schema. Since annotations cover the safety profile and the schema covers pagination constraints, the description adds modest value but not rich behavioral detail.

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

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

The description is a single, focused sentence that front-loads the action and resource, then adds the return value and downstream tools. There is zero fluff, and every clause serves a purpose. It is exemplary in conciseness and structure.

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 an output schema, so return format is covered elsewhere. The description provides the essential context: what it searches, what it returns, and how to use the results. It is complete enough for an agent to decide when to call it, though it could optionally mention that it is the only thread search tool. Given the rich schema and annotations, a 4 is fitting.

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 each parameter has a detailed description covering behavior (e.g., term matches title/body, categoryId silent filtering, page limit). The description itself does not add parameter-specific semantics beyond what the schema already provides; it merely summarizes the search scope. Baseline 3 is appropriate because 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?

The description uses a specific verb 'Search/browse' with a clear resource 'AniList's forum threads', and specifies that it returns thread IDs with context. It is distinct from sibling search tools like search_media or search_character because it explicitly targets forum threads and lists downstream tools for using the results. The purpose is unambiguous and easily actionable.

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

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

The description states the results are intended for use with get_thread, get_thread_comments, post_thread, or post_thread_comment, giving clear downstream context. However, it does not explicitly contrast with other search tools (e.g., search_media) or state when not to use this tool. Still, the primary use case is clear from the wording, so it earns a 4 rather than a 5.

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=true, so the description does not need to repeat that this is a safe read-only search. It adds useful behavioral context by explicitly stating that the tool returns AniList user IDs rather than full user profiles, which prevents an agent from expecting complete user data and directs it to the correct follow-up tools.

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

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

The entire description is a single dense sentence that front-loads the action ('Search AniList for users') and then packs the return-value contract and downstream tool routing into the rest. Every clause earns its place; the long list of target tools is justified because it is exactly what an agent needs to decide what to do with the result.

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 search tool with 100% schema coverage, an output schema, and readOnlyHint/openWorldHint annotations, the description is complete. It states what is searched, how to search, what is returned, and how to use the returned IDs. There is no missing piece an agent would need to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents term, page, perPage, and includeDescription with detailed explanations. The description adds no new parameter-level meaning beyond 'by username,' which is also in the term schema. Per the rubric, baseline 3 is appropriate when the schema carries the burden.

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: 'Search AniList for users by username.' This clearly differentiates search_user from the many sibling search tools (search_media, search_character, search_staff, etc.) that target different entity types. It also clarifies the output purpose by saying it returns user IDs, reinforcing what the tool does rather than restating the 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?

The description gives clear downstream context: returned IDs can be passed to get_user_profile/get_full_user_info, get_user_stats, get_user_list, or toggle_follow_user. This helps an agent know what to do after calling the tool. It does not explicitly state when not to use search_user, but the entity-specific wording and the list of sibling search tools make the intended use reasonably 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?

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false, so the description's burden is lower. It adds context about the login failure scenario but doesn't elaborate on idempotency or side effects. Value is moderate.

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 concise sentences that front-load the purpose and provide necessary details without extraneous information. Every sentence adds value.

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 (single parameter, output schema present), the description covers purpose, usage context, and parameter nuances sufficiently. No gaps remain.

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 parameter 'redirect_url' is fully described in the schema, and the description adds extra meaning by clarifying that a bare code string is also accepted, going beyond the schema's description of 'full redirected URL'.

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 completes an AniList login by submitting a redirect URL, using specific verbs and resources. It distinguishes from the sibling tool 'login_anilist' by describing its role in the login flow.

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 states when to use this tool (when login didn't complete automatically, e.g., on remote/headless hosts), and mentions the prerequisite of having initiated login with 'login_anilist'. It also notes that a bare code string is accepted, providing clear 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?

Annotations indicate non-read-only, non-idempotent, and non-destructive, which the description aligns with. It goes beyond by disclosing that the response returns the entire favourites list, that AniList does not validate kind-id pairing, and that there is a confirmed read-after-write lag. 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 long but every sentence adds operational value: purpose, toggle behavior, response shape, id resolution, validation gap, and lag. It is front-loaded with the core purpose and follows with necessary caveats, with no filler.

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

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

Given the tool's complexity, the description covers login requirement, exact toggle semantics, response list shape, parameter resolution process, a serious API validation gap, and a data consistency caveat. With an output schema present, this is fully complete.

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

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

Although the schema already provides descriptions for both parameters, the description adds essential semantics: the id must be resolved from a tool matching the kind, and because AniList does not validate the match, incorrect pairings silently succeed. This is critical usage knowledge not present in the schema.

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

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

The description uses the specific verb 'toggle' and clearly identifies the resource: an anime, manga, character, staff member, or studio in the authenticated user's AniList favourites. It distinguishes this from sibling tools by focusing on the favourites toggle action, not list entries or user follows.

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 workflow: resolve the id via search_media/get_media, search_character/get_character, etc., based on kind. It also warns against reusing IDs and explains the toggle behavior (calling again un-favourites). The read-after-write lag note gives additional guidance for verification.

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 meaningfully adds beyond annotations by disclosing the login requirement and the toggling behavior — calling again unfollows. This is important state-changing context that the annotations (readOnlyHint=false, idempotentHint=false) do not fully convey on their own.

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 no filler. The login requirement is front-loaded, and the toggle/unfollow behavior is stated in one follow-up sentence. 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 single-parameter mutation with an output schema, the description plus the rich schema description fully cover what an agent needs: the action, auth requirement, toggle behavior, and how to identify the user. No important operational detail 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%, and the schema already explains the numeric ID format, the absence of a username form, and the need to resolve via search_user or get_user_profile. The description adds no additional parameter-level meaning, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Toggle following') and names the exact resource (another AniList user from the authenticated account), going beyond the title to define the toggle behavior. This clearly distinguishes it from sibling tools like toggle_favourite or get_user_profile.

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

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

The description clearly establishes the context: login is required and the action operates on the authenticated user's account. It does not explicitly name alternatives or exclusions, but the tool's scope is narrow enough that 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?

The description adds substantial behavioral context beyond the annotations: it requires login, explains all-or-nothing atomic semantics, states that a single bad id fails the whole request with no partial application, warns that the error does not identify the bad id, and notes the return summarizes counts rather than full entries. This is exactly the kind of operational detail an agent needs.

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 every sentence earns its place: purpose, usage guidance, exclusions, input source, failure semantics, and return behavior. It front-loads the primary purpose and sibling differentiation before diving into operational caveats. No filler or redundancy.

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

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

For a complex 12-parameter mutation tool with nested objects, the description covers the essential operational surface: when to use it, what it deliberately does not accept, authentication, error behavior, and return shape. The output schema handles return-value details, and the annotations cover idempotency and destructiveness. Nothing critical is left to guesswork.

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 genuine semantic value for key parameters: listEntryIds are explicitly list-entry IDs (not media IDs) sourced from get_user_list, score is always on a 0-10 scale regardless of account settings, and progress is only meaningful when entries genuinely share a value. These warnings go beyond the schema's field-name descriptions.

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: 'Apply ONE set of values to many entries on the authenticated user's own AniList list in a single request.' It clearly differentiates the batch tool from its sibling update_list_entry by stating it cannot vary values per entry. No ambiguity about what the tool does.

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 tells when to use this tool instead of update_list_entry (shared values across entries), and when to use the sibling (different values per entry, or need for customLists/advancedScores). It also names prerequisite context: requires login and expects list entry IDs from get_user_list. This gives the agent a clear decision rule.

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