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

No annotations are provided, so the description carries the full burden. It does disclose two useful behaviors—300-character limit and automatic linking of URLs/@mentions—but does not describe side effects, auth requirements, or what happens after creation. 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?

A single, front-loaded sentence conveys the core action, the limit, and the auto-link behavior without waste. Every phrase earns its place.

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

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

For a simple one-parameter creation tool, the description is largely complete: it states the action, the input constraint, and a key processing behavior. It does not explain return values, but no output schema exists and the lack of usage guidance against siblings is a minor gap.

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

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

Schema description coverage is 100%, so the input schema already documents the 'text' parameter and its maxLength. The description repeats this rather than adding new semantic detail beyond the schema, matching 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?

Description states a clear, specific verb ('Create') and resource ('Bluesky post'), with additional constraints (max 300 chars, auto-linked URLs/@mentions). This distinguishes it from read/delete/like siblings and even from reply_post by specifying 'new' post.

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 on when to use this tool versus alternatives such as reply_post, delete_post, or like_post. The context implies it is for composing a standalone post, but the description never states this or calls out adjacent siblings.

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

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

No annotations are present, so the description has the full burden of disclosing behavioral traits. While 'Delete' signals a destructive action, the description does not state that the deletion is permanent, that the caller must own the post, or that associated interactions (likes/reposts/replies) may be affected. It only restates the operation, adding little beyond the tool name.

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 front-loaded sentence that names the action and target with no filler. It is concise and every word contributes to the meaning.

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 tool with no annotations and no output schema, the description is thin. It correctly identifies the required input but omits important surrounding context such as ownership, irreversibility, and expected result/error behavior, which an agent would need to invoke it safely and correctly.

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

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

The schema already documents the only parameter, 'uri', as 'AT URI of the post to delete' (100% coverage), so the description's mention of 'AT URI' adds no new meaning. The baseline of 3 applies because the schema fully describes 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 uses a specific verb ('Delete') and a clear resource ('Bluesky post'), and identifies the required address ('AT URI'). This is unambiguous and distinct from sibling tools such as create_post, like_post, or get_post, which involve creation, reaction, or reading.

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 defines what the tool does but gives no explicit when-to-use or when-not-to-use guidance, and does not mention the ownership prerequisite (you can only delete your own posts). Among the sibling tools there is no other deletion tool, so the usage context is inferable, but not stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action 'Follow' but does not mention that it is a state-changing operation requiring authentication, nor any side effects or failure modes. This leaves the agent to infer the mutation 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 a single six-word sentence with no filler. It front-loads the action and the target, so it is highly concise.

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

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

For a one-parameter tool with no output schema and no annotations, the description covers the core action and parameter, but it omits behavioral context such as authentication, idempotency, and consequences. This is adequate but leaves 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?

The parameter schema already describes 'handle' fully, including an example, and coverage is 100%. The description's 'by handle' adds no new information 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 uses a specific verb 'Follow' and a specific resource 'Bluesky user', and specifies the target via 'handle'. No sibling tool overlaps with this action, so it is clearly distinguishable.

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, nor any prerequisites or exclusions. The only implicit hint is the action itself, which is not enough to meet the 'when-to-use' bar.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Get' signals a non-destructive read and the parenthetical lists the returned categories, but it does not disclose ordering, the time window for 'recent', pagination behavior, or any 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?

One short sentence that front-loads the action and resource, with a parenthetical that adds useful scope. There is no filler or redundant phrasing.

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 core purpose is clear and the parameter is simple, but with no output schema and no annotations, the description leaves out return shape, ordering, recency bounds, and pagination details. These gaps make it adequate but not fully self-contained.

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 'limit' parameter is already fully documented in the input schema with type, default, minimum, maximum, and a description. The tool description adds no additional meaning beyond what the schema provides, so the 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 ('Get') and a clear resource ('recent notifications'), and enumerates the notification types included. This makes the tool's purpose unmistakable and distinct from the sibling tools, which focus on posts, users, profiles, and timelines.

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 about when to use this tool versus related options like get_timeline, get_user_feed, or search_posts. It also omits any prerequisites such as authentication or context in which notifications are expected to be available.

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

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

