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

It explicitly discloses the write side effect ('upload it to your media library') and the permission requirement ('Requires write access'), complementing the readOnlyHint=false annotation. No contradiction with annotations exists, though the '13 voices' claim is inconsistent with the schema's 9-voice enum, slightly reducing accuracy.

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

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

Two sentences front-load the primary action and side effect with no filler. The voice-count claim is somewhat promotional and inaccurate, but the overall structure is efficient.

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 covers the essential action and side effect, but with no output schema it leaves the return value unspecified (e.g., media object or ID) and does not mention model/voice/folder/metadata nuances. The voice-count mismatch further reduces completeness for a tool with five parameters.

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 parameters are already fully documented. The description adds only that the prompt is text and that multiple voices exist; it does not explain model choice, folder behavior, or metadata, and its voice count conflicts with the schema enum.

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 ('Generate'), resource ('audio'), source ('text'), engine ('OpenAI text-to-speech'), and side effect ('upload to media library'), which clearly separates it from sibling generate_text/image/video and media_upload tools. The title alone is generic, but the description resolves 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 gives clear context for when to use the tool: text-to-speech generation with automatic upload. It does not explicitly name alternatives or state when not to use it, but the sibling set is distinct enough that an agent can infer the intended use.

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 the side effect of auto-uploading to the media library, states write-access requirements, and tells the agent which URL to display for PNG vs SVG because imgix does not serve SVG. These add meaningful behavioral detail beyond the annotations without contradicting them.

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

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

Three concise sentences front-load the main action and upload side effect, then pack format and permission guidance without wasted words. Every sentence contributes actionable information.

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

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

For a 7-parameter tool with no output schema, the description helps by revealing the output fields to use for display (media.imgix_url vs media.url) and the upload behavior, but leaves model, aspect_ratio, and metadata decisions to the schema. This is mostly complete given the high schema 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?

The input schema covers all 7 parameters at 100% coverage, so the baseline is 3. The description adds value by explaining when to choose 'svg' format and the display URL distinction for PNG versus SVG, though it does not directly clarify model, alt_text, metadata, or aspect_ratio 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 and resource ('Generate an image using Cosmic AI') and clearly distinguishes this tool from sibling AI tools by specifying image generation and auto-upload to the media library. It also clarifies it is for images, not text, video, or audio.

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: use this tool to generate an image and automatically upload it, and it gives format-specific guidance (svg for logos, icons, illustrations, and vector artwork) and a permission prerequisite ('Requires write access'). It does not explicitly name alternative tools or state when not to use it, but the context is sufficient for 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 provide only minimal behavioral hints (readOnlyHint false, idempotentHint false, destructiveHint false), so the description carries much of the burden for disclosure. It does not mention that generation may consume external AI quota, may produce non-deterministic output, has no default model stated, or that results are not stored/retrievable. The description adds no behavioral context beyond restating the core function.

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

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

The description is compact and front-loaded with the core action. The second sentence lists relevant use cases. The trailing 'and more' is slightly vague but not harmful; overall every sentence contributes to basic understanding.

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 only three parameters and full schema coverage, the description is minimally sufficient for constructing a basic call: a prompt is required, with optional model and max_tokens. However, it lacks guidance on choosing among sibling generation tools, any note about model defaults or costs, and any indication of return format. These gaps keep it from being 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 prompt, model, and max_tokens parameters are already well documented. The description adds no new parameter-level semantics. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description clearly states a specific verb and resource: 'Generate text content using Cosmic AI.' It distinguishes this tool from sibling generation tools like cosmic_ai_generate_image, cosmic_ai_generate_video, and cosmic_ai_generate_audio by explicitly limiting scope to text. It also names concrete use cases such as content, descriptions, and summaries.

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 through the phrase 'Useful for creating content, descriptions, summaries, and more,' which gives some context for when to call it. However, it does not explicitly state when not to use it or mention alternatives like generate_image, generate_video, or generate_audio. 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 mark readOnlyHint=false, so the main added value is the explicit side effect of auto-uploading to the media library and the write-access requirement. It does not contradict annotations and surfaces the most decision-relevant behavioral facts, though it omits details like asynchronous completion or failure modes.

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, purposeful sentences with no filler. The core action and key side effect are front-loaded, and the write-access note earns its place.

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

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

