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

Annotations mark readOnlyHint=false, consistent with a mutation, and the description adds a behavioral prerequisite (follow requirement) that likely causes an error if violated. This goes beyond the annotations, but it does not disclose behavior for duplicates, idempotency, or partial failures. It enriches moderately but remains limited.

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

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

Two short sentences with no filler. The first sentence restates the title, while the second adds the valuable prerequisite/error insight. Efficient enough to earn a 4, though the opening sentence is mildly redundant with 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?

For a simple mutation with full parameter coverage, the description includes the key prerequisite an agent needs to avoid the common error. It does not address success/failure shapes or permission restrictions, but given no output schema and low complexity, this is an adequate level of 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?

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific detail beyond the follow prerequisite; it does not clarify formats for the 'account' selector or 'accts' values, but the schema already covers those.

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

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

The description states a clear verb and object: 'Add accounts to a list.' This unambiguously identifies the operation and distinguishes it from siblings like remove_from_list, create_list, or list_accounts. The title and description align 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?

The description provides one useful usage constraint: you must already follow an account before adding it to a list. However, it does not explicitly compare against alternatives or state when not to use this tool. The guidance is implied by the operation name rather than 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?

The description adds a meaningful behavioral detail beyond annotations: rejecting a request is silent and the requester is not told. This is useful, non-obvious context that annotations do not provide. The broader effects of approval are left implicit, but the annotations already establish the mutation profile.

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 only two sentences long, front-loads the core action, and adds one high-value behavioral caveat. Every word earns its place, with no vague filler or unnecessary repetition.

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

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

For a simple two-decision mutating tool, the description gives an agent enough context to select the tool and choose approve vs reject; the schema fills in the account selector and decision enum. Minor gaps include not describing the expected outcome/return shape and not pointing to get_follow_requests as the listing step.

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 description clarifies that decision values map to approve/reject and that 'acct' refers to the requesting account. However, 'acct' remains under-specified regarding expected format, and the description mostly restates the enum semantics rather than adding new parameter-level detail 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 names the exact action (approve/reject) and exact resource (pending follow request). It differentiates itself from sibling tools like get_follow_requests, which lists requests rather than acting on them, and follow_account, which initiates a follow rather than resolving a pending one.

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

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

The description clearly implies the appropriate context—acting on a pending follow request—but it does not explicitly state when this tool should be preferred over alternatives. It also does not suggest get_follow_requests as the companion tool for enumerating pending requests before calling this one.

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 destructiveHint=true, but the description adds substantial context: the block is visible to the target, removes follows in both directions, hides posts, is reversible while the follows do not return, and requires confirmation. This goes well beyond the structured metadata, fully disclosing side effects and reversibility.

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

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

Four short, information-dense sentences with no filler. The core action is front-loaded, followed by the most important effects, then the confirmation caveat. Every sentence contributes distinct 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?

The description explains the core behavior, side effects, reversibility, and confirmation requirement, which is sufficient for an agent to execute the tool. The only notable gap is the lack of detail on the 'acct' parameter format, and since there is no output schema, the description carries the burden of explaining what the call achieves—which it does well.

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 67% because the required 'acct' parameter has no description. The tool description does not clarify what format 'acct' should take, leaving that gap unaddressed. It does reinforce the meaning of 'confirm' via the 'Needs confirm: true' note, but does not add meaning for the undocumented parameter, so a baseline score applies.

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

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

States a specific verb and resource ('Block an account') and goes beyond the title by enumerating exact consequences: visibility to the target, removal of follows in both directions, and hiding of posts. This differentiates the action from siblings like mute_account or block_domain by describing the precise behavioral effect.

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 appropriate use case—when you want to block and hide your posts from an account—and clearly signals the confirmation requirement. However, it does not explicitly name alternatives like mute_account or unblock_account, nor does it state when NOT to use this tool, leaving selection partially to inference.

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

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

Annotations already carry destructiveHint=true and readOnlyHint=false. The description adds concrete behavioral context beyond that: it hides entire instance accounts and removes followers, and it flags the confirmation requirement.

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 concise sentences plus a short confirmation note. Every part earns its place: the action, the usage context, and the confirmation requirement.

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?

It communicates scope, purpose, and confirmation need, and the schema handles parameter details. It does not describe the return value or reversibility, but the destructive annotation and confirm flag make the operation adequately clear.

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 fully documents domain, account, and confirm. The description only mentions confirm, adding no meaningful parameter semantics 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 says exactly what the tool does: hide every account on an instance and remove their followers. It further distinguishes this from a single-account action with 'rather than one account', making it clear versus sibling tools like block_account.

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 a clear usage condition: use this when a server is a persistent problem rather than one account. It does not explicitly name alternative tools or state when not to use it, so it is slightly below 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?

Given the annotations already declare non-read-only, non-destructive, and idempotent behavior, the description adds useful context about the visibility of bookmarks versus favourites. This goes beyond the structured 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?

The description is only two sentences and leads with the core action. The first sentence repeats the title, a minor redundancy, but the second sentence earns its place by adding differentiating context, so there is no meaningful bloat.

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

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

For a simple one-required-parameter action, the description plus schema fully equips an agent to invoke it: id and account are documented, the privacy behavior is stated, and annotations cover side-effect expectations. No output schema is present, and none is needed 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%: id and account are both clearly documented in the input schema. The tool description adds no parameter-level meaning, so the baseline 3 applies.

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

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

States a specific verb and resource ('Bookmark a status') and immediately distinguishes the action from favourites by noting bookmarks are private, which separates it from the sibling favourite_status tool. Even though the first sentence mirrors the title, the added privacy scope makes the 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?

The privacy contrast ('unlike favourites, which the author can see') gives clear situational guidance: use bookmarks when the action should be private and favourites when author visibility is acceptable. It does not explicitly name the alternative tool, so it stops short of a full when/when-not statement.

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 readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the agent knows this is a non-destructive mutation. The description adds the Mastodon quote-post limitation but does not explain how a boost appears or that it can be undone via unboost_status. This is adequate but not rich behavioral disclosure.

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 short and front-loaded, with the core action stated first and the caveat second. The first sentence repeats the title almost verbatim, which is mild redundancy, but the overall structure is tight and 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 simple one-required-parameter mutation with no output schema, the description plus schema and annotations cover the necessary call context. It addresses the main ambiguity (boost vs. comment), account selection is documented in the schema, and idempotency is annotated. Mentioning reversibility would improve completeness but is not essential.

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 account parameter already explains matching rules, defaults, and how to list accounts. The tool description contributes no additional parameter-level semantics, 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 and resource ('Boost a status to your followers') and immediately distinguishes itself from adding a comment. This separates it from related sibling actions like favourite_status, post_status, and unboost_status.

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 not to use this tool: to add a comment instead, post a status quoting the URL because Mastodon has no native quote post. This is a clear when-not/alternative routing that prevents a common misuse.

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 cover read-only, idempotent, non-destructive behavior. The description adds meaningful behavioral context beyond that: only opted-in accounts are visible, ordering is by new or recently active, and instance scoping is the default. This is useful for setting agent expectations, though it does not mention pagination or output shape.

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

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

