Ads Manager by AdKit: Google Ads, Meta Ads, TikTok Ads, LinkedIn Ads

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

Annotations already mark readOnlyHint=false and idempotentHint=false, so the writing nature is implied. The description adds the important consent and onboarding context, but it does not disclose what happens on repeated calls or what the tool returns, leaving some behavioral ambiguity.

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 key constraint front-loaded. Every phrase earns its place and there is no 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 lightweight one-parameter tool with no output schema, the description adequately covers purpose, scope, and consent requirements. Minor missing context includes duplicate-call behavior and expected return value, but these are low-risk for an onboarding check-in.

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 single agentId parameter is fully documented by the schema. The tool description adds no parameter-level detail, which is acceptable since the schema already carries the semantics.

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

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

States a specific action (records check-in), a specific resource (successful AdKit usage after setup), and a strict scope (onboarding only). This clearly distinguishes it from siblings like adkit_setup or adkit_status.

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

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

Provides clear usage context: onboarding, setup and connection verification, and only at the user's explicit request. It also excludes non-onboarding use via 'Onboarding only' and 'solely,' though it does not explicitly name alternative tools.

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

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

The annotations provide basic mutability hints, but the description adds valuable behavioral context: fire-and-forget semantics, that it never blocks the user's task, and a clear privacy boundary excluding secrets, tokens, bodies, uploaded files, and personal data. This goes beyond the structured annotations.

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

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

The description is compact and front-loaded with purpose. The field list is short and earns its place by adding filling guidance rather than just repeating the schema, and the privacy rule is a single necessary sentence. No filler.

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

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

For a fire-and-forget feedback tool with no output schema, the description covers what triggers it, what fields to populate, the expected non-blocking behavior, and what to omit. It does not explicitly state what the tool returns, but the fire-and-forget framing makes that less critical.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds practical guidance by saying fields should be filled with whatever is known, giving a concrete context example with toolPath/platform/accountId, and reinforcing the sensitive-data exclusion. This elevates it above the schema-only case.

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 ('Report'), the target resource (AdKit), and enumerates accepted categories (bug, confusing behavior, missing capability, product feedback). It is clear and specific, though it does not explicitly distinguish itself from the sibling tool adkit_help.

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: to report a bug or feedback, and it calls out the fire-and-forget, non-blocking nature. It does not explicitly name alternatives or state when not to use it, but the conditions are reasonably clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false; the description reinforces this with 'It runs nothing and changes nothing,' which is consistent and reassuring. It also discloses the scope of content covered per section, though it says nothing about response format or fallback behavior when a path doesn't resolve.

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

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

Front-loads the core definition, then sections, then usage examples – a logical order with no filler. The section enumeration is dense but each item conveys real scope an agent would otherwise have to probe for.

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 three-parameter read-only help tool with a fully described schema and no output schema, this is complete: it tells the agent what content exists, how to reach it, and how to search. Nothing needed to call it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3; the description goes further by showing concrete path and q string formats and by noting that path strings are composed of section/platform/resource (e.g. 'manage google campaigns create'), which helps the agent construct valid input. It does not mention the q-over-path precedence, but that is already documented in the schema.

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

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

States a specific verb and resource ('Read-only reference documentation for the other AdKit tools') and enumerates the four content sections, so an agent can distinguish it immediately from the actionable siblings like adkit_manage or adkit_studio.

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

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

Gives explicit invocation patterns: open a section with path (with a concrete example) or search with q (with a concrete example), and adds the directive 'Search here before telling the user a capability is unavailable.' The when-to-use versus siblings is unambiguous.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive behavior, so the safety profile is covered. The description adds that data comes from connected GA4/GSC sources and references help paths, but it does not disclose pagination, rate limits, or return behavior beyond what the schema implies.

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 tightly written sentences with no wasted language. The core read capability is front-loaded, and the provider/help reference follows 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 16-parameter, six-action tool with no output schema, the description is quite thin: it does not outline the available actions or describe return shape. The 100% schema coverage and help references mitigate this, but an agent still relies almost entirely on structured fields to understand the full operation set.

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 16 parameters are already documented in the input schema. The description only adds the provider distinction and help pointers, which is baseline-level value when the schema does the heavy lifting.

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

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

The description states a specific read operation over GA4 reports and GSC websites, organic keywords, and pages, and identifies the two providers. It does not explicitly differentiate from siblings, but no sibling appears to overlap with this data-integration 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?

It tells the agent that the provider is either ga4 or gsc and points to adkit_help for field references, which is useful routing guidance. However, it does not say when to use this tool versus alternatives or when not to use it, so usage is only implied.

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

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

Annotations declare destructiveHint=true and readOnlyHint=false, and the description adds the important nuance that most browsing is read while mutations are limited to boards and watchlist changes. It adds genuinely new behavioral constraints not in annotations: fill boards before setting shareEnabled:true, and only enable sharing on explicit user request. It does not discuss allowance limits or failure modes, but those are already in the action parameter schema.

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

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