For a single-required-prompt generation tool, the description plus schema covers essential information: what to generate, where it lands, and the permission needed. The lack of an output schema is mitigated by 'upload to media library,' though return/response details are left unstated.

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 six parameters including duration and resolution enums. The description adds no parameter semantics 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 identifies a specific action—generate a video—and a concrete output path (auto-upload to media library), making it easy to distinguish from sibling generate_text/image/audio tools. The 'powered by Veo' detail adds useful specificity.

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

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

It provides the prerequisite that write access is required and implies the tool is for video generation, but it never names alternatives such as cosmic_ai_generate_image or cosmic_ai_generate_audio. Selection guidance is therefore implicit 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 mark this as read-only, and the description adds useful behavioral context about what a block is and what the response contains (name/shortcode, title, description, editor type, content). This gives an agent a good picture of the operation without over-claiming.

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

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

Three tight sentences front-load the core listing action, then give the token context, the intended use, and the return fields. Every sentence earns its place and there is no repetition of the title.

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

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

For a parameterless read-only list tool, this description is complete: it explains the domain concept, when to use the tool, and the return contents. An agent has everything it needs to invoke this 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 tool has zero parameters and schema coverage is 100%, so the description does not need to add parameter detail. Per rubric, a no-parameter tool starts at baseline 4, and there are no missing semantics to compensate for.

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

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

The description names a specific action and resource ('List the reusable rich-text Content Blocks') and adds the distinguishing detail that blocks are referenced via a '{{name /}}' token in rich-text metafields. This clearly separates it from sibling tools for objects, media, types, and AI operations.

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

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

It gives an explicit use case: discover which block shortcodes exist before writing rich-text content that references them. It does not enumerate alternatives or say when not to use it, but the context is clear enough for a no-parameter listing tool.

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

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

Annotations already mark this as destructive with readOnlyHint false, but the description adds valuable behavioral detail: the deletion is permanent and requires write access. This goes beyond what the annotations alone convey. It does not discuss webhook side effects, but the schema documents the trigger_webhook parameter.

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. Each sentence adds a distinct fact: the operation, its permanence, and the access requirement. The description 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 destructive delete operation with annotations and full schema coverage, the description covers the essential facts: what is deleted, that it is permanent, and that write access is required. It does not explain return or error behavior, but no output schema exists and this is adequate for a straightforward delete tool.

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

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

Schema description coverage is 100%, and both id and trigger_webhook already have clear descriptions. The description's 'by ID' aligns with the id parameter but adds no new meaning for either parameter, 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 states a specific verb and resource: 'Delete a media file by ID.' The 'media' resource clearly distinguishes it from sibling delete tools for objects and types, though it does not explicitly name those alternatives. The additional notes on permanence and write access further clarify intent.

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. 'Requires write access' is a prerequisite, not a usage condition. It does not mention sibling delete tools or any scenario-based selection criteria, leaving the agent to infer usage from the tool 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=true, so the read-only nature is covered. The description adds that the tool returns the full media object with URL and metadata, which provides useful return-format context since there is no output schema. However, it does not clarify behavioral nuances such as how the 'props' parameter affects the returned object, and no auth/rate-limit context is provided.

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 action is front-loaded in the first sentence, and the return expectation is stated in the second. 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 tool with only 2 parameters, an existing readOnly annotation, and no output schema, the description is mostly sufficient: it names the input (by ID) and describes the output (full media object with URL and metadata). The only notable gap is the unstated interaction between the 'props' parameter and the promised 'full media object,' which could confuse an agent deciding whether to include props.

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 'id' and 'props' are already documented in the schema. The description reinforces the 'by ID' usage but adds no syntax, format, or interplay details beyond what the schema provides. Baseline 3 is appropriate.

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

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

States a specific verb and resource: 'get details of a single media file by ID.' It clearly distinguishes from the sibling 'cosmic_media_list' (list vs single) and from 'cosmic_objects_get' (media vs generic objects) without needing to open schemas. The scope is precise.

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

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