Three short sentences with the most important scoping and ordering information front-loaded. The final sentence about finding people without a recommendation engine adds context without bloating the description.

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 browsing tool with four optional parameters, all schema-documented, the description covers the key decision factors: who is included, ordering, and scope. It does not detail the result shape, but the concept of browsing a directory of accounts makes the expected output reasonably clear.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description reinforces the order and local-only semantics, but it does not add new parameter-level meaning beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description says this tool lists accounts that opted into discoverability, sorted by newest or most recently active, and scoped to an instance. That is a clear resource and behavior, though the verb 'browse' is only in the title and it does not explicitly distinguish itself from sibling search or follow-suggestion 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 situational color: scoped to your own instance unless you ask for the wider network, and positioned as a way to find people without a recommendation engine. However, it never says when to prefer it over alternatives like search or get_suggested_follows, and it offers no explicit 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 already mark the operation as non-read-only, non-idempotent, and open-world, so the description only needs to add context; it adds the key precondition that the status must not have published. It does not describe error behavior or side effects, but that is acceptable for a simple cancel operation.

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

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

One tight, front-loaded sentence with no filler or repetition of schema fields. Every word contributes to the action and the boundary condition.

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

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

For a two-parameter mutation with annotations and a detailed account field, the description is mostly sufficient; the missing id semantics and the lack of a pointer to list_scheduled_statuses are the main gaps. No output schema exists, so not documenting return values is not a penalty here.

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 account parameter is well documented in the schema, but the required id parameter has no description and the tool description never states that id is the scheduled-status identifier from list_scheduled_statuses. At 50% schema coverage, the description does not compensate for the gap.

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

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

States a clear verb and resource ('Cancel a status that was scheduled') and adds the scope qualifier 'has not published,' which separates it from deleting a published status. It does not name or explicitly contrast sibling tools, so it stops short of a 5.

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

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

The description implies the intended use: for a scheduled status that has not yet published, and its wording excludes already-published statuses. It does not explicitly tell the agent when to prefer this over reschedule_status or to obtain the id via list_scheduled_statuses.

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 destructiveHint=true and readOnlyHint=false, so the description's added value is the irreversibility ('no undo'), the permanent/delete-all scope, and the explicit confirmation requirement. These are useful behavioral details 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?

Three short sentences with no filler: the action comes first, the key caveats follow, and the confirmation requirement is stated plainly. 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 destructive action with two well-documented parameters and no output schema, the description covers what happens, how permanent it is, and what gate must be satisfied. It could be slightly more explicit about the selected account scope and name mark_read/dismiss_notification as alternatives, but the schema and sibling list cover most of that.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description's 'Needs confirm: true' reinforces the confirm parameter but adds no meaning beyond what the schema already says about confirm, and it says nothing new about account.

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, unambiguous action: 'Delete all notifications permanently.' It also distinguishes the operation from 'marking them read,' which clearly separates it from sibling tools like mark_read and dismiss_notification.

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: this is a permanent, confirm-gated delete-all operation, and it explicitly says it is not equivalent to marking notifications read. It does not name the alternative tool to use for read-only marking, but the exclusion is enough for an agent to avoid the most likely confusion.

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 this is not read-only, not idempotent, and not destructive. The description merely repeats 'Create' and adds no new behavioral context—no mention of side effects, whether the list starts empty, authorization requirements, or what the response contains. For a mutating tool, this is a gap beyond what annotations cover.

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 one short sentence plus a practical pointer to add_to_list. It is front-loaded with the core purpose and contains no filler or repetition. Slightly over-concise given the tool has four parameters, but appropriate for a simple creation operation.

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

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

The description is adequate for a basic create tool: it names the action and the follow-up operation. However, there is no output schema and no mention of what the call returns or any prerequisite behavior. The workflow hint partially compensates, but an agent might still wonder about response format or required account context.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds no parameter-specific meaning beyond the generic 'curated list' notion. Baseline 3 applies 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 states a specific verb and resource: 'Create a curated list.' It clearly separates itself from add_to_list by pointing to that sibling for the next step, making the tool's role in the list workflow unambiguous. It does not explicitly differentiate from other list tools like get_lists or delete_list, but the primary purpose is clear.

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 a workflow: create a list first, then use add_to_list to populate it. That gives some usage context, but it never states when to choose this tool over alternatives or provides any exclusions. It's an implied usage rather than an explicit guideline.

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 destructiveHint=true and readOnlyHint=false. The description adds useful side-effect context beyond that: accounts on the list are not affected. It also states the confirm requirement, reinforcing that this is a destructive action requiring explicit confirmation.

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

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

Three short sentences, each earning its place: the action, the side-effect scope, and the confirmation requirement. No filler or redundant elaboration.

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 delete operation, the description plus rich schema and annotations cover everything needed to call it correctly: what is deleted, what is not affected, and that confirm must be true. The absence of an output schema is not a meaningful gap for agent invocation here.

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 documents account and confirm thoroughly, and the tool description mentions 'Needs confirm: true.' The id parameter is not described in the schema, but its meaning as the list identifier is obvious from the tool name and description. Schema coverage is 67%, so this modest description meets the baseline without adding much new parameter detail.

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 ('Delete a list') and immediately clarifies scope: 'The accounts on it are not affected, only the list.' This distinguishes it clearly from sibling tools like remove_from_list, which remove an account from a list rather than deleting the list itself.

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 this tool applies: deleting an entire list while leaving its member accounts untouched. It does not explicitly name alternatives or say 'use remove_from_list instead', but the exclusion of account effects makes the intended usage clear enough.

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?

Although destructiveHint and readOnlyHint already flag mutation, the description adds irreversible consequences and exactly what is lost: boosts, replies, and favourites. It also states the explicit confirmation requirement, providing useful behavioral 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?

Four short sentences are front-loaded with purpose, then side effects, alternative, and confirmation requirement. There is no filler or repetition of schema details, so 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 destructive mutation with no output schema, the description covers what the tool does, what the id must refer to, the irreversible side effects, the preferred alternative, and the required confirm flag. An agent has enough information to invoke it correctly and safely.

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

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

With 67% schema coverage, `id` lacks a schema description, and the description fills part of that gap by saying the target must be one of the caller's own statuses. `account` and `confirm` are already well documented in the schema, so the description only needs to reinforce rather than re-explain them.

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

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

The description opens with a specific verb and resource: 'Delete one of your own statuses.' It clearly scopes the operation to the caller's own statuses and distinguishes the tool from edit_status, the main sibling that could be confused with it.

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 the alternative for the common use case: 'To fix a mistake, prefer edit_status, which keeps all of that.' This tells an agent when not to use delete_status and which sibling to call 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?

