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

With no annotations provided, the description carries full responsibility. It discloses that the tool is unavailable and that intelligence campaigns are planning-only, indicating the operation is not live and has no current effect. It does not speculate on error behavior, but it gives enough context to prevent an agent from expecting activation.

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

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

Two concise sentences carry maximum signal: the unavailability status first, then the correct alternative path. No filler, no repeated schema information. This is well-structured and 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?

The description tells the agent what not to do and names the live path, which is good. However, it instructs 'create a legacy-mode draft' without naming which sibling tool handles that path, leaving a small inference gap. Given the range of create_campaign* siblings, this is not fully complete conditional routing.

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 parameter bytes are already fully documented by the schema. The description adds no parameter-specific detail, but since the tool is disabled, parameter semantics are less relevant. Baseline 3 is appropriate.

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

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

The description clearly communicates that the tool is not currently available and that intelligence campaigns are planning-only, which immediately tells an agent this is not an active activation tool. It also differentiates itself from zuckerbot_launch_campaign by naming that sibling as the live path. It does not describe the operation's intended function in positive terms, but for a disabled tool this is the most relevant clarity.

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 is explicit: do not use this tool now; instead create a legacy-mode draft and use zuckerbot_launch_campaign for the supported live path. This gives the agent a firm instruction and a named alternative. This is the strongest possible 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?

With no annotations, the description carries the full burden. It discloses a behavioral side effect: 'this clears the stored page selection so you can pick a matching page.' This goes beyond simple listing and provides important context. It does not mention authentication or rate limits, but for a read-like operation, this is adequate.

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

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

The description is concise, consisting of two sentences that front-load the main purpose and then add a clarifying detail about the selection side effect. Every sentence earns its place with 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?

Given the simplicity of the tool (one optional parameter, no output schema, no nested objects), the description covers the purpose, usage context, parameter behavior, and an important side effect. It is complete for an agent to correctly invoke this 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 coverage is 100% for the single parameter select_id, and the parameter description in the schema is identical to the tool description's mention. Thus, the tool description adds no new semantic value beyond the schema. Baseline is 3, and no extra credit is warranted.

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 that this tool lists Meta ad accounts and shows the currently selected one, with an option to select a new account via select_id. It is specific about the verb (list/select) and resource (ad accounts), and distinguishes itself from sibling tools by its unique function of listing and selecting ad accounts.

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

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

The description explicitly says 'Call this during setup or when switching between multiple ad accounts,' providing clear context for when to use the tool. It does not explicitly state when not to use or mention alternatives, but the guidance is sufficient for an agent.

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

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

With no annotations, the description fully discloses behavior: for accounts with history, it returns aggregated metrics, top creatives, and CPL ranges; for new accounts, it returns is_cold_start=true and industry benchmarks. This transparently sets expectations about the two distinct outcomes based on account history.

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

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

The description is only two sentences: one explaining the tool's function for both account types, and one providing usage guidance. Every sentence is valuable and there is no redundancy, making it concise and well-structured.

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 no output schema, the description covers return values (aggregated metrics, top creatives, CPL ranges for history; is_cold_start and benchmarks for new accounts). It also explains the cold start scenario. However, it could be slightly more detailed on the exact format of aggregated metrics, but overall it is sufficiently complete for its role as a first-step analysis tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add significant new meaning beyond the schema; it reiterates parameter purposes (e.g., business_id auto-resolves, lookback_days range, target_audience optional check). No additional semantics are provided, so score remains at baseline.

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

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

The description clearly states the tool analyzes historical ad performance for a business, distinguishes between accounts with history (returns aggregated metrics, top creatives, CPL ranges) and new accounts (cold start flag with industry benchmarks), and positions it as the first step in campaign planning. This is specific and differentiates from sibling tools like zuckerbot_get_account_insights.

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?

Explicitly instructs 'Use this as the FIRST step in campaign planning — feed the result into zuckerbot_recommend_campaign_structure.' This provides clear context and a sequential workflow, effectively guiding the agent on when to use this tool versus alternatives.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It states the tool 'locks in the plan' but does not explain whether the action is reversible, what permissions are needed, or what the response looks like. This is minimal for a potentially critical mutation operation.

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

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

The description is just two sentences with no redundant words. The first sentence states the action and optional parameters, the second provides workflow context. 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?

The description lacks return value information (no output schema) and does not cover prerequisites or side effects beyond the sequential dependency. For a mutation tool, this is insufficient for an agent to fully understand the tool's behavior.

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%, providing a baseline of 3. The description adds value by explaining that tier_names and angle_names are 'optional subsets' for narrowing approval, clarifying their purpose in context. This goes beyond the schema 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 clearly states the tool approves an AI-generated intelligence strategy for a campaign, with optional narrowing to specific tiers and angles. It distinguishes from siblings by naming two subsequent tools that depend on this approval, making its role unique.

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

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

The description explicitly says when to use the tool ('before creative production starts') and provides a required sequence ('Required before calling zuckerbot_request_creative or zuckerbot_upload_creative'). However, it does not mention when not to use it or alternative tools for different scenarios.

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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It states that the operation is read-only, available on every tier, saves a shareable report only when the API key resolves to one saved business, and that the opportunity score is only produced when all inputs return. That is much more than a minimal safety disclosure.

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

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

Every part of the description earns its place: scope, expected deliverables, the score range, the conditional report side effect, the tier availability, and usage timing. It is front-loaded with the concrete audit purpose and the parenthetical 'when all inputs return' adds useful precision without bulk.

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

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

With no output schema available, the description does enough by naming the major return streams: spend flags, creative analysis, the score, and action items. It also covers the report side effect and tells the agent when this tool should be called first. An agent can confidently decide whether to invoke it and what to expect back.

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

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

Schema description coverage is 100%, so both parameters are already documented by the schema. The description adds little beyond the schema: it only lightly reinforces that company_name defaults to the connected business name and that meta_ad_account_id defaults to the connected account. That matches the baseline for full schema coverage.

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

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

The description opens with a specific verb and resource: 'Run a full audit of the connected Meta ad account', then enumerates distinct deliverables such as spend flagged against objective, creative fatigue, a 0-100 opportunity score, and prioritized action items. It is clearly distinguished from sibling analytics/insights tools like get_account_insights and get_performance because it frames itself as a full-account audit.

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 usage cue: 'the recommended FIRST call for any new account or when a user asks how are my ads doing?'. This is clear context, but it does not name alternative tools or say when the user should instead call a more targeted sibling like get_performance or get_account_insights, so it lacks explicit exclusion guidance.

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

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

Discloses that it reads billing information but does not explicitly state it's read-only. Acceptable for a simple lookup tool with no side effects.

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, front-loaded sentences with no redundancy. Every word adds value.

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

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

Given no parameters and no output schema, the description sufficiently covers what the tool returns (tier, usage, quota, overage). No 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?

No parameters exist, and schema coverage is 100%. Description adds no param info because none needed. Baseline 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?

Clear verb 'Check' and specific resource 'billing status' with explicit outputs: tier, usage, quota, overage. No sibling tool covers billing, so it's distinct.

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?

Explicitly states 'Use this when a user asks about their plan or usage limits.' Provides clear context for invocation.

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

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

No annotations are provided, so the description carries full responsibility and handles it well. It warns that 'attributed' does not mean Meta-side event matching, explains attribution requires leads_retrieval permission and a bounded backlog resolution, and instructs agents to read attribution.basis and attribution.note before drawing conclusions. This is precisely the kind of behavioral nuance that structured metadata cannot convey.

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

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

The description is two sentences with a clear front-load: what is returned, followed by an IMPORTANT caveat block. Every clause either introduces a needed metric or prevents a dangerous misinterpretation. The extra warning length is justified by the ambiguity of the 'attributed: 0' case.

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

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

With no output schema, the description itself names all metric categories present in the result: total events, events per type, match quality, identifier coverage, meta_events_received, and attribution counts. It also discloses the permission requirement and the heuristic nature of attribution. An agent given this description plus the optional parameter schema has enough context to call the tool and interpret its output correctly.

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

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

Schema description coverage is 100% since selectable_details/uses. The input schema already states that business_id is an optional business ID override, and the description does not add further parameter-specific semantics such as default behavior, allowed values, or relationship to the current business. Baseline 3 is appropriate because the parameter meaning is already fully 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?