The description implies when to use this tool (when you need details for one media file by ID), but it does not explicitly mention alternatives or when not to use it. There is no exclusion such as 'for multiple files, use cosmic_media_list.' The context is clear enough for basic selection but lacks explicit routing guidance.

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

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

Annotations already declare readOnlyHint=true, so the description doesn't need to restate safety. The description adds the optional folder filter and pagination behavior, which is useful context. However, it doesn't disclose details like default pagination behavior, whether the response is a list of metadata or full objects, or any rate limits. With annotations covering the read-only nature, a 3 is appropriate.

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

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

The description is a single sentence that front-loads the core action and resource, then mentions the optional filter and pagination. Every word earns its place; there is no redundancy or filler.

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

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

For a simple read-only list tool with a fully documented schema and readOnlyHint annotation, the description is mostly complete. However, there is no output schema and the description doesn't mention what the response contains (e.g., media metadata, URLs, total count), which an agent might need to know for downstream steps. This is a minor gap 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?

Schema description coverage is 100%, so the schema already documents all four parameters. The description mentions 'optional folder filter and pagination', which aligns with the folder, skip, and limit parameters, but adds no new meaning beyond the schema. Baseline 3 is correct when the schema carries the parameter documentation.

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

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

The description states a specific verb ('List') and resource ('media files from the Cosmic bucket') and mentions optional folder filter and pagination. It is clear, though it doesn't explicitly distinguish itself from cosmic_media_get or cosmic_objects_list; the resource and action are specific enough to be understood.

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 listing media with optional filtering and pagination, but it does not explicitly state when to use this tool versus alternatives like cosmic_media_get or cosmic_objects_list. There is no exclusion or alternative guidance, so the agent must infer the appropriate context from the name and description.

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

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

Annotations already convey a mutating operation (readOnlyHint=false, idempotentHint=false, destructiveHint=false). The description adds a write-access prerequisite and the URL/base64 input modes, but it does not disclose side effects such as webhook triggering or replacement behavior. No contradiction with annotations.

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

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

Two sentences with no filler; the core action and input modes are front-loaded, and the access precondition is stated separately. 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 4-parameter upload tool, the schema handles parameter details and the description supplies the access requirement and input modes. It could add what happens on upload, such as webhook side effects, but nothing critical is missing for a correct 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?

Schema coverage is 100% and each parameter has a meaningful description, including the media data URI format and trigger_webhook default. The tool description only repeats 'URL or base64-encoded data,' adding no semantic value beyond the schema.

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

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

States a specific verb ('Upload'), a specific resource ('media file to the Cosmic bucket'), and the accepted input modes. This distinguishes it clearly from sibling tools like cosmic_media_list, cosmic_media_get, and cosmic_media_delete.

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

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

Provides clear context for when it applies: uploading media to a Cosmic bucket, and adds the prerequisite that write access is required. It does not explicitly name alternative tools or exclusions, so it falls short of a 5.

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

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

Annotations already signal that this is not read-only, not idempotent, and not destructive. The description adds one useful behavioral note, 'Requires write access,' which is a permission context beyond the annotations. However, it does not mention possible side effects, uniqueness behavior for slugs, error cases, or the response shape, so it remains minimally 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 two short sentences with no filler. The purpose is front-loaded in the first sentence, and the authorization note in the second is directly useful. Every sentence earns its place, and the description is appropriately sized for this 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?

Given the tool's complexity—seven parameters, required fields, nested metadata, and no output schema—the description is adequate but sparse. The schema covers parameter meanings, and the description covers purpose and access, but it omits expected return values, failure modes, and behavior around duplicate slugs or missing object types. This leaves minor but real gaps for an agent deciding on success criteria.

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 fully documents all seven parameters. The description adds no parameter-level detail beyond the schema, which matches the baseline of 3. The brief mention of 'object' and 'Cosmic bucket' adds no semantic meaning to individual 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 states a specific action and resource: 'Create a new object in the Cosmic bucket.' The verb 'create' clearly distinguishes it from sibling tools like cosmic_objects_update, cosmic_objects_delete, and cosmic_objects_list. No ambiguity remains about what this tool does.

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

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

