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 establish read-only, idempotent, non-destructive behavior, and the description adds navigational behavior: progressive drill-down, q-based keyword search across the full catalog, and cross-path fallback semantics. It does not contradict the annotations, though it could describe the return/response format more explicitly.

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 well-organized sentences carry the full contract: the first establishes the catalog categories, the second gives concrete invocation patterns and search behavior. It is dense but front-loaded and free of 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 help tool with no required parameters and rich annotations, the description covers root invocation, drill-down paths, keyword search, and precedence semantics, with examples. The lack of an output schema is not a gap because the return is clearly help content.

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

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

Input schema covers 100% of the parameters, so the baseline is 3; the description adds value with worked examples for path and q and clarifies that q searches the entire command catalog. This extends the schema documentation meaningfully without redundancy.

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

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

Clearly identifies this as the AdKit help/discovery tool with a specific verb ('discover') and resource (the AdKit MCP contract). The top-level path categories distinguish it from sibling operation tools and make its scope concrete with examples.

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

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

Provides explicit when-to-use guidance: start with adkit_help() for the root overview, drill down via path, or use q for keyword search. The directive to search before telling a user a capability is unavailable, plus the note that a capability may exist under another path, is strong usage guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and openWorld, so the safety profile is covered. The description adds that this is read-oriented and points to help for actions, but doesn't describe auth requirements, rate limits, or pagination behavior beyond what schema offsets imply.

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-loaded with the read purpose, followed by a concrete help pointer. No wasted words and easy to scan.

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 16 parameters, 100% schema coverage, and rich annotations, the description covers the broad purpose and defers detail to adkit_help. It is nearly complete for a router-style tool, though it omits any mention of the required projectId and its dependency on adkit_projects.

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

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

Schema description coverage is 100%, so every parameter is already documented in the schema, including action enums, provider enums, and per-action requirements. The description adds nothing about parameter semantics beyond the schema, making baseline 3 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 ('Read') and concrete resources (GA4 reports, GSC websites, organic keywords, pages). It distinguishes the resource domain from siblings like adkit_projects, though it doesn't explicitly name which sibling to use for other integrations actions.

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

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

Says to call adkit_help with specific paths for 'actions and fields,' implying this tool covers reads. However, it doesn't state when to use this tool versus alternatives, nor when NOT to use it, leaving routing largely implicit.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=true, so the safety profile is partly covered. The description adds genuine behavioral context beyond the annotations: the sharing action is gated on explicit user intent, and create/add-ads have ordered prerequisites. It does not discuss rate limits or return shape, but the added sharing constraint is meaningful.

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?

Purpose is front-loaded in the first sentence, followed by capability, scope semantics, and a safety caveat. It is dense but every sentence carries distinct information; the middle sentences are somewhat packed but not wasteful.

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

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

For a multi-entity, multi-action tool with a free-form params object and no output schema, the description covers the main entity/action split, the boards workflow, and the sibling boundary. Remaining gaps (e.g., search vs list distinction, similar) are minor since the schema's action enum documents those.

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%, giving a baseline of 3, and the description exceeds that by explaining params.scope values (library vs watchlist) that the free-form params object (additionalProperties: true) leaves undefined. That is real meaning beyond the schema, though it covers only one of the nested params.

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 ('Browse 1M+ ads from thousands of advertisers across Meta, Google, and LinkedIn') and layers on the watchlist and boards capabilities. It explicitly names the sibling boundary by pointing to adkit_manage for the user's own campaigns, so an agent can distinguish this library-browsing tool from management tools without opening schemas.

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

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

It gives explicit when-to-use rules: params.scope library vs watchlist, and the sequencing rule 'Create and fill boards before setting shareEnabled: true through boards update.' It also states an exclusion ('only enable sharing when the user explicitly asks') and routes own campaigns to adkit_manage.

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

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

Annotations already declare readOnly=false and destructive=true, so mutation risk is signposted; the description adds genuinely new behavior: "Most mutations create drafts by default; publish:true sends changes live and requires explicit user approval," plus project opt-in for the raw platform API. This draft-vs-live distinction is not derivable from the annotations and is the key safety context. Auth/permission scope and rate limits are not covered.

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-loaded with the headline capability and organized under em-dash section headers, which helps scanning. However it is long and dense, with several clauses (per-platform coverage, platformOverrides, media uploads, ChatGPT normalization) that add bulk to a single description and partly restate schema content.

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

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

There is no output schema, so the description must stand alone, and for a high-complexity multi-platform tool it covers routing, draft/publish semantics, field-naming rules, raw-API fallback, and file-upload flow while deferring per-platform specifics to adkit_help. Return-value shape and pagination behavior are not described, though the help-tool deferral mitigates this.

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 ten parameters, making 3 the baseline. The description adds routing meaning for entity values and clarifies that full bodies go in top-level data and AdKit field names must be used, but it does not explain params/platformOverrides semantics beyond what the schema states.

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

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

Opens with a specific verb pair (manage AND report) and the resource (ads across eight named platforms), then splits into reporting vs management modes. It names siblings it delegates to (adkit_help for docs, adkit_feedback for gaps), so the agent can route without opening schemas. It is a broad catch-all tool, so its boundary against every other manage-capable sibling is not fully drawn.

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

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

Explicit routing is given for the main branches: entity:"results" for performance/spend/ROAS, entity:"benchmarks" for advertiser benchmarks with the from/for omission rules, entity:"platform-api-request" for unsupported native resources, entity:"media" for uploads, entity:"ads" for creatives. It does not explicitly say when NOT to use this tool (e.g. vs adkit_upload_file, which overlaps with the media upload flow).

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/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?

Annotations already declare openWorldHint=true, idempotentHint=false, and destructiveHint=false. The description adds valuable non-obvious constraints: beta status, which source types are accepted, that base64 and local paths are rejected, and that X and ChatGPT Ads are image-only. It stops short of describing success output or rate limits.

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-loaded with the beta flag and core action, then constraints, then failure routing. Dense and largely waste-free, though the middle sentence about upload URLs is slightly convoluted.

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 9-parameter mutation tool with nested objects and no output schema, the description covers sources, platform restrictions, rejection cases, and failure handling. It omits what a successful call returns (e.g., file id) and any permission requirements, which are minor gaps.

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

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

Schema description coverage is 100%, so every parameter is already documented in the schema, including the action semantics and the source object. The description restates the accepted source forms but adds no syntax or format detail beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Upload one file') plus the full set of destinations, so an agent can immediately distinguish this from adkit_library, adkit_studio, or adkit_manage. The scope constraint ('one file') is explicit.

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?

Clearly explains the two action modes ('upload' when the file is attached/URL/temporary upload; 'request_upload_url' only when the client cannot pass the file) and the fallback when no attachment or URL exists. It also routes failures to adkit_feedback, but gives no explicit guidance on when NOT to use this tool versus siblings.

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