The description opens with a specific verb and resource: 'Get 7-day and 30-day CAPI delivery statistics for the business', then enumerates the exact metrics returned. The metric specificity distinguishes it from nearby CAPI siblings such as zuckerbot_get_capi_config, zuckerbot_capi_test, and zuckerbot_send_capi_event without needing to name them.

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 this is the tool for reading CAPI delivery statistics, but it does not explicitly state when to use this tool versus alternatives or when not to use it. The guidance it provides is about interpreting result fields (e.g., delivery health is meta_events_received, not attributed), rather than tool-selection context.

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

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

Without annotations, the description carries full burden. It discloses key behavioral traits: 'Logs as a test event (does not affect real attribution)' and implies the event is sent to Meta Graph API but as a synthetic test. This adequately conveys non-destructive behavior, though more detail on side effects or permissions could strengthen transparency.

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

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

The description consists of two concise sentences. The first sentence clearly states the action and purpose; the second adds a critical behavioral disclaimer and usage suggestion. No wasted words, front-loaded with the core idea.

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 all 8 parameters are optional, schema coverage is 100%, and no output schema exists, the description is fairly complete. It covers purpose, usage timing, a key behavioral trait, and the testing nature. It does not mention expected output or error scenarios, but is adequate for a straightforward test 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?

With 100% schema description coverage, the baseline is 3. The description adds high-level context (e.g., 'verify raw passthrough') but does not significantly enhance parameter meaning beyond the schema's existing descriptions of each property.

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 'Send a synthetic CAPI test event' and explicitly distinguishes from real event sending (e.g., zuckerbot_send_capi_event) by noting 'does not affect real attribution' and 'Logs as a test event'. This provides a specific verb+resource and distinguishes from 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 advises 'Use after setting up or updating CAPI config to confirm events are flowing', giving clear context for when to apply the tool. It does not explicitly exclude other uses, but the guidance is sufficient for a testing tool among related CAPI siblings.

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

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

No annotations exist, so the description carries the full burden. It discloses the dry-run default, the execute plus idempotency_key gate, and that ads are 'ALWAYS created PAUSED.' It further surfaces operational details such as image_url auto-upload, the processed/ready requirement for video_id, automatic thumbnail derivation, and the image_hash_unusable failure mode.

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

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

The description is long but dense, front-loading purpose and dry-run behavior in the first two sentences, then organizing asset and destination constraints into compact clauses. Each sentence contributes a necessary constraint or alternative, so there is 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?

Given 17 parameters, no output schema, and no annotations, the description still covers the creation workflow, safety defaults, asset sourcing, destination rules, pause state, and the clone alternative. It even names a specific failure mode and points to zuckerbot_upload_ad_asset for asset IDs, leaving very little ambiguity 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%, so the baseline is 3, but the description adds meaning beyond the schema by tying parameters together: the final_url vs lead_form_id exclusivity, VIDEO + final_url requiring cta, cta being required for instant forms, the account-specific image_hash requirement, and idempotency_key being required when execute is true. This materially helps an agent construct a valid request.

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

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

The description opens with a specific verb and resource: 'Create ONE new ad' 'in an EXISTING ad set of the connected ad account,' and specifies the two asset types. It also distinguishes itself from the clone alternative by positioning this tool as the path for brand-new creatives, so an agent can separate it from the sibling list without reading 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?

Explicit when-to-use guidance is present: 'the way to add a brand-new image or video into a campaign that is already running,' and it names the alternative for cloning with 'use zuckerbot_duplicate_ad instead.' It also sets clear exclusions such as 'exactly one of final_url or lead_form_id' and the need to pass execute: true to move past the dry-run.

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

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

No annotations are provided, so the description carries the full disclosure burden. It excels by stating that legacy mode is the only launch-ready path, that intelligence mode 'cannot be activated', that it 'does not spend money or create anything on Meta', and that it only produces a draft that must be reviewed — these are materially important safety and state facts. No contradiction with annotations exists because none were 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?

Three sentences with zero filler: primary purpose first, then the mode limitation, then the critical side effect ('does not spend money or create anything on Meta') and the follow-up action. Every sentence adds information that is not a restatement of the 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?

The description omits any hints at that a draft's output shape or lifecycle (e.g. what the returned draft ________ variable contains, how the caller should use it with preview_campaign). There is no output schema as a second signal, so the description should indicate that the result is a multi-section draft ready for review and downstream handoffs. The mode note and the follow-up tool call do carry the agent a lot of the way, but a small 'return design' clarification is absent.

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 documents every parameter, including enums, defaults, and nested goal/location/creative fields. The description adds only minor parameter-level context (reiterating that legacy mode is the default and launch-ready), which slightly reinforces the mode semantics but doesn't compensate for anything the schema already covers. 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 states a specific verb and resource — 'Create a new campaign draft for a business' — which clearly distinguishes it from launch and activation tools. It doesn't explicitly differentiate from zuckerbot_create_full_campaign or zuckerbot_create_campaign_from_spec, but the 'draft' framing plus the launch_campaign handoff makes the primary purpose unambiguous.

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

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

It provides clear usage context: it creates a draft, does not spend money or touch Meta, and the agent is told to review the draft and then use zuckerbot_launch_campaign. It implicitly excludes zuckerbot_launch_campaign and zuckerbot_activate_campaign for this step, but it doesn't explicitly compare against the other draft/creation siblings (create_full_campaign, create_campaign_from_spec, quickstart).

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

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

There are no annotations, so the description carries full responsibility, and it does so thoroughly. It discloses that everything is created paused, that validation failures return a structured errors array, that location discovery runs only on the real build, that name resolution is strict and never silently substituted, and that identity falls back automatically but reports the result. These are meaningful behavioral traits well beyond what the schema shows.

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 purpose, paused behavior, and the recommended flow, then moves into the spec shape. It is very long, but the complexity of the nested spec justifies most of the length. It could be improved with clearer visual structuring or section breaks, but every sentence carries real 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?

Given the high complexity, lack of annotations, and absence of an output schema, the description covers a remarkable amount of needed context: the spec shape, validation error format, response fields like instagram_identity and resolved_locations, credential requirements, and edge cases like ambiguous location names. An agent has enough detail to invoke the tool correctly and interpret common outcomes.

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

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

Although schema description coverage is 100%, the schema itself only says 'see tool description for the shape.' The description then supplies the entire nested spec grammar, including allowed enum values, conditional fields, constraints like radius bounds, and credential implications. dry_run is also explained with a strong recommendation, making the parameters actionable.

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 opening sentence states a specific verb and resource: 'Build a complete Meta campaign VERBATIM from a declarative JSON spec.' It explicitly disambiguates from strategy/copy tools with 'no strategy generation, no copy authoring,' and clarifies the paused-by-default behavior that separates it from launch tools. This is exactly the differentiation an agent needs among the large sibling set.

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

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

The description gives a explicit recommended flow: run dry_run=true first, review payloads, then re-send without dry_run. It also states when identity is optional vs required, when credentials are needed even for dry_run, and points to sibling tools like zuckerbot_upload_ad_asset and zuckerbot_list_custom_conversions. This gives clear when-to-use and when-not-to-use guidance.

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

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

With no annotations provided, the description must fully disclose behavior. It partially covers permissions and error returns but omits key details: side effects, idempotency, return value on success, or asynchronous behavior. This leaves agents uncertain about the tool's full impact.

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, no redundant words, and the most critical information (purpose, prerequisites, error handling, parameter list) is front-loaded. Highly concise and well-structured.

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

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

The tool has 5 parameters with nested objects and no output schema. The description does not explain what the tool returns (e.g., conversion ID, status), nor does it clarify if the operation is synchronous. For a creation tool, this leaves significant gaps in the agent's understanding of the outcome.

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 parameters. The description adds an example for the rule parameter but largely restates schema information. Baseline score of 3 is appropriate as the description provides minimal additional meaning 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 explicitly states 'Create a custom conversion on the connected ad account', using a specific verb and resource. It clearly distinguishes from sibling tools like list_custom_conversions and other creation 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 mentions prerequisite permissions and an error case (insufficient_permission). It lists required and optional parameters, providing some usage context. However, it does not explicitly state when to use this tool over alternatives, though the context of custom conversion creation is 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?