The usage context is only implied by the verb 'create' and the resource name. It clearly indicates that this tool is for new objects rather than updates or deletions, but it does not explicitly state when to prefer it over alternatives or exclude cases like updating an existing object. The added 'Requires write access' is a precondition, not a usage 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 idempotentHint=trueebb. The description adds the key behavioral fact that the action is permanent, and that write access is required, which is useful beyond the annotations. It does not mention what happens to associated data or webhook behavior (though the trigger_webhook parameter implies it), but the added context on permanence and permissions is valuable.

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 is direct and clear. It front-loads the action and permanence, and includes the access requirement. No fluff, but it is very brief and could have added a bit more guidance while remaining 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?

Given the tool is a simple delete operation with annotations (destructive) and full schema coverage, the description covers the core purpose and the critical permanence warning. However, it lacks guidance on when to use it vs siblings, potential side-effects beyond webhooks (e.g., cascading deletes), and does not mention the response format beyond no output schema. This is adequate but leaves room for improvement.

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

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

The schema already fully describes both parameters (id and trigger_webhook), with 100% coverage. The description does not add any additional meaning about the parameters, such as the effect of setting trigger_webhook to false or any format constraints for the ID. According to the baseline, a score of 3 is appropriate when schema coverage is high and the description adds minimal parameter-specific context.

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

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

The description clearly states the verb ('Delete') and resource ('object by ID'), and the permanence of the action. It does not explicitly name siblings, but the resource 'object' and the verb 'delete' distinguishes it from similar delete tools for other resources (cosmic_types_delete, cosmic_media_delete). The title is redundant but the description adds 'permanent' context.

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

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

The description implies it should be used when you need to delete an object, with no explicit when-not or alternatives. It does not warn against deleting in production or mention any preconditions (e.g., checking dependencies). Sibling delete tools exist but no cross-referencing is provided, so an agent might not know when to choose this over others.

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

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

With readOnlyHint=true, the safety profile is already covered by annotations, so the description's return-value promise ('full object with all metadata') and dual lookup modes add useful context. However, the 'full object' claim sits in tension with the props parameter (which returns a subset), and the default status='any' behavior (returning drafts by default) is not disclosed in the description. These are real surprises an agent could hit, so the description adds value but not rich behavioral coverage.

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, front-loaded with the verb and resource, and every clause earns its place. The lookup modes come firsthol; the return promise completes the picture with zero 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 5-parameter tool with no output schema, the definition is adequate but has clear gaps: 'full object with all metadata' is a thin return contract that does not tell the agent what fields to expect, and the status default (any) and its interaction with props are left entirely to the schema. The annotations cover safety and the schema covers parameters, so the description itself carries less burden, but a slightly more concrete return description would make this 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 coverage is 100%, so the baseline is 3, but the phrase 'by ID or by slug+type' adds cross-parameter meaning beyond any single parameter description: it frames id and slug+type as alternative lookup keys and clarifies the id-vs-slug choice. This modest semantic increment above the per-parameter schema descriptions justifies a 4.

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

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

The description names a specific verb and resource ('Get a single object') and the two lookup modes ('by ID or by slug+type'), which is precise and informative. 'Single object' clearly differentiates it from the sibling cosmic_objects_list for an agent choosing between fetch-one vs fetch-many 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 conveys clear context: use this tool to retrieve exactly one object when you hold an id or a slug+type pair)Skip. It does not explicitly name alternatives or exclusions, so it stops short of a 5, but the 'single object' framing combined with the sibling list tool gives an agent enough to route correctly.

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 readOnlyHint and openWorldHint annotations already cover safety and scope; the description adds behavioral specifics: it returns an array of objects with metadata and supports optional filtering/pagination. It does not mention rate limits or response shape details, but 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?