With no annotations provided, the description carries the full behavioral burden. It correctly signals a read-only retrieval operation via 'Get', but does not disclose potential error conditions, authentication requirements, rate limits, or the structure of the returned post. It is honest but minimal.

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, front-loaded sentence with no filler words. Every word earns its place, and the essential information (what and how) is immediately visible.

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

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

For a one-parameter read-only tool, the description provides the core information needed to call it correctly. The absence of an output schema is offset by the straightforward meaning of 'get a post,' though details about return format or error behavior would make it 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?

The schema fully documents the only parameter, 'uri', including its type and description. The description's phrase 'by AT URI' simply echoes the schema without adding extra semantic detail, so the baseline of 3 applies.

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

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

The description clearly states the action ('Get'), the resource ('a specific Bluesky post'), and the required identifier ('by AT URI'). This unambiguously distinguishes it from sibling tools like search_posts or get_user_feed, which operate on queries or feeds rather than a single post.

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 'by AT URI' implies the intended use case: call this tool when you already have a post's AT URI and want that specific post. However, there is no explicit when-not-to-use guidance or comparison to alternatives like get_thread, leaving some inference to the agent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get' appropriately conveys a read operation, and the parenthetical reveals a meaningful default behavior. However, it does not mention response contents, error behavior, authentication expectations, or any rate limits, so behavioral transparency is only partially addressed.

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, front-loaded sentence with no fluff. The core action appears first, and the optional-handle nuance is contained in a compact parenthetical. 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 tool with one optional parameter and no output schema, the description is nearly sufficient: it names the operation and explains the only parameter's omission behavior. It does not describe the shape of the returned profile or error conditions, but those are largely inferable from the tool name and domain. Slightly more detail on response or auth context would make it 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%, and the schema already explains the handle parameter as 'Handle to look up (omit for own profile)'. The description essentially repeats this same information, adding no new semantic value beyond what the schema provides. 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 states the action ('Get') and the resource ('Bluesky user profile'), so the tool's purpose is unambiguous. It also adds the nuance that omitting the handle returns the caller's own profile. However, it does not explicitly differentiate from sibling tools like search_users or update_profile, leaving some differentiation to the tool name and schema.

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

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

The parenthetical 'omit handle for own profile' provides a concrete usage condition: use no handle for your own profile, or supply a handle for another profile. This is clear situational context. It does not state exclusions or name alternatives such as search_users for finding handles, so it falls short of explicit when-to-use-versus-alternatives guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates that replies are included and does not explain reply ordering, nesting depth, pagination, authorization requirements, or the exact shape of the returned thread.

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

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

The description is a single compact sentence with no filler. It front-loads the action and the object, which is appropriate for a one-parameter retrieval 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 simple one-parameter read operation, this is minimally adequate. However, there is no output schema and no annotations, so the description does not clarify the structure of the returned thread, such as how replies are nested or ordered, leaving a notable gap in 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% and the uri parameter is already documented as the AT URI of the post. The description adds no additional parameter-level meaning beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description states a clear verb and resource: getting a post thread along with its replies. It distinguishes the tool from the sibling get_post by highlighting that replies are included, though it does not explicitly name get_post as an alternative.

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

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

No guidance is given about when to use this tool versus alternatives like get_post or get_user_feed. There is no mention of when this tool is the right choice or when a sibling should be 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only restates the purpose. It does not mention authentication requirements, that results are posts from followed users, ordering/pagination behavior, or the response 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?

The description is a single, front-loaded sentence with no filler. It is appropriately concise for a one-parameter read operation, though it omits some useful context.

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

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

For a simple one-parameter read tool, the description plus schema is minimally workable: an agent can infer that no arguments are required and that 'limit' is optional. However, without an output schema, pagination/auth details, or any differentiation from get_user_feed, the definition is 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?