Discloses critical behaviors: dry_run produces a preview without side effects, live mode creates PAUSED Meta objects, auto-activation is disabled, and generated videos link for rejection tracking. With no annotations provided, the description carries the full burden and largely meets it, though it omits details on idempotency or authentication requirements.

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

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

Five sentences with clear structure: purpose, important default, dry_run flow, live mode behavior. Front-loaded with key action. No wasted words; every sentence adds value.

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

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

Given the complexity (6 params, no output schema), the description covers the main workflow and side effects. It mentions return structure for dry_run (campaign structure) but does not describe the return format for live mode or error handling. Sibling tools context is clear, placing this as a middle step in architect workflow.

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. The description adds significant value by explaining the dry_run/activate parameter workflow and the approval process, which is not evident from schema alone. This context helps the agent understand parameter interactions and usage order.

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 it builds a complete PAUSED Meta campaign from an approved Campaign Architect session, using a specific verb ('Build') and resource. It distinguishes from siblings like zuckerbot_create_campaign or zuckerbot_launch_campaign by emphasizing the session-based, approval-driven workflow.

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?

Explicitly states the dry_run default, the safe preview, and the need for customer approval before setting dry_run=false. It also mentions that live mode creates PAUSED objects and auto-activation is disabled. Implicitly positions the tool after an approved architect session, but does not explicitly exclude alternatives like zuckerbot_activate_campaign.

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?

Describes the core behavior of expanding a seed into a lookalike with typical percentages. No annotations provided, so description carries full burden; however, it omits details like idempotency, error handling, or authentication requirements.

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

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

Two concise sentences with no fluff. First sentence states purpose, second adds key details. Front-loaded and 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?

No output schema; description does not mention return value (e.g., new audience ID). For a creation tool, this is a notable gap. Otherwise covers purpose and typical use adequately.

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 covers all four parameters with descriptions. Description adds usage context (typical percentages 1, 3, 5) and clarifies that seed_audience_id references a stored row, adding value beyond 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?

Clearly states verb 'create' and resource 'lookalike audience' from a seed. Distinguishes from sibling tools like create_seed_audience and delete_audience by specifying it expands a seed into a prospecting audience.

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 context that it's for prospecting tier of an intelligence campaign. Implicitly differentiates from deletion or listing tools but lacks explicit when-not-to-use or prerequisites like seed must exist.

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

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

With no annotations, the description carries the full behavioral burden and does provide meaningful disclosure: portfolios are planning/monitoring-only, launch is unavailable, and budgets are split into prospecting, retargeting, and reactivation tiers with per-tier CPA targets. It does not cover response shape or edge cases, but the major operational constraint is clear.

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, front-loaded with the core action, and every sentence adds either scope, supported source, or a key limitation. There is no redundant or filler 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?

Given no annotations and no output schema, the description gives sufficient context for an agent to understand the tool's purpose, constraints, and behavior, including the critical no-launch limitation. It also explains how tiers and budgets work so the agent can reason about the 7 optional 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 baseline is 3. The description adds value by explaining how the parameters relate: a total budget is split across tiers using percentages, and CPA targets apply per tier. It also clarifies the template vs custom tier selection model, going beyond the raw field names.

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 portfolio, and qualifies it as multi-tier, audience-based, planning/monitoring-only, and sourced from a template or custom array. This clearly distinguishes it from sibling portfolio tools like get_portfolio, update_portfolio, rebalance_portfolio, and launch_portfolio.

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 clear context: the agent should use this tool to create a planning/monitoring portfolio and explicitly says portfolio launch is not currently available, avoiding incorrect expectations. It does not explicitly name sibling alternatives, but the create-versus-manage distinction is strongly implied.

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

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

With no annotations, the description carries the full behavioral burden. It credibly goes beyond a simple statement of creation by describing the recovery-mode behavior: 'skips Meta audience creation and user upload and only writes the registry record.' It also adds context around verification against the bound ad account. It could still disclose more about side effects, failure behavior beyond the referenced error, or prerequisites, but what is present is substantive.

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 primary action, then seamlessly folds in the selective recovery case. The adopt-explanation sentence is somewhat complex but necessary and not inflated. Every sentence conveys distinct information, and nothing feels redundant with sibling context or the 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?

The description covers the normal path and the recovery path quite well, but with no output schema and no annotations, the agent is still left without clarity on what the tool returns after a successful registry write, whether a audience ID is returned for downstream steps, or what happens when min_contacts is not met. Since the tool is positioned as a first step in a pipeline, describing its output would meaningfully complete the picture.

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 adds meaning beyond the schema by explaining that source_stage controls which CRM lifecycle stage seeds the audience and that adopt_meta_audience_id is not just a field but a full recovery path that bypasses creation. This goes beyond the schema's short descriptions and helps an agent reason about live business semantics.

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

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

The description uses a specific verb ('Build') and names the exact resource ('a Meta custom audience') plus the key input ('hashed CAPI user data', 'CRM lifecycle stage'). It clearly distinguishes itself from sibling audience tools like list_audiences, refresh_audience, and create_lookalike_audience by explaining it is the first step in seed creation and by detailing the recovery path via adopt_meta_audience_id.

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

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

The description explicitly says when to use this tool with 'Use this as the first step to create retargeting or reactivation audiences from your own first-party CRM data.' It also specifies a concrete recovery use case for the adopt_meta_audience_id parameter, which disambiguates an important scenario. However, it does not explicitly contrast against sibling tools like create_lookalike_audience or refresh_audience.

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

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

With no annotations, the description carries the disclosure burden. It explains the return content: per-group CPL/CTTR/CPC/frequency averages, trend direction, structured recommendations, and optionally top/bottom adds. This gives a helpful expected-behavior contract for a read-oriented analysis tool. It doesn't't disclose whether the operation is strictly read-only, limited, or any edge-case handling, but for an analysis tool it's usefully 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 composed of three purposeful, front-loaded sentences: the tool's action, the output, and its recommended use in the workflow. It could be tightened (not enum values already in the schema with slightly redundant lists), but it remains efficient and well structured.

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?

Output description is present because there is no output schema, and it covers the most important return components. Given the tool has 11 optional params and 1 required, the combination of the `group_by` intro and high-coverage schema gives a complete context for most calls. It doesn't mention `cohort`, `summary_mode` implication in the main description, but their schemas already describe those behaviors.

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 11 parameters completely, including enums and meanings, so the baseline applies. The description does not add substantial per-parameter meaning beyond schema: it largely paraphrases `group_by` and the metric set. That is acceptable, but leaves gumption at baseline.

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

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

The description uses a specific verb and resource ('Analyse creative performance patterns... grouping ads by...') and enumerates grouping and metric options. It clearly communicates what the tool does. However, it does not explicitly distinguish itself from `zuckerbot_created_cross_analysis`, similarly creative performance name the same resource family, so it doesn't fully earn the top cluster on differentiation.

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

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

The description explicitly says 'Use this before generating new brief so inform the creative strategy.' This is clear contextual when-to-use instruction. However, it does not say when-to-use vs the sibling trools or explicitly exclude alternatives when they might be better fits.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does convey what the call produces (a performance matrix, best/worst combinations, and an actionable insight string), which is useful return-format context. It does not disclose the read-only nature, whether it requires prior creative-attribute data, or how the insight string is generated, leaving some ambiguity about data dependencies.

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

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

Three sentences with zero filler: purpose, example, return format. The purpose is front-loaded, the example earns its place by clarifying the abstract 'cross' idea, and the returns sentence completes the agent's mental model. Efficient and well-ordered.

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

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

For a read-style analysis tool with 9 parameters, no output schema, and a relatively simple query intent, the description covers the essential contract: what it does, an illustrative usage, and what it returns. The main gaps are lack of explicit relation to cohort/objective_family advanced filter behavior and no statement about read-only safety, but the schema covers the filters and the tool complexity is low enough that this is not 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 coverage is 100%, and every one of the 9 parameters already has its own description, so the baseline is 3. The description reinforces that group_by and cross_by are the two dimensions being 'crossed' and that the combination order matters (hook_type × visual_style yields a cell like curiosity + ugc), but it adds no new parameter-level detail beyond the schema.

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

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