The description says 'Remove' and 'This is not undoable,' both implying permanent deletion of a resource. The destructiveHint annotation is false, which signals a non-destructive operation. This is a direct safety-signal contradiction, so the description fails the behavioral transparency check.

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

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

Two compact sentences with no filler. The operation is stated first, followed immediately by the important irreversibility warning.

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 dismiss action, the core effect and irreversibility are present, but the description does not clarify what id should contain or what happens on repeated dismissal, especially with idempotentHint false. The conflicting destructiveHint annotation further undermines 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?

Schema description coverage is only 50%: account is documented in the schema, but the required id has no description and the tool description never states that id is the notification to dismiss. The description adds no parameter-level meaning 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 ('Remove') with a specific resource ('a single notification from the list'). The word 'single' distinguishes it from clear_notifications, and the focus on one notification clearly separates it from read-oriented notification 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 clearly indicates this tool is for dismissing one notification at a time, giving an agent a direct condition for use. It does not explicitly name clear_notifications as the alternative for bulk removal, so it stops short of full 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?

The description discloses meaningful behavioral context beyond the annotations: Mastodon keeps a public revision history, the post retains boosts/replies/favourites, and the edit is public the moment it runs so confirm is required. This complements the destructiveHint and readOnlyHint 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?

Four concise, front-loaded sentences deliver the action, rationale, prerequisite, and safety requirement with no filler. Every sentence earns its place in the description.

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 destructive mutation with 8 parameters and no output schema, the description covers the core workflow, prerequisite, and public-feedback consequence. It does not describe return values or rate limits, but those are not essential for this tool given the schema's parameter coverage.

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 75%, so the schema already documents most parameters. The description adds little parameter-specific meaning beyond mentioning the editable fields and the confirm requirement; it does not compensate for the undocumented language and sensitive 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 opens with a specific verb and resource ('Change the text, content warning, media alt text or poll of a status that is already published'), which unambiguously identifies the operation. It also distinguishes editing from delete-and-repost, making the tool's purpose clear even among many sibling 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?

The description explicitly frames when this tool is appropriate ('editing beats delete-and-repost') and gives a concrete prerequisite ('Call get_status_source first to get the exact text you are editing'). It does not explicitly enumerate when not to use it, so it stops short of fully explicit 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 convey idempotentHint=true, readOnlyHint=false, and destructiveHint=false, but the description adds no behavioral context beyond repeating the action. It does not mention side effects, error conditions, or account-actor behavior, though it does not contradict 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 extremely short, but the single sentence merely repeats the title and therefore provides no informative content. This is under-specification rather than effective conciseness, unlike a terse but informative summary.

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

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

For a simple mutating tool with no output schema, the description should at least clarify what happens when the status is favourited or what is returned. It does neither. The agent must rely entirely on the schema and annotations, which leaves meaningful gaps around expected outcomes and edge cases.

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

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

Schema description coverage is 100% and both parameters (id and account) already have meaningful descriptions, so the baseline is 3. The tool description itself adds no parameter-level meaning, but the schema carries the load adequately.

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 'Favourite a status.' is a verbatim restatement of the title, so it is a tautology rather than an independent explanation. It names the resource and action but does nothing to distinguish it from close siblings like bookmark_status or unfavourite_status.

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

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

No guidance is given about when to use this tool versus alternatives such as bookmark_status or unfavourite_status. There are no exclusions, prerequisites, or contextual cues to help an agent decide between similar status-affecting tools.

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 cover the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=true), so the description only needs to add context beyond them. It does exactly that by disclosing that locked accounts trigger a follow request instead of a direct follow, which is a meaningful behavioral edge case not otherwise expressed in the schema.

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

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

Two short sentences with no filler. The first sentence states the core action plainly, and the second front-loads an important edge case. Minor redundancy with the title exists, but nothing wasteful.

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 mutating tool, the description plus the rich schema parameter descriptions and annotations cover the main behavior and the key locked-account edge case. There is no output schema and no return-value detail, but that is a minor gap for a follow action and does not prevent 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 the parameter descriptions already explain acct formats, notify semantics, account selection, and the reblogs default. The tool description adds no parameter-specific detail, so the baseline 3 applies.

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

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

The description states a specific verb and resource ('Follow an account') and adds an important conditional: locked accounts receive a follow request instead. The noun 'account' clearly separates it from sibling tools like follow_hashtag and from account-modifying tools such as block_account or mute_account.

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

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

There is no explicit when-to-use guidance, exclusion criteria, or mention of alternative tools such as follow_hashtag or answer_follow_request. The locked-account note describes behavior, not selection context, so the agent must infer usage purely from the tool name and title.

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 this is a non-read-only, idempotent write, and the description adds the meaningful effect on the home timeline. It does not cover auth requirements or any side-effect caveats, but the annotation context lowers the burden on the description.

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

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

Two tight sentences, front-loaded with the action and its effect. There is no filler, no repetition of schema details, and 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 simple mutation with one required parameter, complete schema descriptions, and rich annotations, the description is sufficient for an agent to invoke the tool correctly. It does not describe the response shape, but there is no output schema and that is not needed to decide to call 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?

Input schema coverage is 100%, and the schema already documents account resolution and that the hashtag may include a leading #. The description adds no parameter-level meaning beyond what the schema provides, so the baseline applies.

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

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

States an explicit action and its consequence: following a hashtag routes every public post carrying it into the home timeline. It also positions the tool as 'the main way to build a feed on Mastodon,' distinguishing it from read-only alternatives like get_hashtag_timeline and from unfollow_hashtag.

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

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

Gives a clear use case ('the main way to build a feed on Mastodon') plus a concrete behavioral effect, so an agent can tell when following a hashtag is the right operation. It does not explicitly discuss when to use a hashtag timeline or unfollow instead, but the context is unambiguous enough.

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, openWorldHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds valuable behavior context: it explicitly accepts multiple account identifier formats and resolves accounts the instance has never seen, which informs the agent about potential network/remote resolution and return completeness. 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?

Three sentences each earn their place: the first summarizes the return contents, the second specifies accepted input formats, and the third highlights the remote-resolution behavior. The most critical information (what the tool returns) is front-loaded, with no fluff 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 read-only tool with two parameters, the description is complete: it states what is returned, what inputs are accepted, and how unknown accounts are handled. The output schema is absent, but the description lists the key result fields sufficiently for an agent to understand the return value. No critical 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?

Although the schema has only 50% description coverage (the required 'acct' parameter lacks a schema description), the description compensates by clearly stating that the tool accepts '@user@instance', a bare local username, or a numeric id. This directly maps to the 'acct' parameter and provides the format information the schema omits. The 'account' parameter is already described in the schema, so the description adds meaning beyond it.

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') with a clear resource ('full profile for any account') and enumerates what is included (bio, counts, metadata fields, verification state, mutual follow status). It clearly distinguishes itself from sibling tools like get_account_statuses or get_relationships by focusing on the complete profile object.

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

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