One concise sentence front-loads the action and follows with filters and return shape. No filler or repetition of title/name beyond the necessary 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 read-only list tool with no output schema, the description states the return kind ('array of objects with their metadata') and the high-level filter/pagination behavior. It leaves advanced params (sort, depth, props, query) to the fully-covered schema, so an agent can still 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%, so the schema already documents all 8 parameters with defaults and enums; the description only names type/status/pagination as a subset. It adds no additional meaning beyond the schema, 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 uses a clear verb-resource pair ('List objects from the Cosmic bucket') and adds scope and behavior ('optional filters for type, status, and pagination', 'Returns an array'). This distinguishes it from the sibling CRUD/get/media/types tools; an agent can recognize it as the collection-listing operation.

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 does not name sibling alternatives or state when to prefer cosmic_objects_get or cosmic_media_list. The usage context is implied by 'List objects' and the optional filter list, but no explicit when/when-not guidance is 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 cover read-only/destructive/idempotent traits, so the description's added value comes from stating that only provided fields are updated and that write access is required. This gives useful behavioral context beyond the structured annotations and does not contradict them.

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

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

Two short sentences deliver the core action, the key constraint (partial update), and the access requirement. No filler or redundancy; the most important 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 6-parameter update operation with no output schema, the description covers the essential invocation details: what to update, how partial updates behave, and the auth requirement. It doesn't explain return values or metadata merge semantics, but the core guidance is sufficient for correct use.

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 parameters are already documented. The description adds essential semantic meaning by indicating that omitted fields are left unchanged and that the id field identifies the target. This goes beyond the raw 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'), a clear resource ('existing object'), and a required identifier ('by ID'). It also clarifies partial-update semantics, which distinguishes it from sibling tools like cosmic_objects_create and cosmic_objects_delete without needing to open schemas.

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

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

The description establishes a clear context: this tool is for modifying an existing object by ID, not for listing, reading, creating, or deleting. It adds the precondition that write access is required. It does not explicitly name alternative tools or state when not to use it, but the context is sufficient.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the mutation profile is covered. The description adds one useful behavioral detail — 'Requires write access' — beyond the annotations. It does not disclose side effects, duplicate-slug behavior, or what happens after creation, but given the annotation coverage the added value is moderate, not rich; a 3 fits.

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: action, key input, and permission requirement. The first sentence is front-loaded with the core purpose, and each subsequent sentence adds distinct information. Only minor redundancy exists between 'custom schema' and 'metafields to structure your content,' keeping this just shy of a 5.

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

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

With a nested metafields schema, 5 parameters, and no output schema, the description covers the essentials (action, key input, write-access requirement) while the rich schema carries parameter detail. Gaps remain: return value/shape on success, duplicate-slug or validation behavior, and any post-creation implications are unmentioned — more relevant here because no output schema exists to fill that void.

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 carries the full weight of parameter meaning (including unusually detailed guidance like preferring rich-text over markdown/html-textarea and select over select-dropdown). The description's 'Define metafields to structure your content' adds a small semantic link to the metafields parameter but does not exceed the baseline expected when the schema is this complete.

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 new object type with a custom schema.' It is unambiguous against its siblings (cosmic_types_list/get/update/delete, cosmic_objects_create), since 'create' + 'object type' maps directly to this operation and 'Define metafields' clarifies the input being built. An agent can select this tool 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?

Usage is implied: this is for creating new object types rather than listing, getting, updating, or deleting them. However, the description provides no explicit when-to-use guidance or exclusions, such as pointing to cosmic_types_update for modifying existing types or cosmic_objects_create for creating content items of a type. The 'Requires write access' note is a lightweight operational hint, not a routing 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 description adds critical behavior beyond the annotations: the cascade effect of deleting all objects of the type, and the write-access requirement. This is especially valuable because the annotations already mark it destructive, and the description gives the concrete consequence an agent needs to predict.

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 the essential warning front-loaded. Every word earns its place: the action, the identifier, the destructive consequence, and the permission requirement are all covered without padding.

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

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

For a single-parameter destructive delete tool, the description fully covers what an agent needs: the target, the cascade risk, and the access requirement. No output schema is needed for a delete operation, and the sibling list makes the resource scope 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 the only parameter, slug. The description simply repeats that the slug identifies the object type, adding no new semantic 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?

States a specific action (Delete), the resource (object type), and the key identifier (slug). The resource is clearly distinct from the sibling cosmic_objects_delete, which targets individual objects rather than types.

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

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