The description states a specific verb ('cross') and resource ('two creative dimensions') with a clear goal ('find winning combinations'), and the hook_type × visual_style example makes the operation concrete. It distinguishes itself from the sibling zuckerbot_creative_analysis through the word 'cross' implying a two-dimensional comparison, though it never explicitly names the sibling or contrasts itself against it.

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

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

The example implies the intended use — pairing two creative dimensions (e.g., hook_type × visual_style) to surface winning patterns before building creative. However, there is no explicit guidance on when to choose this tool over zuckerbot_creative_analysis, suggest_angles, or get_performance, and no 'when-not-to-use' or prerequisite context (such as needing uploaded creatives or business context).

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

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

With no annotations, the description carries the full burden of disclosure. It states the tool returns a 'pattern-match score' and accepts raw specs, implying a read-only operation with no side effects. However, it does not explicitly confirm safety (e.g., no data modification) or address permissions, latency, or error scenarios. The description is adequate but not fully 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 concise: two sentences clearly state purpose, input/output, and usage advice. No redundant or extraneous words, and critical information is front-loaded. Every sentence serves a purpose.

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

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

Given the tool's simplicity (2 parameters, no nested objects, no output schema), the description covers purpose, inputs, output (pattern-match score), and usage timing. It is mostly complete for an agent to decide when and how to invoke it. Minor gaps include lack of detail on scoring methodology or data prerequisites, but these are not critical for invocation.

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

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

Schema coverage is 100%, with all parameters already well-documented. The description adds context by listing examples like 'copy, headline, CTA, asset URLs, frame URLs', but this largely echoes the schema. For a high-coverage schema, the baseline is 3, and the description does not significantly enhance understanding 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 clearly states 'Score proposed creative variants against the business's historical top-performing patterns', providing a specific verb (score) and resource (creative variants). It distinguishes from sibling tools like zuckerbot_suggest_angles (which suggests new angles) and zuckerbot_creative_analysis (which likely analyzes existing creatives).

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

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

The description explicitly advises 'Use this before producing expensive creative assets to pre-validate concepts against what has historically worked', giving clear usage context and benefit. However, it does not explicitly mention when not to use it or provide alternative tools, which would warrant 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?

With no annotations, the description carries full burden. It discloses the permanent, irreversible nature and that deletion affects both Meta and local registry. It does not cover error cases or prerequisites, but is still informative.

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 zero waste. The first states action and scope, the second gives usage context. Every part is essential.

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 simple delete function with one parameter and no output schema, the description covers the core purpose, permanence, and use cases. It lacks mention of response or potential errors, but for a straightforward delete it is adequate.

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. The description does not add further meaning beyond the schema's 'Stored audience row ID'. No additional parameter details are provided.

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 it permanently deletes an audience from both Meta and local registry. It uses a specific verb and resource, distinguishing it from list, create, or refresh sibling tools.

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

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

It explicitly mentions when to use: stale audience, creation error, or freeing up slots. While it does not explicitly state when not to use, the listed use cases are sufficient and imply alternatives (e.g., refresh).

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

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

There are no annotations, so the description carries the full behavioral burden, and it succeeds strongly. It discloses that the tool is dry-run by default, that execute:true actually creates the ad, that the created ad is ALWAYS paused, that a new creative is always built, and that unsupported creative types are rejected with the unsupported feature named.

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 every sentence earns its place. It front-loads the main action, then steps through execution behavior, safety-relevant paused state, source-shape constraints, and finally a named sibling alternative, all without unnecessary fluff.

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 an 11-parameter tool with no annotations and no output schema, the description is remarkably complete: it covers the return shape, success path, failure modes for unsupported creatives, idempotency, cross-account restriction, and post-creation behavior. There is no obvious gap that would leave an agent guessing on how 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 already covers 100% of parameters, which sets a baseline of 3. The description adds meaningful context beyond the schema by specifying supported source shapes for the source_ad_id, explaining that creative IDs are never reused, and tying execute/idempotency_key together as a paired behavior.

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

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

The description opens with a specific verb and resource: "Duplicate ONE supported ad into an existing ad set in the SAME ad account." It distinguishes itself from siblings by explicitly contrasting with zuckerbot_create_ad and zuckerbot_upload_ad_asset. The supported-source limitations further clarify exactly what this tool operates on.

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 tool makes clear when to use it and when not to: it is for duplicating existing ads, while zuckerbot_upload_ad_asset + zuckerbot_create_ad is the named alternative for introducing brand-new assets. The dry-run vs. execute path and the required idempotency_key usage are also explicitly described.

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?

Without annotations, the description carries full burden. It discloses the crawling and extraction behavior and the force_refresh option, but lacks details on potential failures, side effects (e.g., data modification), or output format. Adequate but incomplete.

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 effectively convey core purpose and usage guidance with no redundant words, making it easy for an agent to parse.

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

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

The description covers the main purpose and usage but lacks details on return value structure, error handling, or prerequisites (e.g., needing a stored business). Given no output schema, the description should provide more context for completeness.

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

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

Schema coverage is 100% and schema descriptions already explain parameters well. The description adds context for force_refresh usage but doesn't significantly extend beyond the schema, meeting the baseline for high coverage.

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

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

The description explicitly states the action ('crawl and extract') and the resource ('business website') with detailed output examples (company description, services, etc.), clearly distinguishing it from sibling tools like research_reviews or research_competitors.

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 guidance on when to use the tool ('before creating a campaign when the business has not been enriched') and when to use force_refresh, but does not explicitly mention when not to use it or list alternatives.

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

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

No annotations were provided, so the description carries the full burden of behavioral disclosure, and it does so exceptionally. It documents the bare-id semantics versus Meta's CSV 'l:' prefix, UTC and inclusive date semantics, the exact permission requirement, the error behavior when permission is missing, and the truncation/cap behavior. Nothing in the description conflicts with the structured information.

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 purpose and each subsequent sentence earns its place by addressing a specific operational concern. It is dense and information-rich without becoming bloated or redundant.

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 there is no output schema, the description provides the minimum necessary return expectations, date handling, permission requirements, CSV-ID caveat, and pagination/truncation behavior. It also routes the agent to the correct sibling for metadata, making this roughly complete for correct invocation and interpretation.

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

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

The schema already documents all three parameters, so the baseline is 3. The description adds meaning by clarifying that dates are inclusive and by telling the agent where to obtain form_id values. This is genuinely useful, but the schema still carries most of the parameter-level burden.

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-resource operation ('Export lead submissions from a Meta instant form') with date range and an explicit list of returned fields (id, created_time, submitted field values). It is clearly distinguishable from the sibling list tools, especially by pointing the caller to zuckerbot_lead_forms for finding form ids.

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 tells the agent when the tool is appropriate, how to obtain the required form_id, and what to do when results are truncated: narrow the date range and re-call. It also names the permission prerequisite, so the agent can route errors to the correct remediation without guessing.

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

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

With no annotations, the description carries full burden. It reveals that briefs are 'weighted toward the top-performing creative attributes,' which is a key behavioral trait. It does not mention destructive actions, auth needs, or rate limits, but as a generation tool it is likely non-destructive.

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

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

Two concise sentences: first defines the tool's purpose and output components, second provides usage guidance. No redundant or extraneous 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?

Given 7 parameters, no output schema, and the generative nature, the description is complete. It explains what the generated briefs contain (hook type, etc.) and the weighting logic. It also references the prerequisite tool for proper usage.

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% (all 7 parameters have descriptions). The description adds value by explaining how parameters like 'bias' and 'metric' influence the weighting toward top performers, beyond the schema's basic 'Optional generation bias' etc.

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 'Generate creative production briefs based on the business's tagged ad-performance patterns' and specifies the components of each brief (hook type, visual style, etc.). It distinguishes itself from sibling tools like zuckerbot_generate_campaign_brief by focusing on creative production and requiring prior analysis.

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

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

The description explicitly says 'Use after running zuckerbot_creative_analysis to know which patterns to bias toward,' providing a clear precondition. It does not mention when not to use or alternatives explicitly, 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?

With no annotations, the description fully assumes responsibility. It discloses safety (non-destructive, read-only), notes automatic data pulls (brand context, historical patterns), and explains cold-start behavior. Transparent about internal workings.

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?