The description implies when to use it: whenever a full account profile is needed, regardless of whether the account is known to the instance. It does not explicitly mention alternatives or exclusions, but the context is clear from the enumerated content and the note about resolving unseen accounts. This meets the 'clear context, no exclusions' level.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the ordering behavior ('newest first') and a tip about reply filtering, which is useful but not extensive. It does not mention pagination mechanics, default limits, or authentication requirements, though these are partly in the schema. No contradiction with annotations.

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

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

The description is two sentences, with the core purpose front-loaded. The second sentence adds a practical tip without excess. It is appropriately concise and well-structured, though it could arguably be expanded slightly with pagination behavior or a mention of the 'account' parameter's default.

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

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

For a read-only list tool with 10 parameters fully described in the schema, the description covers the essential context: what it returns (account statuses) and ordering. It does not explain the return format, but no output schema exists. The automatic pagination and parameter defaults are in the schema, so the description is adequate given the annotations and schema richness.

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 10 parameters. The description adds minimal semantic value beyond the schema: it highlights 'exclude_replies' with a use case and notes 'newest first' (not a parameter but ordering). This is a marginal enhancement over the baseline 3 for full schema coverage.

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

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

The description states the core function clearly: 'Statuses by one account, newest first.' This specifies the verb (get statuses), the resource (one account), and the ordering. It distinguishes from get_account (account details) and timeline tools by focusing on a single account's posts, though it does not explicitly name those 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 gives a specific usage tip: 'Use exclude_replies when studying how someone writes, so replies do not dominate the sample.' This provides context for when to use a parameter, but it does not explicitly state when to choose this tool over alternatives like get_home_timeline or get_account. It implies the use case of examining an account's own posts but lacks exclusions or 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 declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds useful domain context about what announcements contain but does not disclose additional behavioral traits such as pagination, ordering, or handling of already-dismissed announcements beyond what the schema parameter hints.

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

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

Two short sentences, both earning their place: the first defines the resource, the second gives the practical trigger for use. No filler or redundancy, and the most essential information is front-loaded.

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

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

For a simple read-only tool with zero required parameters, a well-documented schema, and safety annotations, the description covers intent and appropriate use. It does not describe the return shape or pagination, but given the low complexity and lack of required inputs, the available context is sufficient for an agent to invoke 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%, so both parameters (account and include_read) are already documented in the schema. The tool description adds no parameter-specific meaning beyond that, 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 clearly identifies the resource ('Announcements from the people who run your instance') and the concrete content types (downtime, rule changes, moderation decisions). It is specific about the verb-resource pairing, though it does not explicitly contrast with sibling tools like get_instance_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?

The phrase 'Worth checking when something stops working' gives a clear, concrete trigger for when an agent should call this tool. It does not mention exclusions or name alternatives, but the usage context is more specific than the bare verb-plus-resource pattern seen in many sibling definitions.

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 communicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds no behavioral context beyond that: no mention of pagination behavior, sorting, rate limits, or what exactly is returned. It merely restates the subject matter.

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 short with no wasted words and the core scope is front-loaded. It is a fragment rather than a complete sentence, but given the tool's simplicity, the brevity is mostly appropriate.

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 schema and annotations cover parameters and safety, and the title conveys the operation. However, there is no output schema and the description does not explain what the return value looks like (e.g., a list of domain strings) or how pagination works beyond the max_id hint, leaving minor ambiguity for a listing tool.

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

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

Schema description coverage is 100%, so limit, max_id, and account are already fully documented with clear meanings. The description contributes no additional parameter-level nuance, so it sits at the baseline for tools with complete 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 title provides a clear verb+resource: 'List instances you have blocked.' The description reinforces the scope with 'Whole instances,' which distinguishes this from per-account or per-user block tools like get_blocks. However, the description itself is a fragment without an explicit verb and does not name any sibling 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?

There is no guidance on when to use this tool versus alternatives such as get_blocks, block_domain, or unblock_domain. The description gives no context about typical use cases, prerequisites, or exclusions, leaving the agent to infer entirely from the name and 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, idempotentHint, and destructiveHint=false, so the safety profile is covered structurally. The description itself adds no behavioral context beyond what the annotations and schema provide, such as pagination behavior or the shape of returned data.

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

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

The description is short and free of fluff, but it is essentially a repeat of the title 'Accounts you have blocked' and therefore does not earn much of its place. It is concise without being substantively useful.

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 no output schema and a minimal description, an agent lacks context about the return shape and about how this endpoint differs from adjacent list tools like get_mutes and get_blocked_domains. The schema and annotations cover parameters and safety, but not the selection context an agent needs when choosing among similar siblings.

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

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

Schema description coverage is 100%, and each parameter (limit, max_id, account) already has a meaningful description including defaults, pagination behavior, and account matching semantics. The tool description adds no parameter-level meaning, so it correctly stays at the baseline of 3.

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

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

The description clearly identifies the resource as blocked accounts, which is immediately understandable and separates it from follower, mute, endorsement, and blocked-domain list tools. It is a noun phrase rather than an explicit verb+resource statement, but the purpose is not vague. It does not explicitly name sibling tools, so it stops short of a 5.

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

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

The description gives no guidance on when to use get_blocks versus related sibling tools such as get_mutes, get_blocked_domains, or get_endorsements. There is no 'use this when...' or 'use X instead for...' context, so an agent must infer the usage entirely from the tool name.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, so the safety profile is fully covered. The description adds that bookmarks are private, which is useful conceptual context but not a distinct behavioral characteristic such as pagination, ordering, or authentication requirements.

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

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

The description is a single sentence that front-loads the core purpose and immediately adds the privacy distinction. Every word earns its place; no filler or redundant restatement 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?

For a simple read-only list tool with two fully documented parameters and robust safety annotations, nothing an agent needs to call it correctly is missing. The privacy caveat closes the main conceptual gap versus favourites, and the schema handles all operational details.

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%. Both params, limit and account, already have rich descriptions including defaults, bounds, matching rules, and fallback behavior. The tool description adds no parameter-specific 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 clear verb-resource pair: 'Statuses a connected account has bookmarked.' It also distinguishes itself from the sibling get_favourites by noting bookmarks are private, which is the key differentiator among the similarly named 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?

The description gives clear context for when to use this tool — listing statuses bookmarked by a connected account — and explicitly contrasts with favourites. It does not name the sibling tool get_favourites directly, but the 'unlike favourites' comparison effectively routes the agent away from the most likely alternative.

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

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

Annotations already cover read-only, open-world, and idempotent behavior; the description's 'as far as your instance knows' mostly restates the openWorldHint rather than adding new behavioral context. No contradiction.

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

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

One sentence that front-loads the result ('accounts that boosted a status') and appends the key open-world caveat. No filler.

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

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

For a simple read-only list operation, the definition is complete: the required status id is inferable, limit and account are schema-documented, and no output schema is needed to understand an account list. It could mention response shape or pagination, but this is not a major gap.

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

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