Four sentences, front-loaded with what the library is, then scope semantics, then the sharing safety rule, then the sibling pointer. Each sentence carries distinct information with no restatement of the name or 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?

There is no output schema, so the description carries the burden, and it covers the three entities, the read-vs-write split, and the sharing precondition. Per-action detail (analyze flow, add-ads, untrack semantics) is delegated to the enum description, which is reasonable given the dispatcher shape, but the description alone would not be enough to drive every action.

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 baseline is 3, but params is a free-form object with no documented keys and the description supplies the one key that matters: params.scope with values library (default) and watchlist (the selected project's My Watchlist). That is real meaning the schema cannot convey. It does not enumerate other params keys, keeping it at 4 rather than 5.

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

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

Opens with a specific verb+resource and scale ('Browse 1M+ ads from thousands of advertisers across Meta, Google, and LinkedIn') and names the two subsystems it manages: watchlists and inspiration boards. It distinguishes itself from adkit_manage by stating that the user's own campaigns live there, so an agent can route correctly 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?

Gives concrete selection rules: params.scope=library vs watchlist for advertiser list/search, and an explicit exclusion ('The user's own campaigns live in adkit_manage'). It also sets an approval gate on sharing. It stops short of telling the agent when to prefer adkit_studio or other library-adjacent siblings, so not 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 flag destructiveHint=true/openWorldHint=true, and the description adds genuinely new behavioral context: most mutations create drafts by default, publish:true goes live and needs explicit user approval, and platform-api-request requires project opt-in. That approval-and-draft gating is exactly the safety nuance annotations cannot express. It does not describe rate limits or partial-failure behavior, keeping it off a 5.

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 text is dense but front-loaded, leading with the two-mode split before the routing details, and each sentence carries operational information (entity routing, draft/publish semantics, data vs params). The list of metrics (spend, ROAS, impressions, clicks, conversions, CPC/CPA) is slightly padded but still helps an agent map natural-language questions to the right entity.

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 10-parameter, nested-object mega-tool with no output schema, the description covers the essential routing (reporting vs mutation vs escape hatch), draft/publish behavior, request-shaping rules, and the media upload flow. It leaves per-platform entity and field detail to adkit_help deliberately, which is reasonable for a router tool, though an agent still has to make a second call to act confidently.

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 3 baseline is met by the schema alone, but the description adds real meaning: use AdKit field names rather than raw platform fields, send full request bodies as top-level data, and use platformOverrides for raw fields. It also clarifies the publish flag's live-send consequence, which the schema only weakly conveys.

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

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

The description opens with a specific verb+resource scope (manage and report across eight named ad platforms) and then splits into two clearly-labeled modes: 'Reporting & analytics' and 'Management'. An agent can tell which branch applies. It stops short of the top mark because it does not distinguish this mega-tool from siblings like adkit_studio and adkit_library, which also appear to touch campaign content.

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 routing is unusually explicit: entity:"results" for performance, entity:"benchmarks" with params.from:"YYYY-MM" for benchmarks, entity:"platform-api-request" for unsupported native resources, entity:"media" action:"request_upload_url" for files, entity:"ads" for creatives, and adkit_feedback for gaps. The only gap is that it never states when a caller should prefer adkit_studio/adkit_library/adkit_help instead of this tool.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and readOnlyHint=false, so the safety profile is largely covered by structured data. The description adds the useful side-effect that list also returns accessible workspaces, but it never warns that update can overwrite project fields (e.g. tags replacing the full list) despite carrying the destructive hint.

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

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

Three short sentences, front-loaded with the verb+resource, then the identifier workflow, then the list-return detail. No sentence is redundant and nothing is buried.

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 12 parameters, 100% schema coverage, and no output schema, the description adequately covers how to obtain and use projectId and what list returns. It omits any hint about destructive update behavior or create prerequisites, but the annotations and schema fill most of that 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 baseline is 3, and the description goes beyond it by explaining the projectId lifecycle (obtain via list, then reuse for update and other project-scoped tools). It adds workflow meaning but no additional format or constraint detail for the remaining 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 specific verbs and a clear resource ('List, create, or update AdKit projects'), so the agent immediately knows this is the CRUD entry point for projects. It does not explicitly contrast itself with siblings like adkit_manage or adkit_setup, but the resource-level specificity is strong.

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 real workflow guidance: use a projectId from list for update, note that list returns accessible workspaces, and (in the schema) that action defaults to list and create is for when no project exists. There is no explicit when-not guidance or named alternative sibling, which keeps it short of a 5.

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

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

Annotations already declare readOnlyHint/idempotentHint/non-destructive, so the safety profile is covered. The description still adds real behavioral context beyond that: the tool returns a link rather than performing the linking itself, and projectId auto-resolves only for single-project users, which affects invocation.

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

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

Three short sentences with the usage trigger front-loaded, then the return value, then the prerequisite. No filler and nothing buried mid-sentence.

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-required-parameter read-only tool with a 100% covered schema, the description covers trigger, return, and prerequisite adequately even without an output schema. Minor gaps remain around what happens when auto-resolution fails and whether the returned link is time-limited.

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 description's parameter notes ('Requires projectId from adkit_projects', 'auto-resolves only for single-project users', platform deep-linking) largely restate what the schema already documents. Baseline 3 is appropriate when the schema carries parameter meaning.

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 (connect an ad platform), the platforms involved, and the concrete return (a sign-in link plus ad-account picker), which is far more useful than a bare name. It does not, however, explain how it differs from the similarly named sibling adkit_integrations, so the agent must still infer the boundary.

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?

Opens with an explicit trigger: 'Use when the user wants to connect an ad platform' — an agent can act on that without guessing. It names no exclusions or alternative tools for overlapping cases, so it stops just short of full 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/idempotentHint/destructiveHint, and the description adds what data is returned. However, 'Requires projectId' is slightly overstated because the schema notes the parameter auto-resolves for single-project users, and no edge-case behavior is disclosed. 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?

One sentence that front-loads the return contents and immediately states the dependency. No filler or repetition.

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

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

The description explains what the tool returns and the input dependency. It lacks an explicit call scenario or output-shape details, but given a single parameter and read-only safe operation, it is nearly complete.

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

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

With 100% schema coverage, the description adds no new parameter meaning; it simply repeats that projectId is required and sourced from adkit_projects, which the schema already documents.

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 ('Return') and a precise resource ('project context, connected platforms, assigned ad accounts, and Studio setup'), which clearly identifies the tool as a status/read-only lookup and distinguishes it from sibling tools like adkit_projects or adkit_setup.

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

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

It explicitly states the prerequisite: projectId must come from adkit_projects. This tells the agent which prior tool to call. It does not name alternatives or exclusion cases, so it misses the highest bar, but the usage context is clear enough.

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

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

Annotations already signal readOnly=false and destructiveHint=true; the description adds meaningful behavior beyond that: Studio entities are drafts, no live campaign data is exposed, and the temporary-upload workflow requires a PUT before passing the reference. It does not detail side effects of delete/update, but the key conceptual boundary is well disclosed.

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

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

The description is dense but efficiently organized: capability overview, critical action mapping, the upload workflow, and boundary with adkit_manage. Every sentence contributes guidance an agent needs, and no space is wasted restating the tool name or schema.

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

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

For a multi-entity, multi-action tool with nested params and no output schema, the description covers the major decision points: which entity/action combos to use, id behavior, the upload sequence, and where live data lives. It does not describe return payloads, but that is a minor gap given the breadth of operations and the strong 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?

Schema coverage is 100%, so the baseline is 3, but the description enhances it materially with action-specific id semantics ('omit to auto-create' vs 'provide id to add variants'), the temporary_upload reference shape, and example enum values for model/quality. It leaves a few actions to the schema, but adds real operational meaning beyond the property descriptions.

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

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

The description opens with a specific role: 'AI ad generation workspace' and enumerates concrete operations (create briefs, generate images, list media, inspect media items, share briefs). It also distinguishes itself from adkit_manage by explicitly stating Studio ads are creative drafts, so an agent can separate this tool from its 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?

It gives explicit routing instructions: use entity 'ads' with action 'generate', omit or provide id depending on variant behavior, and use the media request_upload_url flow for user photos. It also states what the tool does NOT contain (live campaign data/spend/performance) and directs that data to adkit_manage, which is clear when-not 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?

The annotations already disclose that this is a non-read-only, open-world, non-idempotent, non-destructive operation. The description adds useful behavioral constraints beyond the annotations: exactly one file, no base64 payloads, platform-specific image support, and the request_upload_url byte-upload workflow.

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

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

The description is front-loaded with the core action and then efficiently covers source selection, platform limitations, and failure reporting. Every sentence provides actionable guidance with no repetition of schema text.

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

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

For a nine-parameter tool with nested objects and no output schema, the description covers the key workflow: destination platforms, accepted sources, the temporary upload fallback, the base64 restriction, and failure reporting. The schema supplies the remaining parameter detail.

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 most parameter documentation. The description still adds meaningful semantics by clarifying the exclusive files-vs-source choice, when request_upload_url applies, and that base64 payloads are rejected.

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: upload one file to named ad platforms or Studio. It distinguishes supported source modes and platform-specific image limitations, so an agent can identify exactly what the tool 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?

It explicitly says to use files when the client supports file inputs, otherwise use source for a public HTTPS URL or completed temporary upload, and reserves request_upload_url for when neither is available. It also names a sibling tool, adkit_feedback, for reporting failures.

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