Concise, front-loaded with purpose, safety, and workflow. Every sentence adds distinct value: purpose, safety, input sourcing, output details, next steps. 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?

Complete for a generation tool with no output schema: describes return format (per-slot directions, static/video details) and includes workflow context (present to customer, call ad generation tools). No missing information.

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% with good descriptions, but the tool description adds value by explaining parameter relationships (session_id vs approved_structure, auto-resolution of business_id) and intent of additional_creative_direction, going beyond 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?

Clearly states the tool generates a detailed creative brief from an approved campaign structure, specifies inputs and outputs (per-slot creative directions), and distinguishes from sibling tools by naming subsequent steps (zuckerbot_generate_static_ad / zuckerbot_generate_video_ad).

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?

Explicitly declares safety ('SAFE — pure function, no Meta API calls'), clarifies when to use (after campaign structure approval), and provides workflow guidance ('present to customer, then call...'). Lacks explicit 'when not to use' but 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?

With no annotations provided, the description fully discloses key behaviors: auto-pagination, truncation with a truncated flag, and the effect on data coverage. It also warns that zero-delivery days are legitimately absent and advises comparing the covered range with the requested range.

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 well-structured with the core purpose first, followed by details and caveats. It is slightly lengthy but every sentence adds value (e.g., truncated behavior, zero-delivery days). 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?

Despite lacking an output schema, the description lists return metrics, response fields (row_count, covered, truncated), and handles edge cases (truncation, missing zero-delivery days). This is comprehensive for a read-only data fetch 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 coverage is 100%, so the baseline is 3. The description confirms the date range and time_increment usage but adds no new semantics beyond what the schema already provides. It mentions auto-pagination but does not add parameter-specific 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?

The description specifies the exact action (fetch historical Meta ad account performance), the resource (connected business over a date range), and the specific metrics returned (spend, clicks, impressions, CTR, CPM, CPC, frequency). It clearly distinguishes from sibling tools like zuckerbot_get_campaign_insights by focusing on account-level performance.

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?

Explicitly states the tool is 'useful for top-level budget reporting and month-over-month trend analysis without opening Ads Manager.' While it doesn't explicitly say when not to use or name alternatives, the context implies it's for aggregate account data vs. campaign-specific 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?

With no annotations, the description carries the full behavioral burden. It transparently explains that ready=true must be observed before proceeding, that a derived thumbnail_url accompanies it, and that polling is the expected pattern. It does not disclose failure states or how processing errors surface, but the core polling behavior is well 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?

The description is three tight sentences with no filler. It front-loads the status-check purpose, then presents the ready semantics and polling cadence, with every sentence earning 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?

Given the lack of an output schema, the description sufficiently explains the return signal (ready=true), the derived thumbnail_url, and the down-stream VIDEO ref usage. It stops short of covering processing-failure states or what to do if the status never becomes ready, so it is not fully exhaustive, but it is complete enough for normal 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 fully documented in the input schema. The description adds the useful context that video_id comes from zuckerbot_upload_ad_asset, but it does not otherwise deepen meaning beyond the schema's own 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 verb and resource: 'Check Meta's processing status for a video uploaded with zuckerbot_upload_ad_asset.' It clearly identifies the tool as a status-checking endpoint and distinguishes it from uploading, creation, and generic creative-status tools by tying it to the ad-asset upload flow.

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

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

The description gives a clear execution context: call it after uploading an ad asset and before using the video in zuckerbot_create_ad or a from-spec VIDEO ref. It also gives explicit polling guidance (every 15–30 seconds while ready=false), though it does not explicitly state when not to use it or name alternative status 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?

Discloses the side effect: 'Updates the local audience registry row'. Without annotations, the description carries the full burden, and this is a key behavioral trait. It also implies it's a read operation with a minor write, which is 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?

Two sentences, no fluff, front-loaded with purpose and usage. Every sentence adds value without redundancy.

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

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

For a simple tool with one parameter and no output schema, the description covers the action (fetch with side effect), the specific data fetched (delivery status, size, readiness), and the use case (pre-launch check). It is complete for an agent's needs.

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 already covers 'Stored audience row ID' for the single parameter. The description adds no new meaning beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states it fetches Meta delivery status, size, and readiness for a stored audience, with a specific verb and resource. It distinguishes from sibling tools like 'delete_audience' and 'refresh_audience' by focusing on checking status for campaign readiness.

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?

Explicitly says to use this tool to 'check if an audience is large enough to use in a campaign before launch'. While it doesn't mention alternatives or when not to use, this provides clear context for when to invoke it.

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

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

With no annotations provided, the description carries the full burden. It clearly implies a read-only operation by saying 'fetch', but does not explicitly confirm non-destructiveness, mention rate limits, or describe behavior on missing IDs. The listed return fields help but leave behavioral aspects partially uncovered.

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 first packs the core functionality with specific details, the second gives usage guidance. Every sentence adds value; the description is optimally concise.

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

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

For a single-parameter, no-output-schema tool, the description is fairly complete. It lists the kinds of details returned, asserts lifecycle-stage flexibility, and differentiates from siblings. It lacks error-handling info, but the simplicity mitigates 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 coverage is 100%, so baseline is 3. The description adds that the ID is used 'by ID' and lists the return fields, but does not provide additional meaning or format beyond what the schema already states ('ZuckerBot campaign ID').

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 ('fetch') and resource ('full details of a ZuckerBot campaign by ID'), lists concrete components (intelligence workflow state, approved strategy, etc.), and clearly distinguishes it from sibling tools like get_campaign_insights or get_performance which serve narrower purposes.

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 states to use this tool 'to inspect a campaign at any stage of the lifecycle', providing clear positive guidance. However, it does not explicitly mention when not to use it or point to alternatives, missing an opportunity for full differentiation among siblings.

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

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

With no annotations, the description carries full burden. It discloses that rows are tagged with is_zuckerbot for benchmarking, explains status_scope and status_synced_at, notes that spend-by-date is authoritative for delivery, and mentions cache bypass via refresh. It does not explicitly state it is read-only, but the query nature is clear. Minor omission of explicit non-destructive statement prevents 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 description is lengthy but well-structured, front-loading the core purpose and then layering details. Every sentence provides useful guidance (metric preferences, status handling, benchmarking). It could be slightly more concise by grouping related details, but the density is justified by the tool's complexity.

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 11 parameters, no output schema, and no annotations, the description covers the main aspects: purpose, filtering, sorting, metrics reliability, status interpretation, and cache behavior. It does not mention error scenarios or rate limits, but for a read-only query tool this is acceptable. The thorough metric guidance and benchmarking feature make it quite 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% with descriptions for all 11 parameters. The description adds significant value beyond schema by explaining preferred sort values (meta_result, conversion_leads), clarifying deprecated metrics (leads/cpl), detailing status filter behavior (simple vs legacy), and describing refresh, time_increment, and status semantics. This goes well beyond baseline schema 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 clearly states the tool queries campaign, ad set, or ad-level performance for any campaign in the connected Meta ad account. It specifies the resource (campaign/adset/ad-level performance) and action (query), and distinguishes from sibling tools by noting it includes campaigns not created by ZuckerBot and provides benchmarking via is_zuckerbot tag.

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 on when to use this tool (for performance queries) and includes detailed guidance on metric selection (prefer meta_result over deprecated leads) and reliability conditions (campaign-level, non-time-incremented). However, it does not explicitly contrast with sibling tools like zuckerbot_get_account_insights or zuckerbot_get_campaign, which would strengthen when-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It discloses a critical constraint: the webhook secret is write-only, with reads only returning set and last4 fields. However, it could mention any required permissions or authentication context, but given the tool is read-only, the transparency is good but not exhaustive.

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 sentences front-loaded with purpose, followed by usage guidance, then a behavioral note. Every sentence adds value and there is no fluff. It is well-structured for quick comprehension.

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 read with one optional parameter and no output schema, the description lists all returned fields (CAPI delivery, CRM source, currency, mappings, action source, webhook URL) and covers the important behavioral constraint on the secret. It is complete for an AI agent to understand what it does and what to expect.

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

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

The single optional parameter 'business_id' is fully described in the input schema with a clear description. The description adds no additional meaning beyond the schema, and schema coverage is 100%, so the baseline of 3 is appropriate.

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

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