The schema documents limit and account well, and the description's 'a status' makes the required id refer to a status ID. Still, the description itself adds no parameter detail beyond the schema, and the undocumented required id is only implicit.

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 exactly what the tool returns: 'the accounts that boosted a status', and the title mirrors it. It doesn't name the sibling get_favourited_by, so it lacks explicit differentiation, but the operation is 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?

No guidance is given about when to call this instead of get_favourited_by or get_status_history. 'As far as your instance knows' hints at a limitation but not a decision rule.

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 readOnly, idempotent, and non-destructive behavior. The description adds valuable context beyond those annotations: it reveals the privacy model ('anyone mentioned in one can see it') and the ordering behavior ('newest first'). This helps an agent understand side effects and visibility 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 first sentence is front-loaded with the core behavior, and the second explains a key Mastodon-specific nuance. The third sentence about existing MCP servers is not directly actionable for invoking the tool, but it is brief and does not significantly bloat the description. Overall it is tight and well ordered.

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

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

With no output schema, the description reasonably summarizes the return shape ('participants and last message') but leaves out response envelope, pagination behavior, and exact field structure. The two parameters are fully described in the schema, so the main gap is response detail. This is adequate but not fully complete.

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

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

Schema description coverage is 100%, so both 'limit' and 'account' are already well documented by the input schema. The tool description adds no additional parameter-level explanation, which is acceptable given the schema's completeness. Baseline 3 is appropriate here.

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 resource ('Direct conversations') and states exactly what is returned: 'newest first, each with its participants and last message.' It also clarifies that Mastodon direct messages are statuses with visibility 'direct', which helps distinguish this from standard timeline tools. This is a clear, actionable purpose statement.

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

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

The description gives useful context about how Mastodon models direct messages, implying when this tool is relevant. However, it does not explicitly say when to prefer this over alternatives like get_home_timeline or mute_conversation, and it offers no exclusionary guidance. The usage intent is clear but largely inferred.

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, idempotentHint, openWorldHint, and destructiveHint=false, covering the safety profile. The description adds no behavioral detail beyond the resource's meaning, such as pagination behavior or auth requirements, but nothing it states conflicts 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 a single, efficient noun phrase with no filler words. However, it duplicates the title exactly, so it earns no extra credit for providing unique information and lacks a front-loaded action verb.

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 read-only list with documented parameters, the description is minimally sufficient. It does not describe the output shape or item fields, and with no output schema an agent would have to infer the return format from the name and title.

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

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

Schema description coverage is 100%, so limit, max_id, and account are fully explained in the schema, including defaults, constraints, and continuation semantics. The description adds no parameter-level information, so the baseline score 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 names the exact resource ('accounts you feature on your own profile') and the tool name 'get_endorsements' maps directly to it. It is specific enough to distinguish from siblings like get_followers or get_following, though it lacks an explicit verb such as 'list' and repeats the title verbatim.

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

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

There is no guidance on when to call this tool rather than the many sibling get_* tools, no stated exclusions, and no mention of common use cases such as retrieving the profile's featured endorsements. An agent must infer the context entirely from the name and title.

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, idempotentHint, openWorldHint, and destructiveHint. The description adds valuable context about federation: the result is limited to the local instance's knowledge, which directly explains the openWorldHint and is critical for setting expectations. This goes beyond the structured annotations and enhances behavioral understanding.

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 short sentences, with the core entity stated first and the federation caveat as a supplementary clause. It is efficient and front-loaded, though the first sentence is a noun phrase without a verb. Still, it earns high marks for brevity and 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?

The tool lacks an output schema, so the description must explain what is returned; it does state 'accounts that favourited a status', which is a reasonable high-level return. However, it does not mention the required 'id' parameter, nor does it describe pagination or any response structure. The federation context helps, but gaps remain for a straightforward API call.

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

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

The description does not mention any parameter, and only two of three parameters have schema descriptions (limit and account). The required 'id' parameter lacks both schema description and any clue in the description about identifying the status. Schema coverage at 67% is partial, and the description fails to compensate for the missing id 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 identifies the resource: accounts that favourited a status. The title 'See who favourited a status' reinforces the action, and the federation caveat distinguishes this from a universal list. It is specific enough to separate from siblings like get_boosted_by, though it lacks an explicit verb in the main sentence.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It mentions federation's limitation but does not state when it should be chosen over get_boosted_by or get_favourites. No exclusions or context signals are given, leaving the agent to infer usage from the name and title.

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, openWorldHint, idempotentHint, and destructiveHint false, covering the safety profile. The description adds useful behavioral context beyond this: results are ordered newest first and are scoped to a connected account.

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 conveys scope and ordering without any filler. The most relevant information is front-loaded and every word earns its place.

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

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

For a simple list tool with two optional parameters, complete annotation coverage, and no output schema, the description plus schema is sufficient. The return value is implied by 'statuses', ordering is stated, and selection behavior is covered by the schema.

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

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

Schema description coverage is 100%, so the parameters are already fully documented in the schema. The tool description adds no additional parameter-level meaning beyond the schema, matching 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 uses a specific resource ('statuses') and a specific scope ('a connected account has favourited'), plus an ordering qualifier ('newest first'). It clearly distinguishes this from siblings like get_favourited_by (who favourited a status) and get_bookmarks (bookmarked statuses).

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

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

The description implies when to use the tool: when you need a connected account's favourited statuses. However, it offers no explicit when-not-to-use guidance or comparison with alternatives such as get_bookmarks or get_account_statuses.

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 it read-only, open-world, idempotent, and non-destructive. The description adds useful behavioral context beyond that: it is large and unfiltered, which warns the agent about potential volume and noise. It does not describe ordering or pagination details, but those are partially covered by the parameter descriptions.

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

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

Two short sentences, zero filler, with the core resource definition first and practical usage direction second. 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 read-only timeline tool, the combination of the description, full parameter documentation, and safety annotations is complete. The description conveys the semantic scope and noise level, and the schema covers filtering, pagination, and account selection, so an agent has everything needed to invoke 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 coverage is 100%, and each of the six optional parameters has a rich description covering defaults, pagination, account matching, and filters. The tool description itself adds no parameter-level detail, so a baseline score 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/resource: reading the federated timeline, defined as public content federated from the rest of the network. It also implicitly contrasts with local/home timelines and explicitly differentiates from search and hashtag timelines, so an agent can distinguish it from the many sibling timeline 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?

The description gives explicit when-to-use guidance: use it for broad, unfiltered public content, and use search or a hashtag timeline when looking for something specific. This names concrete alternatives and provides the decision condition.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to repeat safety traits. The description adds useful context about the mechanics of following hashtags but does not disclose return format, pagination, or error behavior. Since annotations cover the core safety profile, the marginal behavioral information is modest, warranting a baseline 3.

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

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

The description is short and front-loaded, starting with the direct statement 'Hashtags you follow.' The contextual explanation about feed-building is relevant but could be trimmed; still, every sentence contributes meaningful background. It is not overlong, earning a solid 4.

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

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