The input schema fully documents the only parameter 'limit', including its default, minimum, maximum, and meaning ('Number of posts'). The description adds no additional parameter-level meaning, but since schema coverage is 100%, 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 states a clear verb ('get') and resource ('your home timeline'), so an agent can understand the operation. It does not explicitly differentiate from the sibling tool get_user_feed, though 'your' signals the authenticated user's own 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?

No guidance is provided about when to choose this tool over get_user_feed, search_posts, or other timeline-related tools. The description simply states what it does, leaving selection logic entirely to inference.

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

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

With no annotations, the description carries the full behavioral burden. It clearly signals a read operation and scopes it to a user's recent posts, but it does not disclose ordering, authentication needs, visibility constraints, or behavior for invalid handles. It is adequate but not richly transparent.

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, front-loaded sentence with no wasted words. It states the action, the resource, and the scope efficiently.

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

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

For a simple two-parameter read tool with no output schema, this is reasonably complete: the resource, the target user, and recency are all communicated. Minor gaps like exact ordering and return shape are inferable and not critical for 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 documentation covers 100% of the parameters, including descriptions, defaults, and constraints for handle and limit. The description mostly restates the handle concept ('specific user') and adds only a mild implication of recency, so it contributes little 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 'Get recent posts from a specific user' has a clear verb ('get'), resource ('recent posts'), and scope qualifier ('from a specific user'). It distinguishes this tool from siblings like get_timeline and search_posts, so an agent can tell what it does without opening the schema.

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

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

The use case is implied: call this when you need the recent posts of a particular Bluesky handle. However, there is no explicit guidance about when to prefer it over get_timeline or search_users, and no exclusions or alternative recommendations are given.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only says 'Like a Bluesky post' and mentions required inputs; it does not state whether the action is idempotent, what side effects occur, whether authentication is needed beyond the implied context, or what response is returned.

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 filler. The action is front-loaded and the prerequisite is stated compactly beside it, making it easy to scan and process.

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

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

For a simple two-parameter action, the description plus full schema coverage is minimally sufficient for invocation. However, without annotations or an output schema, it leaves out behavioral details like idempotency and response format, so it is 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 the schema already documents the uri and cid parameters. The description adds only that they are required, which is already encoded in the schema's required array, so it provides no meaningful additional semantic 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 verb ('Like') and resource ('Bluesky post'), making the tool's purpose immediately clear. It also naturally distinguishes this from sibling tools like repost and delete_post by naming the exact action, so an agent can select it without opening the schema.

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

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

The description implies usage by naming the action and prerequisites, but it does not explicitly state when to prefer this over alternatives or mention any exclusions. An agent can infer this is the like action, but there is no direct guidance on 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It communicates the core reply behavior and the parent-identifier prerequisite, but says nothing about permissions required, side effects on the thread, behavior when the parent post doesn't exist, or what the response contains.

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 action is front-loaded ('Reply to a Bluesky post') and the second sentence earns its place by stating the critical data prerequisite.

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 5-parameter mutation tool with no annotations and no output schema, the description covers the essential prerequisite and schema covers the parameters, but the agent is left without guidance on auth requirements or any behavioral context beyond the mechanics of a reply.

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 already documented in the schema. The description adds marginal value by telling the agent where parent_uri and parent_cid come from, but does not clarify root_uri/root_cid semantics beyond what the schema already states.

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

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

The description names a specific verb and resource ('Reply to a Bluesky post'), which is immediately distinct from the sibling create_post. It also specifies the required identifiers (parent URI + CID), pinning down exactly what operation is being performed.

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

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

The description provides a clear prerequisite and points the agent to where to source the required identifiers ('get from search or get_post'). However, it never explicitly contrasts with create_post or states when not to use this tool, leaving the when-to-use guidance partially 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?

There are no annotations, so the description carries the full behavioral burden. It names the action but does not disclose that this is a mutating operation, what side effects occur (e.g., appearing on the user's profile or followers' feeds), whether authentication is required, or what happens if the CID does not match the URI.

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, front-loaded sentence with no filler. Every word contributes: the action, the resource, and the required inputs are all 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?