The description clearly states it fetches the Conversions API configuration for a business and lists specific fields: CAPI delivery, CRM source, currency, stage-to-event mappings, action source, and webhook URL. It distinguishes from sibling tools like set_capi_config and rotate_webhook_secret by emphasizing its read-only nature and the write-only secret behavior.

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 guidance on when to use: 'Use this before configuring CAPI to see what is already set, or to audit the current event mapping.' Also specifies when not to rely on it for the full webhook secret and points to the sibling tool zuckerbot_rotate_webhook_secret as the alternative.

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

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

Even with no annotations provided, this description carries the full behavioral load: it discloses the read-only nature, confirms no extraction is triggered, confirms no spending occurs, and details included lifecycle fields such as tag_status, error_class, attempt metadata, and version/fingerprint information. That gives the agent an accurate mental model of what will happen.

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 packed with useful information but remains organized and front-loaded with the core 'read' action and resource. The three long sentences are dense, yet every clause adds context about shape, lifecycle, read-only behavior, or intended usage. It is borderline long but not bloated given the lack of an output 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?

The description compensates for the missing output schema by enumerating the returned shape: 17 extracted attributes, lifecycle, versions, fingerprints, and objective family. It also provides the correct temporal context relative to sibling tools. The main gap is unspecified behavior for invalid or missing ad IDs, but all core retrieval aspects are covered.

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 each parameter already has a meaningful description. The natural-language description adds context such as the 'up to' limit and the canonical data shape, but it does not materially extend the schema's parameter-level explanations. A baseline of 2 is therefore appropriate: the schema handles the 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 begins with a specific verb and resource: 'Read the stored creative attribute tags' in the 'canonical creative_attributes.v1 shape'. It clearly distinguishes this from sibling analysis tools by emphasizing that it only reads already-stored rows rather than running analysis or extraction.

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

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

The description gives explicit sequencing: use after zuckerbot_audit_account reports creative analysis complete, or before zuckerbot_creative_analysis to inspect individual ads. It also signals the safety aspect, 'never triggers extraction and never spends anything,' which tells the agent when low-cost inspection is appropriate. It does not enumerate all exclusions, but the contextual guidance is strong.

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

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

With no annotations, the description carries full burden. It discloses the poll returns all_complete=true when jobs finish and notes intelligence activation is temporarily disabled. However, it doesn't mention rate limits or other edge cases.

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

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

The description is concise (two sentences) and front-loaded with purpose, then usage guidance. No wasted words.

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 polling tool with 1 param and no output schema, the description covers purpose, usage, return value, and a state note. It feels complete given the context.

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

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

Schema coverage is 100% with campaign_id described as 'Intelligence campaign ID'. The description adds no extra meaning beyond this.

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

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

The description clearly states the tool checks the async upload queue for a campaign to see if Meta ad-creation jobs are complete. It uses specific verb 'check' and resource 'queue', and distinguishes itself from siblings like zuckerbot_upload_creative and zuckerbot_get_campaign.

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

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