Given the tool's simplicity, the rich annotations, and fully documented parameters, the description is mostly complete. It explains why the tool matters (building a feed without an algorithm) and why it is distinctive. There is no output schema, so not explaining return values is acceptable. Minor gaps like pagination or error conditions are not critical for a read-only list endpoint.

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

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

The input schema provides 100% coverage for the two parameters: limit with constraints and default, and account with matching rules and default. The description adds no additional parameter detail beyond what the schema already documents. Per the calibration baseline, a 3 is appropriate when the schema carries the semantic 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 title 'List hashtags you follow' and description's first phrase 'Hashtags you follow' clearly indicate the tool's function. The description also differentiates it by noting that no existing Mastodon MCP server exposes this, which helps distinguish it from related tools like follow_hashtag or unfollow_hashtag, though the purpose is stated rather than a full imperative sentence.

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 explains the purpose of following hashtags (bringing public posts into the home timeline) but provides no guidance on when to call this tool versus alternatives such as get_hashtag_timeline or search. It does not state any exclusions, prerequisites, or context in which this tool should be preferred, leaving the agent without 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.

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral context beyond that: 'Pages automatically past the 40-per-request ceiling,' which tells the agent that pagination is handled and multiple requests may occur transparently.

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 short sentences with no filler. The core purpose is stated first, and the pagination behavior is added as a second valuable 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 simple read-only listing tool, the description is mostly adequate, especially with annotations covering safety. However, with no output schema, it does not describe the return shape or ordering, and it does not distinguish itself from get_following or explain the required acct parameter. The schema partially compensates, but the description alone leaves some gaps.

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

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

The schema already documents 75% of the parameters with descriptions for limit, max_id, and account. The tool description adds no parameter-specific meaning beyond the schema. The required acct parameter remains undocumented in both description and schema, but the high schema coverage keeps this at 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 clearly identifies the resource: accounts that follow a given account. The title adds 'List', making the operation unambiguous. It is implicitly distinguishable from get_following (which lists accounts a given account follows), but it does not explicitly name the sibling or use a strong verb like 'returns' or 'lists'.

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

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

The description gives no guidance on when to use this tool versus siblings like get_following, get_account, or get_relationships. It provides no when-to-use, when-not-to-use, or 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?

The description adds 'Pages automatically,' a useful behavioral detail beyond the annotations' readOnly/openWorld/idempotent hints. It does not contradict annotations, and for a simple read-only listing tool the pagination note provides meaningful 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?

Two short sentences with no filler; the core behavior is stated first and the pagination behavior follows. The description is efficiently sized for a simple list tool.

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

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

For a read-only list operation, the description, schema, and annotations together cover the essential behavior, parameters, and safety profile. The lack of an output schema is acceptable because the return type ('accounts') is implied.

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 75%: limit, max_id, and account already have descriptions. The phrase 'given account' clarifies that acct is the target account, but the description does not add format or default details beyond the schema. This meets 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 names the resource ('accounts a given account follows') and the title supplies the verb 'List', making the purpose clear. It is distinguishable from the sibling get_followers because it targets accounts the given account follows rather than followers.

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?

'Accounts a given account follows' implies the tool is for retrieving another account's follow list, but it gives no explicit guidance about when to prefer it over alternatives like get_followers or get_suggested_follows. 'Pages automatically' hints at handling paginated results but not when or how to request subsequent pages.

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, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds the useful locked-account context, but does not disclose details like return shape or edge cases. With annotations carrying most of the behavioral burden, this is adequate but not rich.

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

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

Two short sentences with no filler. The first sentence defines the output concept, and the second adds an important scope restriction. 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 read-only list operation with fully documented optional parameters, the description is mostly complete: it conveys what is returned and the locked-account condition. A minor gap is not pointing to the related approve action, but the schema and annotations cover 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?

Schema description coverage is 100%, and limit, max_id, and account each have clear descriptions. The tool description contributes no additional parameter-level meaning, 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 title 'List pending follow requests' and description 'Accounts waiting for you to approve their follow' clearly identify the resource and the action. It implicitly distinguishes itself from get_followers and answer_follow_request by focusing on pending approval, though it does not explicitly contrast a sibling tool.

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

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

The description gives one useful condition: 'Only meaningful on a locked account,' which is a clear prerequisite. However, it does not explain when to use this tool instead of related tools like answer_follow_request or get_followers, leaving alternatives to inference.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds valuable context by specifying 'Public statuses' (excluding non-public ones) and explaining that hashtags serve as the primary discovery mechanism, which goes beyond what annotations state and helps the agent understand the tool's role.

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 only two sentences, with the core action stated upfront and the contextual rationale following. Every sentence earns its place, no redundancy, and it's well-structured for quick parsing.

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

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

For a read-only tool with a rich schema and no output schema, the description adequately covers what the tool does and why it matters. It doesn't explain return formats or pagination details, but those are handled by the schema and annotations, so the description is sufficient for an agent to decide when to call 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 input schema provides 100% coverage with descriptions for all 9 parameters, including filtering options (all, any, none), pagination (limit, max_id), and account selection. The description adds no additional parameter-specific meaning, so it relies entirely on the schema, warranting the baseline score of 3.

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

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

The description clearly states the tool returns public statuses carrying a specific hashtag, with a concrete verb and resource. It distinguishes hashtag-based timelines from other timeline tools by its subject matter, but does not explicitly name sibling alternatives like get_home_timeline or get_local_timeline, so it stops short of a 5.

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

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

The description implies usage for discovering conversations around a hashtag, noting it's 'the main way to find a conversation' on Mastodon. However, it provides no explicit when-to-use vs alternatives, no exclusions, and no mention of cases where other timeline tools would be more appropriate, leaving usage guidance mostly implicit.

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 cover read-only, idempotent, and non-destructive behavior. The description adds useful behavioral details beyond that: newest-first ordering, the feed scope, and the since_hours time-window mode versus fixed-count mode.

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 lead with the core purpose and then add the one non-obvious usage nuance. There is 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 read-only timeline retrieval tool, the description plus fully covered schema provides all needed semantics: feed scope, ordering, pagination parameters, account selection, and the special time-window behavior. No output schema is needed because the return type is implied by 'statuses'.

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 limit, max_id, account, and since_hours. The description adds only a slight rephrasing of since_hours as a time-window alternative, providing minimal extra value.

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 operation and resource: reading statuses from accounts and hashtags you follow, ordered newest first. This clearly distinguishes the home timeline from siblings like get_local_timeline, get_federated_timeline, and get_hashtag_timeline.

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

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

The phrase 'accounts and hashtags you follow' gives clear context that this is the personalized home feed rather than public or list-based timelines. However, it does not explicitly name alternative tools or state when-not-to-use 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?

The annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds context about the range of possible character limits and the nature of the data returned, which is beyond the annotations. It 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 two sentences, front-loaded with the key purpose, and includes a practical tip. Every sentence earns its place without extraneous 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?