The description implies when to use this tool: deleting an object type by slug, with the important caveat that all objects of that type will also be deleted. It does not explicitly name alternatives or state when not to use it, but the destructive warning gives an implicit usage boundary.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, establishing a safe read operation. The description adds valuable behavioral context by specifying the return payload ('full schema including all metafield definitions'), which the annotations do not cover. It does not discuss errors or authentication, but given the annotations, this is a minor gap.

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

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

The description is two short sentences: the first states the primary action, the second clarifies the return value. There is no redundant wording, and the most important information is front-loaded. Every clause earns its place.

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

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

For a simple read-only get-by-slug tool with no output schema and only one parameter, the description is fully adequate. It states the purpose, the input basis, and what the response contains. Combined with the readOnly annotation, 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?

The input schema is fully documented at 100% coverage for the single 'slug' parameter, so the schema itself provides the meaning. The description adds no extra detail about slug format, URL encoding, or examples. Per the rubric, baseline 3 is appropriate because the schema already 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 description states the precise action ('Get a single object type by slug') and the resource ('object type'). The word 'single' differentiates it from list siblings like cosmic_types_list, and 'object type' separates it from cosmic_objects_get and media tools. This is an unambiguous, specific purpose.

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

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

The description implies usage context: you use this tool when you have an object type slug and need its full schema. However, it provides no explicit guidance on when to prefer this over cosmic_types_list, nor does it mention alternatives or exclusions. The guidance is implied rather than 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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds that the return includes schema definitions and metafields, which is useful behavioral context beyond the annotations. It does not disclose pagination, ordering, or whether metafields are always present, but for a zero-parameter list tool this is acceptable.

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, no filler, and the core action is front-loaded. Every word earns its place, and the additional detail about return content is valuable 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 zero-parameter, read-only list tool with no output schema, the description is nearly complete. It tells the agent what it returns (schema definitions and metafields). The only minor gap is not mentioning whether the list is paginated or ordered, but that is a small omission 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?

There are zero parameters, so the schema has nothing to document. The description adds meaning by explaining what the response contains (schema definitions and metafields), which is the only semantic content an agent needs. Baseline 4 for zero-parameter tools 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 ('List') and resource ('object types in the Cosmic bucket'), and mentions it returns schema definitions including metafields. It is clear enough to distinguish from sibling tools like cosmic_objects_list (which lists object instances) and cosmic_types_get (which gets a single type), though it does not explicitly name those siblings.

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 read-only listing use case and the context signals show zero parameters, so an agent can infer it is a simple 'list all' operation. However, it does not explicitly state when to prefer this over cosmic_types_get or cosmic_objects_list, nor does it mention any exclusions or prerequisites.

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, destructiveHint=true, and idempotentHint=true. The description adds 'Requires write access' and lists modifiable fields, which is useful but does not go further into what gets replaced, whether omitted fields are reset, or what the response looks like. 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 three short sentences with no filler. It front-loads the action and resource, lists capabilities, and includes the key access requirement. 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 mutating, destructive tool with no output schema, the description is minimally adequate: it names the operation, target, modifiable fields, and access requirement. But it omits the 'singular' field, gives no return-value expectations, and provides no explicit guidance on replacement versus patch semantics. The schema and annotations fill some gaps, but not all.

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

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

The input schema has 100% parameter description coverage, so the schema already documents all parameters. The description mentions title, metafields, and options but not singular, and adds no deeper semantic details beyond the schema. This fits the baseline of 3.

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

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

The description clearly states the verb ('Update'), the resource ('object type schema'), and the main modifiable fields (title, metafields, options). It does not explicitly differentiate from sibling tools like cosmic_objects_update, but the focus on 'object type schema' makes the target resource clear. Missing 'singular' from the field list is a minor completeness gap.

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 'Update an existing object type schema' implies use for existing types rather than creation or deletion, and 'Requires write access' gives a prerequisite. However, it does not explicitly state when to prefer this over alternatives like cosmic_types_create, cosmic_types_delete, or cosmic_objects_update.

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