The description explicitly advises to poll this after zuckerbot_upload_creative when creative_status='uploading', providing clear when-to-use context and an alternative (the upload 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?

With no annotations, the description carries the full burden of safety and side-effect disclosure. It adds meaningful context: this is a pure read of an already-bound ad engine, never binds or consumes a slot, and stats requests are capped at 90 days by default 30. This tells the agent things it would not otherwise know about the tool's behavior and 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?

The description is dense but every sentence earns its place: the first defines scope and output fields, the second defines optional stats parameters, the third clarifies side-effect behavior. There is no redundant language and the key limitation (read-only, no slot consumption) 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?

There is no output schema, so the description must explain what gets returned — it virtually lists the fields. It also covers interesting behavior, optional stats, defaults, and the clean-read side effect. Given 6 parameters (5 optional, 1 required) and a simple no-nested object shape, everything an agent needs to make a correct call is present.

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 goes further by clarifying that include_stats expects an explicit bounded window, that the default window is last 30 days and is capped at 90, and by giving the fields returned. This meaningfully supplements, though schema already owns most per-parameter 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 'Read one custom conversion in full' — a specific verb plus resource telling the agent exactly what the tool does. It enumerates the returned fields and distinguishes this from listing by saying 'one custom conversion,' so it can be differentiated from zuckerbot_list_custom_conversions and zuckerbot_create_custom_conversion without inspecting 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 clearly frames the tool as an individual-read operation with optional stats, which is a strong usage signal. It is not explicit about when NOT to use it or naming an alternative for bulk listing, though the conversion_id schema hint points to zuckerbot_list_custom_conversions; making it slightly shy of explicit route-selection guidance. Overall, context is clear but exclusions are 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?

No annotations are provided, so the description carries full burden. It describes the read-only validation behavior and its position in the workflow. It does not disclose auth requirements or side effects, but for a validation tool this is sufficient and accurate.

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

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

Two concise sentences, front-loaded with the core action and followed by usage context. No wasted words.

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 no parameters and no output schema, the description explains the purpose and when to call. It could optionally describe the output format, but it's not critical for an agent to use 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 has zero parameters, so schema coverage is 100%. The description adds no parameter info, which is acceptable since none exist. Baseline for 0 params is 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 clearly states it resolves and validates Meta launch credentials (access token, ad account, page, pixel) and reports readiness for autonomous launch. It differentiates from sibling tools like zuckerbot_launch_campaign by specifying it should be called after setup before launching.

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?

Explicitly says to call after completing the setup sequence and before launching a campaign. Provides clear context but does not mention when not to use or list alternatives, though sibling tools like zuckerbot_create_campaign provide context.

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

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

With no annotations provided, the description takes on the full burden of safety disclosure and does so explicitly: 'A pure read — it never changes or persists the selected form.' This is precisely the behavioral property an agent needs before invoking a tool. It also discloses the Page-ownership constraint that explains likely validation failures. Details like auth requirements or not-found error behavior are absent but secondary for a one-parameter read.

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

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

Three sentences with zero waste. The verb and resource are front-loaded, the return payload is listed compactly, the read-safety property is disclosed in one short sentence, and the sibling routing plus precondition close it out. 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 tool with a single parameter, one required field, and no output schema, coverage is solid: the description states purpose, enumerates the payload (partially substituting for an output schema), declares the safety profile, and defines the sourcing of the ID. An explicit note on the form_id error behavior (e.g., missing id or mismatch with the selected Page) would raise this to fully complete, but nothing essential is missing for correct invocation.

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

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

Schema coverage is 100% and the form_id parameter description already includes the key lookup instruction, so the schema does most of the work. The description adds value beyond the schema by stating the Page-ownership validation rule and by listing the concrete fields the ID's read will resolve, which contextualizes the parameter's 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?

The description opens with a specific verb-resource pair, 'Read one Meta lead form (Instant Form) in full', and then enumerates exactly what the read returns (questions, privacy policy URL, legal content, locale, context card, thank-you page, follow-up action URL, status, created time, lead counts). This unambiguously distinguishes it from sibling zuckerbot_lead_forms (the listing counterpart) without needing to open any schema.

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

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

The description provides explicit routing ('Find form ids with zuckerbot_lead_forms') and a concrete precondition ('The form must belong to the selected Facebook Page'). It does not explicitly name exclusions like zuckerbot_export_leads when lead data is what's needed, but the enumerated field list implies that distinction strongly enough for an agent 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?

No annotations are provided, so the description carries full burden. It details the output structure for legacy vs Intelligence campaigns but does not explicitly state that the operation is read-only or safe. It implies non-destructive behavior by describing metrics retrieval, but lacks explicit safety disclosure.

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

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

The description is two sentences, front-loaded with the core purpose and immediately followed by concrete detail on output differentiation. Every sentence adds value with 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?

Given only one parameter and no output schema, the description fully covers the expected behavior: it explains what metrics are returned for both legacy and Intelligence campaigns, including AI recommendations. The use case is explicitly stated, making it complete for an agent to use 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 only parameter is campaign_id, which the schema already describes as 'ZuckerBot campaign ID.' The description does not add extra meaning or format details beyond what the schema provides. With 100% schema coverage, baseline is 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 it fetches real-time performance metrics for a ZuckerBot campaign, distinguishing between legacy and Intelligence campaigns with specific metrics listed. It also provides a use case ('monitor an active campaign or diagnose underperformance'). This differentiates it from siblings like zuckerbot_get_campaign or zuckerbot_get_campaign_insights.

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

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

The description explicitly says 'Use this to monitor an active campaign or to diagnose underperformance,' giving clear guidance on when to use it. It doesn't directly state when not to use it or mention alternatives, but the context is sufficient for appropriate selection among sibling 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?

Without annotations, the description implies a read-only operation by stating 'Fetch' and listing return data. It does not explicitly state non-destructive nature but is sufficient for a read tool.

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

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

Two concise sentences: first defines purpose and return data, second provides usage guidance. Front-loaded and no wasted words.

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?

Explains return fields (tiers, budgets, CPA targets, performance) and usage scenario. Lacks specification on portfolio status constraints but is adequate for a simple read tool with no output schema.

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

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

The single parameter 'portfolio_id' is fully described in the schema (100% coverage). The description adds 'by ID' and usage context but no additional semantic details 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 clearly states the tool fetches configuration and performance data for a portfolio by ID. It identifies the resource (audience portfolio) and action (fetch), but does not explicitly differentiate from sibling portfolio tools like update_portfolio or rebalance_portfolio.

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: use for planning, monitoring, or rebalancing an already-active portfolio. However, it does not mention when not to use it or list alternative tools for similar purposes.

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?

Discloses it's 'the money endpoint' that creates real ads and immediately starts spending. Explains auto-resolution of credentials and behavior of launch_all_variants. With no annotations, it carries full burden; missing details on idempotency or effects of re-launching, but the critical financial impact is clearly highlighted.

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?

Concise at 6 sentences, front-loaded with purpose and money warning. No unnecessary details. Well-structured and easy to parse.

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

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

Covers prerequisites, key parameter explanations, and warning. Lacks return value description (e.g., status or campaign ID), error conditions, and handling of non-draft campaigns. With no output schema or annotations, more context would be helpful for a high-stakes 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 coverage is 100% (all parameters described). Description adds value by noting auto-resolution for meta_page_id, meta_access_token, and meta_ad_account_id, and explaining launch_all_variants behavior. Provides guidance beyond schema for key optional 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?

Clearly states verb 'Launch' and resource 'draft campaign on Meta (Facebook/Instagram)'. Emphasizes it creates real ads and spends budget, distinguishing it from other campaign tools like zuckerbot_create_campaign (draft creation) and zuckerbot_activate_campaign (activation).

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?

Explicitly instructs to check budget availability and Meta connection via zuckerbot_meta_status before calling. Mentions use of launch_all_variants for A/B testing. Does not explicitly list when not to use (e.g., if campaign already live), but context implies it's for drafts.

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

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

No annotations exist, so the description is responsible for behavioral disclosure. It honestly states the tool is unavailable and will not create Meta objects, which prevents an agent from assuming side effects. It does not explicitly describe failure modes, but the unavailability warning is 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 critical status 'Not currently available' is front-loaded, and the alternative guidance is delivered in two tight sentences with no wasted words.

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 that is unavailable, this is complete: it tells the agent not to call it, gives the alternative, and mentions legacy-mode drafting. The only small gap is that 'legacy-mode draft' is not further described, but the referenced launch_campaign path covers the 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 parameters are already documented. The description adds no parameter-level detail, which is acceptable here because the tool is unavailable and existing parameter descriptions suffice.

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

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

The description says 'Not currently available' and that new multi-tier launches do not create Meta objects, but it never directly states what the tool is or was for. Its intended function is only implied by the tool name and schema.

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

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

Explains exactly when not to use this tool and points to an explicit alternative: 'use zuckerbot_launch_campaign for the supported live path.' Also notes that portfolio planning and monitoring remain available, helping the agent route to the right 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?

With no annotations provided, the description carries the full behavioral burden. It explicitly states listing is a pure read scoped to the selected Page, never changes the selection unless select_id is provided, and explains pagination via next_cursor and the result persist side effect of select_id.

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 well-structured, front-loaded set of sentences with no filler. Each sentence earns its place: the core read purpose, safety guarantee, pagination behavior, optional selection, and usage recommendation.

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

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

For a low-complexity tool with zero required params and no output schema, the description adequately covers purpose, side effects, pagination, and usage context, an agent all an agent needs to select and 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 already documents both parameters comprehensively, including after as a pagination cursor and select_id as an optional selection switch. The description mostly restates the schema's semantics with some context, but does not add meaning beyond what is already 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: 'List Meta lead forms (Instant Forms)... show which is currently selected.' It clearly distinguishes from sibling tools like get_lead_form by focusing on available forms on the selected Page, and also describes the optional selection capability.

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?

Explicitly recommends using this 'Let's find the lead form' before launching a leads-objective campaign to reuse the CRM-connected form. It provides clear context and motivation, though it does not explicitly name alternative tools or say when not to use them.

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

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

No annotations are provided, so the description must disclose behavioral traits. While 'list' implies a read operation, the description does not explicitly state it is non-destructive or read-only. A clear statement of safety would improve transparency.

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

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

The description consists of two concise sentences. The first states what the tool does, and the second provides usage context. No fluff or redundancy.

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

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

Given the tool has only one optional parameter and no output schema, the description adequately covers what the tool returns (audiences, sizes, etc.) and when to use it. It would benefit from mentioning pagination or error conditions, but completeness is high for a list 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?

The input schema has 100% description coverage for the single optional parameter (business_id). The description does not add additional context about the parameter beyond what the schema already provides, so baseline score 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 explicitly states the tool lists 'all stored Meta audiences' and enumerates specific types (seed, lookalike, sizes, delivery statuses, CAPI source details). It uses a clear verb+resource structure and distinguishes from siblings like deletion or creation 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 provides two clear use cases: before launching a campaign and for finding IDs for refresh/delete operations. It does not explicitly state when not to use or mention alternatives, but the positive guidance 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?

No annotations are provided, so the description must bear the full burden of behavioral disclosure. It does not mention that the tool is read-only, non-destructive, or that it does not modify state. Also missing details like pagination, sorting, or error behaviors. The agent must infer the read-only nature from the 'list' verb.

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: the first defines the action and return, the second provides usage contexts. No extraneous information; every word contributes. Highly concise and 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?

The description covers the main purpose and return value (files with summaries), and provides practical usage examples. For a simple list tool with one optional parameter and no output schema, it is mostly complete. Minor gaps: no mention of error states or maximum results, but these are not 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?

The input schema has 100% description coverage, with the 'business_id' parameter already described as 'Optional business ID override'. The tool description adds no additional semantics beyond the schema. 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?

Clearly states the verb 'List', the resource 'uploaded business-context files', and the scope 'for a business'. The description also includes the extracted summaries, providing a complete picture. This differentiates it from sibling tools like zuckerbot_upload_business_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?

Explicitly states two specific use cases: confirming planning documents before creating a campaign and checking if a previous upload was processed successfully. This gives clear guidance on when to use the tool, though no explicit alternatives or when-not-to-use are provided.

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

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

With no annotations, the description carries full behavioral disclosure and the author steps up: it says it is a pure read, states it never binds or consumes an ad-account slot, and explains the pagination cursor contract. This gives an agent enough information to reason about side effects and repeated calls.

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

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

Three sentences and each one earns its place: what is returned, side-effect and pagination behavior, and when to use the tool. The most differentiating information (it never binds an ad-account slot) appears early.

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 compensates by listing the returned fields and mentioning next_cursor for pagination. It also provides the routing use case and the read-only safety guarantee, making the tool well-specified for an agent to select and invoke it 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 documentation coverage is 100%, so the schema already explains after and business_id. The description reinforces the pagination usage of after but does not add substantial new parameter meaning beyond what the schema provides.

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

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

Clearly states it lists custom conversions on the connected ad account and enumerates the exact fields returned (id, name, rule, source event, pixel, availability). The plural 'list' differentiates it from get_custom_conversion or create_custom_conversion without forcing an agent to infer from the name.

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?

Explicitly gives a concrete use case: find the custom conversion id a campaign spec's optimisation_event should reference. It also explains pagination behavior for truncated lists. However, it does not explicitly mention alternatives like get_custom_conversion from create_custom_conversion or what to do when you need a single specific conversion.

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

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

With no annotations, the description must carry the burden. It mentions that calling with select_id changes the selected page for future launches, implying a side effect. But it doesn't disclose potential issues like overwriting without confirmation or authorization requirements.

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

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

Two clear sentences that front-load the core purpose and optional behavior. Every word is useful and 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?

For a simple tool with one optional parameter and no output schema, the description covers both usage cases and the persistence of selection. It could hint at output format but is otherwise complete.

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

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

The schema covers 100% of the parameter (select_id), and the description essentially repeats the schema explanation. It adds no new meaning beyond what the schema already provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool lists Facebook Pages and shows current selection, with optional selection by ID. This distinguishes it from sibling tools, which are mostly about campaign management, audience, etc.

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

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

The description explains that the selected page is used for future launches, indicating this is a setup tool. However, it doesn't explicitly state when not to use it or mention prerequisites like having a connected Meta account, which is 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?

Describes return values (connection status, ad accounts, connect URL) but does not disclose side effects or confirm it's read-only. With no annotations, should be more explicit about behavioral traits.

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

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

Two compact sentences: one for purpose, one for usage guideline. No unnecessary words.

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?

Adequately covers return values and pre-launch context. Could mention error behavior or rate limits, but sufficient for a simple status check.

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?

No parameters exist (schema coverage 100%), so description doesn't need to add param info. Baseline 4 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?

Description uses specific verb 'Check' and clearly identifies the resource: connection status of Facebook/Meta account. Distinguishes from siblings by focusing on a prerequisite check.

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?

Explicitly states when to use ('Always call this before attempting to launch a campaign'), providing clear context. Does not explicitly mention alternatives but the instruction is strong 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?

With no annotations to provide safety or side-effect context, the description carries the full burden. It discloses that pausing stops delivery and spend immediately, leaves the object in Meta, reports the prior status, and that resume is currently unavailable through ZuckerBot. This is notably transparent for a state-changing tool.

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 punchy, front-loaded sentences cover purpose, impact, level selection, and resume caveat without filler. Every sentence earns its place and the most important operational consequence—stops delivery and spend—appears early.

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?

This is a state-changing tool, but the description covers what stops, what persists in Meta, the response behavior (prior status), and the unsupported resume flow. There is no output schema, and the description does enough for an agent to call this confidently and understand the likely result.

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

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

Schema description coverage is 100%, and the schema already documents entity_level, entity_id, campaign_id, and action. The description's 'set entity_level and pass the matching id' summarizes the relationship but does not add substantial parameter meaning beyond what the schema provides, so it sits at a baseline 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 states a specific verb and resource: pause/delivery across campaign, ad set, and ad levels, with 'campaign' as the default. This clearly differentiates it from sibling tools like activate_campaign, delete_audience, or get_campaign.

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 explains when to use adset/ad level vs. campaign level by explicitly saying to 'stop an underperformer WITHOUT killing the winners in the same campaign.' It also tells the agent that resume is not available through ZuckerBot and must be done in Meta Ads Manager, which is grounded, actionable 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?

With no annotations, the description carries full burden. It discloses the key behavioral trait that selecting a pixel sets it for all future conversion tracking and CAPI attribution, indicating a persistent side effect. It does not mention destructive actions or permissions, but the mutation is clearly described.

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

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

The description is two sentences, front-loaded with the primary action, and efficiently covers both listing and optional selection with its consequences. No wasted words.

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 no output schema, the description does not detail the output format when listing or after selection (e.g., list structure, confirmation message). It also omits potential error conditions (e.g., invalid pixel ID). For a low-complexity tool, it provides adequate but not complete context.

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

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

The schema coverage is 100%, and the description essentially restates the parameter's purpose from the schema ('If provided, selects this Meta Pixel ID for conversion tracking. If omitted, lists all available pixels.'). It adds no new semantic details beyond what the schema already provides.

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

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

The description clearly states the verb 'List' and the resource 'Meta Pixels', specifying the context 'on the currently selected ad account'. It also distinguishes itself from sibling tools by focusing on pixel listing and selection, which is unique among the listed 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 provides clear context for when to use the tool: to list available pixels or optionally select one. However, it does not explicitly mention when not to use it or suggest alternative tools for pixel management.

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

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

No annotations exist, so the description carries the full burden. The description implies a read operation ('Fetch live...') but does not explicitly confirm it is non-destructive or mention any side effects. It also lacks details on authorization, rate limits, or data freshness. The mention of 'live' indicates real-time data, but overall transparency is adequate but incomplete.

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

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

The description is two sentences: the first states the action and return contents, the second provides usage guidance. It is front-loaded with the key purpose and contains no unnecessary words. Every sentence adds value.

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

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

Given the simple input (one required string) and no output schema, the description provides a good overview of return values (enriched tier rows, daily metrics, etc.). However, it does not address error conditions (e.g., portfolio not found, not launched) or prerequisites. This is a minor gap considering 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% (one parameter: portfolio_id). The description does not add meaning beyond the schema's 'Audience portfolio ID' – it does not explain format, validation, or how to obtain it. With high coverage, the baseline is 3, and there is no extra semantic value.

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

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

The description clearly specifies the verb 'Fetch' and the resource 'Meta performance and downstream CAPI attribution for a launched audience portfolio.' It enumerates specific return items (enriched tier rows, ad breakdowns, daily metrics, CPA comparisons, autonomous evaluation outputs). This effectively distinguishes it from sibling tools like get_portfolio (which likely fetches basic portfolio data) and rebalance_portfolio (which executes rebalancing).

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

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

The description explicitly states when to use: 'Use this to monitor a running portfolio and decide whether to rebalance.' This guides the agent to invoke it for monitoring and decision-making before rebalancing. It does not provide exclusions or alternatives, but the context is clear enough given the sibling 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool scrapes the site, generates AI copy, uses site imagery, and works without a Meta account or budget. It does not disclose persistence or side effects, but for a preview generation tool the behavioral detail is strong and sufficient.

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 every sentence earns its place: the first defines the action and value, the second explains how it works, and the third gives the workflow. It is front-loaded, avoiding filler and low-level repeated details.

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 input expectation, core execution behavior, output artifact, and the workflow context, and it does not omit any obviously critical information. Since there is no output schema, a tiny bit more detail about what the returned mockup/preview format looks like could help, but the sentence is sufficient.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds only the implied breadth of 'any business URL' and does not meaningfully expand the schema semantics for ad_count or URL formatting; it stays at the baseline recommended for high coverage.

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

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

The description uses a specific verb and resource ('Generate a zero-cost campaign preview from any business URL') and clearly states what the tool produces: AI-generated headlines, body copy, and a mockup using the site's imagery. This clearly separates it from sibling tools like zuckerbot_create_campaign or zuckerbot_create_full_campaign, which build and launch real campaigns.

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

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

The description provides explicit placement: 'Use this as the first step to show a user what their ads could look like before committing to a full campaign.' It does not name alternative tools directly, but the context makes clear this is a pre-campaign preview rather than an execution tool, giving adequate 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?

No annotations provided, so description carries full burden. It discloses that the tool returns status, recommendations, pricing, and setup guide, implying it is a read-only, non-destructive operation.

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

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

The description is 3-4 sentences and covers all essential information. It is somewhat detailed but not excessively verbose, and it front-loads the key functions.

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 zero parameters and no output schema, the description thoroughly explains the return values (status, steps, pricing, setup guide). It is complete for its purpose.

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?

No parameters, so baseline 4. Description adds value by detailing what the tool returns, compensating for the lack of 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 explicitly states it shows authentication mode, billing tiers, setup instructions, and recommended tool flow. It clearly differentiates as the first call for orientation.

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?

Explicitly says 'Call this first in any new session to orient the agent.' Provides clear context for usage, though lacks explicit when-not-to-use instructions.

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

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

With no annotations, the description carries full burden. It discloses that dry_run=false updates Meta ad set budgets and local records in one operation, indicating a destructive write. However, it does not detail permissions, reversibility, 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?

The description is two sentences, front-loading the main action and modes. Every sentence provides necessary information without 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?

The description covers the dry-run and execute paths, and mentions the effect on Meta budgets and local records. No output schema exists, but the description implies recommendations are returned for dry-run. It lacks detail on error conditions or exact output format, but is adequate for a mutation tool.

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