The tool is simple (one optional parameter) with rich annotations covering safety and idempotency. The description explains what data will be returned, fulfilling the agent's need to know what to expect. No output schema exists, but the description sufficiently enumerates the content. A minor gap is the lack of a note about account selection behavior, but the schema addresses that.

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

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

Schema description coverage is 100%, so the account parameter is fully documented in the schema. The description does not add parameter-specific details, but since the schema covers it, a 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 clearly states the tool reads the instance's rules and limits, enumerates specific data points (character limit, attachments, poll options, media size, software version, server rules), and distinguishes it from siblings by its focus on instance configuration rather than timelines or statuses.

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 advises reading it before drafting anything long, given the variable character limit. While it doesn't name alternative tools, it provides clear usage context that an agent can act on. No exclusion criteria are stated, but the use case is specific enough.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, fully covering safety. The description adds no behavioral context beyond what annotations provide—no pagination details, no mention of default limit, no notes on list ownership or authorization. With annotations carrying the safety profile, the description contributes nothing extra, warranting a score below 3.

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

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

The description is a single concise sentence with no fluff. It is appropriately sized for a simple read operation, though it could be more action-oriented. The structure is clean and front-loaded with the resource being described.

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 read-only tool with annotations and a partial schema, the description minimally conveys the return value (accounts on a list). However, it lacks context about the required id parameter, any default behavior, or how this relates to list management. Given the simplicity, the missing details are not critical but still noticeable; a more complete description would mention the need for a list ID.

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 67%, with limit and account having inline descriptions, but id is undocumented. The description text itself does not elaborate on any parameters. The id parameter's semantics are predictable from context (list ID), but the description does not compensate for that gap. Since the schema covers most parameters adequately, a 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 'The accounts on one of your lists.' is a noun phrase that states the resource but lacks an explicit verb like 'get' or 'list'. It is clear enough from the tool name and title, but the description alone does not convey the action. It does distinguish from sibling tools like get_list_timeline by focusing on accounts, but without explicit action language.

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

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

The description provides no guidance on when to use this tool versus alternatives, no mention of prerequisites (e.g., needing an existing list ID), and no exclusion criteria. Sibling tools like get_lists or get_list_timeline are not referenced, so the agent must infer the intended use from the name alone.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. However, the description adds no behavioral context about what the tool returns, whether it supports pagination, or how it handles multiple accounts. The description is essentially a restatement of the title without deeper behavior.

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

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

The description is short but not well-structured. 'Your curated lists.' is vague and uninformative as an opening. The second sentence primarily describes get_list_timeline, which is off-topic for get_lists. The content would be better used as documentation for sibling tools.

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 a single optional parameter and no output schema, the description is still inadequate. It fails to state what the returned data will look like or how to interpret the lists. The reference to get_list_timeline helps a little, but the core function of get_lists is never clearly explained.

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 description coverage is 100%, and the single 'account' parameter is fully documented in the schema with explanation and defaults. The description adds no extra parameter semantics, which is acceptable given the 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 'Your curated lists.' is a noun phrase rather than a clear verb-resource statement. It never explicitly says 'get' or 'list' the user's lists, leaving the action implicit. The only actionable hint is redirecting to get_list_timeline, which describes a different tool.

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

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

The description gives no explicit guidance on when to call get_lists itself. It only mentions that a list id can be passed to get_list_timeline, which is related but does not clarify the purpose or alternatives for listing lists. No when-to-use or when-not-to-use criteria are provided.

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, idempotentHint, and destructiveHint, so the description only adds the scope that it returns statuses from accounts on the user's lists and where to obtain list IDs. This is useful context but not rich behavioral detail beyond what annotations and schema already 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 two sentences, front-loading the core purpose and immediately pointing to get_lists for the required list_id. No unnecessary words; each 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 read-only timeline tool with full schema descriptions and annotations, the description is sufficient: it explains what it returns, where to find the required list_id, and the schema covers all parameters and pagination details. It lacks explicit authentication notes but that is implicit across the toolset.

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

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

Schema description coverage is 100%, so all five parameters are documented in the schema. The tool description does not add any additional parameter semantics beyond the schema, matching the baseline for full schema coverage.

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

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