The tool is simple and its parameters are fully documented in the schema, so an agent can determine the call shape. However, with no annotations and no output schema, the description does not explain the behavioral outcome or return value, leaving some context incomplete.

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 uri and cid. The description only restates that both are required, adding no new semantic detail beyond the structured schema.

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

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

The description states a specific verb ('Repost'), a clear resource ('a Bluesky post'), and the key prerequisite (URI + CID). This distinguishes it from sibling tools like create_post, reply_post, like_post, and delete_post without needing to inspect schemas.

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

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

The intended use case is implied by the verb and resource: use this when the user wants to repost an existing post. However, it does not explicitly state when not to use it or compare it against alternatives such as like_post or reply_post.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states the search action and scope; it does not explain the return format, result ordering, pagination, or whether it searches all public posts or a restricted set. This is a significant gap for a read operation with no annotation safety signals.

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, front-loaded sentence with no wasted words. Every word contributes to conveying the tool's core function, making it appropriately concise and easy to parse.

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 low-complexity search tool with a simple schema, the description is adequate for basic selection and invocation. However, with no output schema and no annotations, an agent is left without information about result shape, ordering, or any search constraints, making it minimally complete rather than fully self-sufficient.

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

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

Schema description coverage is 100%, and the query parameter description duplicates the tool description ('keywords, hashtags, or phrases'). The limit parameter has clear schema documentation including default and bounds. The description adds no semantic value beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description 'Search Bluesky posts by keywords, hashtags, or phrases' clearly identifies the action (search), the resource (Bluesky posts), and the method (keywords, hashtags, phrases). This distinguishes it from siblings like search_users and get_user_feed without needing further explanation.

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: use when you need to find posts matching certain terms. However, it does not explicitly say when not to use it or mention alternatives such as search_users for user discovery or get_timeline for a feed, leaving the agent to infer context.

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?

There are no annotations, so the description carries the behavioral burden. The verb 'Search' signals a read-only lookup, and 'by name or handle' scopes the matching behavior. However, it does not disclose match semantics (partial/exact, case sensitivity), pagination, or response structure.

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

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

The description is a single sentence with no filler. It front-loads the action, resource, and search criteria efficiently.

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

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

For a simple two-parameter search tool, this is mostly adequate, but with no output schema and no annotations, the description leaves return format and matching behavior to inference. It is sufficient for basic invocation but lacks richer context that would help an agent fully know what to expect.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by specifying that the query parameter matches against name or handle, which the schema description ('Search query for users') does not state. The limit parameter gains no extra semantic detail, but the key parameter is clarified.

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 ('Search'), a clear resource ('Bluesky users'), and explicit search criteria ('by name or handle'). It clearly distinguishes itself from sibling tools like search_posts by focusing on users rather than posts.

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 use case is implied — use this when you need to find Bluesky users by name or handle — but there is no explicit guidance about when to prefer it over alternatives such as search_posts or get_profile. No exclusions or comparison points 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the mutation but does not disclose whether fields are independently cleared when omitted, whether changes are reversible, whether authentication is required, or what the response looks like.

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

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

The description is one efficient sentence with no filler. It front-loads the action and the target fields, and every word contributes to understanding the tool's purpose.

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 low-complexity tool with only two optional parameters and full schema coverage, the description is nearly complete. It covers the core action and fields, though it lacks explicit behavioral details around mutation effects and omitted-field semantics.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds 'and/or' indicating optionality, but this is also implied by the schema's required: 0. The description does not need to add much 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 uses a specific verb ('Update') and identifies the resource ('your Bluesky display name and/or bio'). It clearly distinguishes this tool from sibling read tools like get_profile, search_users, and feed/post actions.

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

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

The description implies the tool should be used when the user wants to change their own profile display name or bio, but it provides no explicit guidance about when not to use it or what alternative to choose. No sibling is mentioned or excluded.

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