The description clearly states the resource (a list's timeline) and the action (retrieve statuses), and explicitly distinguishes it from other timeline tools by referencing 'one of your lists' and pointing to get_lists for list IDs. This separates it from siblings like get_home_timeline or get_local_timeline.

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

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

The description implies usage context by noting it's for lists you own and provides a prerequisite (find list IDs with get_lists), but it does not explicitly state when to use this tool versus alternatives like get_home_timeline or get_hashtag_timeline. 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 cover safety (readOnlyHint, idempotentHint, destructiveHint false). The description adds behavioral context beyond those: content is public, scoped to the local instance, and can be a high-volume 'firehose' on large instances, which is useful for expecting large result sets.

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 only two sentences and front-loads the core definition. The second sentence adds useful usage context, though the subjective 'most useful timeline there is' is slightly less precise than a more objective condition would be.

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 timeline tool with robust annotations and fully documented parameters, the description plus input schema is sufficient. It establishes scope, content type, and scale. It doesn't explicitly describe the response shape, but the name and schema's pagination references make the return type reasonably clear.

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 every parameter already has a meaningful description. The tool description adds no additional parameter-level semantics, so the baseline score 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 clearly defines the resource and scope: 'Everything public posted by accounts on your own instance.' This distinguishes it from the federated timeline (other instances) and the home timeline (followed accounts), while the tool name and title provide the read/get verb.

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 useful context ('On a small themed instance this is the most useful timeline there is; on mastodon.social it is a firehose') that implies when it is appropriate, but it does not explicitly name alternatives like get_federated_timeline or get_home_timeline or state when not to use 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the core safety profile is covered. However, the description adds no additional behavioral context: it does not mention pagination, ordering, result format, or that the list may change as new mutes are added. No value is added beyond the structured 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 terse clause with no filler, and it is front-loaded. It is efficient in length, though it borders on under-specification because it provides almost no operational detail beyond 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?

For a simple read-only paginated list, the schema and annotations cover a fair amount of context. However, there is no output schema, and the description does not clarify expected return shape, ordering, or that it refers specifically to account mutes rather than conversation mutes. It is adequate but has clear gaps.

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

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

Schema description coverage is 100%, and all three parameters (limit, max_id, account) have useful schema descriptions. The tool description itself contributes no parameter-level meaning, so the high schema coverage carries the load and the baseline score 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 is essentially the title restated as a noun phrase: 'Accounts you have muted.' It identifies the resource clearly but uses no verb and does not differentiate from sibling list tools like get_blocks or from mute_account. It is understandable, but it adds little beyond what the tool name and title already imply.

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

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

There is no guidance on when to use this tool versus alternatives such as get_blocks, mute_account, or get_conversations. The description names no context, no exclusions, and no conditions that would help an agent choose between this and related tools.

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 disclose the safety profile: read-only, idempotent, non-destructive, open-world. The description adds useful context about the content domain and the actionable meaning of mention, but it does not describe pagination, ordering, or response structure. There is 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?

Two tight sentences: the first defines scope, the second gives high-value selection guidance. Nothing is wasted, and the actionable filtering tip is front-loaded for practical use.

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

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

For a read-only list tool with a well-described schema and strong annotations, the description is sufficiently complete: it states what notifications are included and how to filter. It could mention admin notification types or response ordering, but the schema's enum and pagination fields compensate.

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

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

The input schema already documents all six parameters at 100% coverage, so the baseline is 3. The description adds value by framing the types parameter as a way to isolate notifications needing answers and by explaining that 'mention' is the actionable case, which helps the agent choose parameter values intentionally.

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 enumerates the notification kinds returned—mentions, boosts, favourites, follows, poll results, and edits—making the resource clear without being a pure tautology. Combined with the title 'Read notifications,' an agent can tell this is a read/list operation, though it doesn't explicitly state a verb like 'list' or 'fetch.'

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 practical usage guidance: filter by type to get only actionable notifications, and specifically treat 'mention' as the item a human must deal with. It does not explicitly compare against siblings like dismiss_notification, clear_notifications, or get_read_position, so the agent has to infer when this read tool is preferred.

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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds valuable context beyond annotations: the read position is shared across every client on the account, and the returned id is a meaningful opaque token for incremental fetching. This enriches understanding without contradicting the hints.

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

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

The description is two sentences with no wasted words. The first sentence defines the resource and its scope, the second gives actionable guidance on using the result. Information is front-loaded and 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 simple read-only tool with one optional parameter and rich annotations, the description is complete. It explains what the return value represents, how it behaves across clients, and how to use it in downstream calls. There is no output schema, but the description sufficiently conveys the value's purpose. Missing edge cases (e.g., no read position yet) are minor given the tool's simplicity.

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 'account' has full description coverage in the schema (100%), including its matching behavior and default. The description itself adds no parameter-specific details, but the baseline of 3 applies because the schema fully documents 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 clearly states a specific verb ('check how far you have read' from the title) and resource ('last notification and home-timeline entry you marked read'), and explicitly distinguishes its output's purpose ('Pass the returned id as since_id'). This differentiates it from siblings like mark_read or get_home_timeline.

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

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

The description provides explicit instructions on how to use the returned value ('Pass the returned id as since_id to fetch only what is new'), giving clear practical guidance. However, it does not explicitly state when to use this versus alternatives (e.g., mark_read for setting the position), though the usage is strongly implied.

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

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

Annotations already provide readOnlyHint and idempotentHint, so the safety profile is covered. The description adds meaningful behavioral detail: it is a batch call and reports reciprocal mute/block state, which the schema and 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?

Two sentences with distinct jobs: the first defines the output semantics, the second gives usage context. There is no redundant restatement of the title or 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?

Even without an output schema, the first sentence tells the caller what relationship data will be returned. The description plus annotations and schema cover the necessary safety, batching, and parameter context, though it does not spell out the exact response field names.

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 describes the optional 'account' parameter well, and the description supplies the missing semantics for the required 'accts' parameter by referring to 'each account named' and 'a whole list.' It does not fully formalize the items, but the combination is adequate.

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 identifies the operation: for each named account, it checks follow status in both directions and mutual mute/block status. This distinguishes it from siblings like get_account and get_followers by emphasizing batch relationship checks.

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 to use this before a bulk follow or unfollow and contrasts it with the slower per-profile approach. It does not name a specific sibling for single-account use, but the guidance is concrete enough for an agent to select it appropriately.

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, idempotentHint=true, and destructiveHint=false, so no extra safety disclosure is needed. The description adds useful behavioral context beyond the schema by specifying that media, poll, link preview, and engagement counts are included in the result, which is valuable since there is no output schema.

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 conveys the core purpose and key result contents with zero filler. Every word contributes value, and no unnecessary enumeration or repetition 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 simple read-only fetch with two parameters, one required, the description plus annotations cover the safety profile and the important returned components. The main gap is that it does not mention the optional account parameter or when to supply it, but the schema already provides that information, so the overall package is nearly 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?

The description adds mild meaning to the id parameter by saying the status is fetched 'by id,' but it does not describe the account parameter at all. The account parameter is well documented in the schema, so the description does not need to repeat it, yet with only 50% schema coverage for id the description only partially compensates.

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 — fetching a single status by ID — and distinguishes it from siblings like get_thread (surrounding context), get_status_source (source text), and get_status_history (edit history) by emphasizing a single status with its media, poll, link preview, and engagement counts. The title and resource are clear and not tautological.

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 phrase 'A single status by id' implies the tool is for fetching one known status, which gives some usage context. However, it does not explicitly say when to prefer this over get_thread, get_status_source, or get_status_history, nor does it mention any exclusions or alternatives. Usage 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 indicate readOnlyHint, idempotentHint, openWorldHint, and destructiveHint false. The description adds valuable behavioral detail: it specifies the order (oldest first) and that all published versions are returned, which is not captured by annotations.

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

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

The description is concise and front-loaded, with two sentences that state the core behavior and a key insight about public accessibility. Every word adds value, with 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 simple read-only tool with annotations covering safety, the description provides enough detail for an agent to call it correctly: it explains the output order and the public nature. It does not describe the exact return format, but the absence of an output schema and the simplicity of the operation make this acceptable.

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 describes the 'account' parameter but leaves 'id' undocumented, giving 50% schema coverage. The description does not mention parameters directly, but the tool's name and context make it clear 'id' is a status ID. The description adds minimal value beyond the schema, so a 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 clearly identifies the tool's purpose: retrieving the edit history of a status, ordered oldest first. It distinguishes itself from sibling tools like get_status and get_status_source by focusing specifically on the history of published versions, and the mention that it works for any public post adds scope.

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

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

The description provides clear context by stating that edits are public and the tool works for anyone's post, not just the user's own. This implies appropriate usage for retrieving public edit histories, though it does not explicitly name alternatives or state when not to use the 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 readOnly/idempotent annotations, it discloses that the output is raw typed text plus the content warning, and explains the pitfall of editing HTML-rendered content with rewritten links. It also adds an access constraint by limiting the source to the user's own statuses.

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 wasted words. The core definition is front-loaded and the second sentence earns its place by explaining why this tool is the correct source for edits.

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 read-only tool, the description plus annotations cover safety, the access restriction, the return content, and the most important behavioral pitfall. 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 schema documents 'account' but leaves 'id' bare, and the description never explicitly maps 'id' to a status identifier. With schema description coverage at 50%, the description fails to compensate for the undocumented required 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 specifies the resource ('one of your own statuses'), the exact representation ('plain-text source... exactly as it was typed'), and the extra content ('plus its content warning'). The contrast with rendered HTML clearly marks it as distinct from content-returning siblings like get_status.

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