Space Monkey Mailchimp Dashboard

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior Mend. The description adds valuable context by revealing what specific account data is inspected and by tying the tool to quota/error diagnosis, which helps the agent anticipate the nature of the response and the practical use case.

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, each earning its place. The first describes what the tool returns, and the second gives actionable guidance on when to use it. No filler, no repetition of schema or annotation information.

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

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

For a zero-parameter, read-only introspection tool with rich annotations and an output schema, the description is complete. It covers what data is returnedaine, why an agent would call it, and how to interpret its role in retry/error handling. Nothing needed to invoke it correctly is missing.

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

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

The tool has zero parameters and the schema is fully documented as an empty object, so parameter semantics are trivially satisfied. The description reinforces that the tool introspects the API key's own context, which further removes any ambiguity about what the agent needs to pass.

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 ('Introspect'), a precise resource ('the API key's own account'), and concrete data returned (effective tier, per-service entitlements, quota usage, project count). It clearly distinguishes itself from the sibling sm_get_* tools by scoping to the caller's own account rather than campaigns, members, projects, or sync runs.

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 use cases: checking headroom and diagnosing 403/429 errors before retrying. It does not name alternatives or explicitly say when not to use it, but the self-account scope and quota focus provide enough context for an agent to select this tool versus the get/list 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?

Annotations already declare readOnly, idempotent, non-destructive and open-world behavior, so the safety profile is covered. The description adds a genuine behavioral trait beyond that: the return is a fixed-size set of campaign-level aggregates in one call regardless of audience size, which tells the agent the cost/shape is constant. No contradiction with annotations.

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

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

Two sentences, front-loaded with the core action and payload, followed by usage routing and scoping exclusions. Every clause carries information; 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?

An output schema exists, so return values need not be explained in prose. The description covers purpose, timing, scope limits, and the sibling that handles excluded breakdowns — everything an agent needs 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?

Schema description coverage is 100%, and both projectId and campaignId are fully documented in the schema including error behavior (400 VALIDATION_ERROR, 404). The description adds no additional parameter meaning, so the baseline of 3 is correct.

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 (load one campaign's full report) and enumerates the metric families returned (delivery, open, click, click-to-open, bounce). It explicitly names what it is not, contrasting with sm_get_variate for per-variant, funnel and geography breakdowns, so an agent can distinguish it from siblings without opening a schema.

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

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

Gives explicit timing guidance ('Use after you have identified a campaign of interest') and routes the agent to the alternative (sm_get_variate) with the condition that selects it. Nothing about when/when-not is left to inference.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), so the bar is lower. The description adds genuinely useful behavior beyond them: 'All metrics come from synced BigQuery tables, so they are only as current as the project last sync run' — a data-freshness caveat the agent needs to interpret results.

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 front-loaded sentences: purpose and contents first, then the consolidation claim, then the data-freshness caveat. Dense but each sentence earns its place; the list of report sections is the only slightly padded element.

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 an output schema exists, the description need not explain return values — yet it still maps the report's sections, defines scope (one sent campaign, per-variant only for A/B), and flags the sync-driven freshness limit. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so projectId, campaignId and the botFilter enum are already fully documented in the schema. The description adds no parameter syntax or format detail beyond it; 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?

Specific verb ('Produce a full post-mortem') + resource ('one sent campaign'), and it enumerates the exact contents: summary metadata, delivery/performance rates, engagement velocity, audience quality, per-variant breakdown. The line 'Combines the detail, velocity, audience-quality and variate views into one report' implicitly separates it from sibling point-views such as sm_get_variate and sm_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?

Usage context is clear: one sent campaign, with variant breakdown only 'when the campaign is an A/B test'. The 'combines ... into one report' phrasing tells the agent to prefer this over calling the individual view tools piecemeal. No explicit when-not or prerequisite guidance, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the non-mutating and safe nature is covered. The description adds behavioral context beyond annotations: the conditional usage ('when basic insights cannot explain a change'), the explicit exclusion list, and the fact that all three tiers return campaign averages, previous-period averages, audience summary, and auto-generated insights. It does not contradict annotations and adds scope and shared-output context, though it omits details like error handling or pagination, which is acceptable given the rich annotation coverage.

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

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

The description is front-loaded with purpose and components, then states the usage condition, then lists exclusions and sibling references, and ends with the shared-output note. Every sentence serves a purpose, though it is slightly verbose due to the detailed exclusion lists. This is a strong 4; a 5 would require even tighter grouping of the exclusions.

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 moderate complexity (6 parameters, 1 required, output schema available) and rich annotations, the description adequately covers the decision points: when to use, what it returns, what it excludes, and what overlaps with other tools. The parameters are fully explained in the schema, and the output is defined by the output schema. The description leaves no critical ambiguity for an agent to select or invoke it correctly. A 4 is appropriate; a 5 would be reserved for even more exhaustive edge-case guidance that is not necessary here.

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% per the context, and each parameter (projectId, startDate, endDate, campaignId, minSendVolume, maxSendVolume) is already documented with formats, defaults, and constraints. The description does not add any parameter-specific meaning—it only describes the output scope. Per the rubric, a high schema coverage yields a baseline of 3, and since the description contributes no extra parameter semantics, this remains a 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 starts with a specific verb ('Get') and clearly specifies the resource ('deeper audience analytics') followed by a concrete list of included analyses: engagement distribution, tag and segment summaries, subscriber-growth baseline with churn decomposition, and campaign consistency. It also names the sibling tools that handle the excluded items, making it unambiguous how this tool differs from sm_get_insights_basic and sm_get_insights_expert.

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

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

It explicitly states when to use this tool ('Use when basic insights cannot explain a change') and then lists exactly what is excluded and which sibling to use instead (sm_get_insights_basic for per-campaign performance table, single-campaign detail, list overview, engagement/send-volume trends; sm_get_insights_expert for campaign fatigue, subject-line keywords, send-time heatmap, monthly trend, audience health). Additionally, it notes the shared outputs across all three tiers, giving clear routing 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?

Annotations already establish readOnly, idempotent, open-world, and non-destructive behavior, and the description adds meaningful context beyond that. It discloses not only what the endpoint returns but also what it deliberately excludes, and it clarifies that the list/subscriber views are Mailchimp-level rather than member-level lifecycle, preventing semantic misinterpretation.

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 every sentence earns its place: it front-loads the main purpose, then uses exclusion lists to steer the agent to the correct sibling tools. The final sentence about shared output across all three insight tiers prevents a misleading assumption that 'basic' lacks common aggregates.

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

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

Given the tool's complexity, the fully detailed input schema, the output schema, and the rich sibling set, the description is remarkably complete. It covers purpose, scope, exclusions, alternatives, and cross-tier behavior, leaving no major gap an agent would need to resolve by trial and error.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters thoroughly. The description itself adds little parameter-level meaning beyond implying the project scope, but since the baseline is 3 for high schema coverage, no deduction 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 opens with a specific verb and resource: 'Get headline campaign and audience performance for a project' and then enumerates concrete output sections. It also clearly distinguishes itself from sm_get_insights_advanced, sm_get_insights_expert, sm_get_member_overview, and sm_get_member_growth, so an agent can disambiguate it from nearby 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 explicitly says 'Start here for "how are we doing"', which tells the agent when to select this tool. It also lists exactly which capabilities are excluded and explicitly names the alternative tool for each excluded category, giving clear when-to-use versus when-to-use-another guidance.

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

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

Annotations already establish that the tool is read-only, idempotent, and non-destructive. The description adds meaningful behavioral context beyond that: it clarifies the tool's analytic scope, what it deliberately excludes, and what it shares with the other insight tiers. No contradictory or hidden behavior is left unaddressed.

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: scope, usage timing, exclusions with sibling routing, and shared return elements. It is not as tight as a two-sentence definition, but the length is justified by the need to differentiate among three insight tiers.

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 output schema, annotations, and sibling context, the description is complete: it tells the agent what the tool returns, when to call it, which tools to use instead for excluded content, and what all insight tiers share. An agent can select and invoke this tool correctly without further inference.

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 parameters are already fully documented in the input schema. The description does not need to restate parameter semantics, and while it references timezone-aware heatmap behavior, it does not materially add beyond the schema. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Get'), names the resource ('expert diagnostics'), and enumerates the concrete insight types it returns. It also explicitly distinguishes this tier from its basic and advanced siblings, so an agent can identify the tool's unique purpose.

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

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

The description states when to use it ('Use only after basic or advanced have established what changed') and gives explicit exclusions with routing to sm_get_insights_basic and sm_get_insights_advanced. This is clear, actionable guidance with named 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?

Annotations already establish the safe-read profile (readOnlyHint, idempotentHint, non-destructive, closed-world), so the lighter bar applies. The description adds genuine context by explaining it exists as a fallback for clients lacking resource-read support, which the annotations do not 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?

A single front-loaded sentence with a parenthetical enumeration and an em-dash clause that carries the usage trigger. Dense but every clause earns its place; only slightly run-on.

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?

An output schema exists, so return format needn't be restated, and annotations already cover the safety profile. Purpose, contents, and the usage trigger are all present, leaving only minor gaps around the parametrized topic fetch.

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

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

Schema description coverage is 100% and the single optional 'topic' enum is fully documented upstream, so the baseline of 3 applies. The description names three of the four topics but omits 'faq' and never mentions the omit-to-get-index behavior, adding little beyond the schema.

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

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

States a specific verb and resource ('Returns ... knowledge documents') and enumerates the payload (analyst preamble, metric guardrails, OpenAPI schema URL), so an agent knows exactly what comes back. It does not explicitly contrast itself with nearby siblings like sm_get_prompt or sm_get_schema, which keeps it short of a 5.

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

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

Gives a clear trigger ('read this before interpreting any Space Monkey metrics') and a scope condition ('for clients that cannot read MCP resources'), implicitly routing resource-capable clients elsewhere. It stops short of naming a specific alternative tool or stating when-not to call it in more absolute terms.

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

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

Annotations already carry the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the description doesn't need to cover side effects. It adds light context about the profile's scope and included fields, but does not disclose error behavior, permissions, rate limits, or other behavioral traits beyond what annotations provide.

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

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

A single front-loaded sentence states the operation, the exact data returned, and the intended use cases without filler. Every element 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?

With two clearly documented required parameters, a rich output schema, and annotations covering safety/idempotency, the description is sufficient for an agent to decide to call and invoke the tool. It also orients the agent across a large sibling set with the 'full profile' framing and use-case guidance.

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%, with detailed documentation for projectId and subscriberHash including failure mode and regex pattern, so the schema does the heavy lifting. The description contributes nothing parameter-specific, 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 opens with a specific verb and resource ('Load one member's full profile') and enumerates the content (title, company, tags, clicked URLs, engagement percentile, at-risk state, bot detection), making the tool's purpose unmistakable. 'One member' separates it from list tools, and the field list distinguishes it from the other sm_get_member_* 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 explicitly anchors usage to pre-call briefs and shortlist enrichment, giving clear context for when the tool is appropriate. It does not name alternatives or state when not to use it, but the use-case sentence is enough to guide selection among the many 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?

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description adds a genuinely useful behavioral trait: the result set is frequently empty even for highly engaged members, warning the agent against treating an empty list as an error. It stops short of describing pagination or return shape, but an output schema exists.

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

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

Three short sentences, front-loaded with purpose, then the empty-result caveat, then the alternative tool. No filler; each 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?

With a rich output schema, full parameter documentation, and annotations covering safety and openness, the description only needs to supply purpose, the empty-result caveat and sibling routing — all of which it does. Nothing needed to call it correctly is missing.

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

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

Schema description coverage is 100% across all 15 parameters, including enums, defaults, formats and cursor semantics, so the schema carries the full burden. The description adds no parameter-level meaning beyond it, making the baseline 3 appropriate.

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

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

States a specific verb (List) and resource (individual campaigns a member received/opened/clicked), and explicitly contrasts with the sibling sm_list_campaign_responders as the 'inverse view'. An agent can distinguish this from the sibling without opening either 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?

Names the alternative tool and the condition that selects it ('members who responded to one campaign'). It also gives a practical usage caveat — this drill-down is often empty even for engaged members, so keep a fallback — which is real routing guidance.

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

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

Annotations already declare read-only, idempotent and open-world, so safety is covered. Beyond that the description discloses meaningful derivation behavior: country is inferred from region (US states/CA provinces mapped), falls back to stored country data, and unresolvable values are bucketed as Unknown, plus the non-obvious rule that regions is null unless countryCode is passed.

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 dense sentences, front-loaded with the purpose and followed by usage context and the derivation caveat. Slight redundancy with the schema on the countryCode/regions behavior keeps it from a 5.

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

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

An output schema exists, so return-shape explanation is unnecessary. The description supplies the usage context and the data-derivation edge cases (region inference, Unknown bucket, conditional regions) that an agent needs to interpret results 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% and both parameters are thoroughly documented there, including the countryCode case-insensitivity and the regions-null behavior. The description largely restates that schema contract rather than adding new syntax or format guidance, so the baseline 3 applies.

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

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

States a specific verb and resource: 'Get the country and region distribution of a project's members.' This is precise enough to separate it from sibling member-metrics tools such as sm_get_member_overview or sm_get_member_growth without opening either 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?

'Use for territory, event and travel-planning questions' gives a concrete use context and implies the questions this tool answers. It stops short of naming when-not-to-use or an explicit alternative sibling, so it is not a full 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds important data interpretation context: a cohortRetention row is a current status breakdown for the signup month, not retention at month N, and signup month may fall back to last-changed or sync time when Mailchimp lacks an opt-in timestamp.

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, then usage, then a critical caveat, then an explicit alternative. Each sentence serves a distinct function, and the dense but necessary routing sentence prevents the most likely misuse.

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 rich annotations, a complete output schema, and 100% schema description coverage, the description supplies everything the agent needs beyond structured fields: purpose, usage context, key interpretation caveat, and alternative routing. No meaningful gap remains for correct tool selection or 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 description coverage is 100% and the single projectId parameter is already fully documented in the schema, including the required behavior and error case. The description adds no parameter-level semantics beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description names the exact returned artifacts — signup cohorts, churn timeline, and cohort retention — and explicitly distinguishes this tool from the subscriber-growth series in sm_get_insights_basic. An agent can identify both the tool's scope and its closest alternative without opening 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?

It states the intended question types ('list-growth and attrition') and explicitly routes audience-size-over-time questions to sm_get_insights_basic instead. This provides clear when-to-use and when-not-to-use guidance with a named 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?

Beyond the annotations (readOnly, idempotent, non-destructive), the description discloses non-obvious behavior: it is not paginated, language is truncated to the top 20, rep and custom-dimension lists to the top 25, and the rep block is omitted unless the project maps an owner merge field. These constraints are not derivable from any structured field and materially affect how an agent interprets the output.

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

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

Purpose and usage are front-loaded, and the dense truncation sentence earns its length by conveying three distinct limits. It is slightly verbose and could split the truncation clause, but very little is wasted.

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 an output schema present, the description need not explain return values, and it still covers scope, truncation behavior, conditional omission of the rep block, and alternative-tool routing. Nothing an agent needs to call this correctly is missing.

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

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

There is a single parameter (projectId) with 100% schema description coverage, so the schema already documents its format, sourcing endpoint, and the 400 VALIDATION_ERROR on omission. The description adds no additional parameter meaning, making the 3 baseline appropriate given the schema does the heavy lifting.

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

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

The first sentence names a specific verb and resource ('aggregate audience composition for a project') and enumerates the exact dimensions returned: totals, status, rating, rep, and language breakdowns. It also explicitly differentiates itself from siblings by contrasting the 'member-composition view' with the Mailchimp-list health view in sm_get_insights_basic.

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 states when to use it ('quick shape-of-the-list answer') and names a concrete alternative with the condition that selects it ('For Mailchimp-list health ... use the list overview in sm_get_insights_basic'). The routing between the two tools is unambiguous.

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

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

The description discloses behavior the annotations cannot: the call is unpaginated and returns every tag/segment, untagged members are excluded from the tag list and only appear via a separate untaggedCount, and engagement rates exclude insiders while member counts do not. These are non-obvious, outcome-shaping facts an agent would otherwise misread.

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

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

Purpose and the audience-building use case are front-loaded, and each sentence carries distinct information with no filler. The final sentence stacks three separate caveats into one long clause, which slightly hurts scannability.

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?

An output schema exists, so return values needn't be documented; the description instead covers the count/rate caveats and the no-pagination behavior, which are exactly the gaps an agent would otherwise trip on. Nothing needed to call it correctly is missing.

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

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

With a single parameter and 100% schema description coverage, the schema already fully documents projectId (format, listing endpoint, 400 VALIDATION_ERROR on omission). The description adds nothing parameter-level, so the baseline of 3 applies.

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

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

States a specific verb and resource ("Get tags and segments") plus the payload shape ("engagement and status breakdowns"), which is enough to separate it from sm_list_members or sm_get_member over similar data. It never names a sibling explicitly, so it falls short of the top band's sibling 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?

"Use to turn an event or interest tag into a working audience" gives one concrete motivating context, which is more than nothing. But there is no when-not guidance, no prerequisites, and no routing to alternatives such as sm_list_members or sm_get_member_campaigns when a plain member listing is what's needed.

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

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

Annotations already cover read-only, idempotent, non-destructive behavior, so the description only needs to add context beyond that. It adds that events are 'raw' and returned 'in time order,' which is useful, but it does not disclose additional behavioral traits such as pagination defaults or result size. Pagination is documented in the schema, and this is acceptable given strong annotation coverage.

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

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

The description is two short sentences with no filler: the first states the core action and scope, and the second gives the practical use case. Every word earns its place, and the key behavior 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?

Despite the tool's 15 parameters, the full schema describes every parameter, an output schema exists, and annotations cover safety semantics. The description supplies the missing contextual layer: what the tool is for and when to use it. Nothing essential for selecting or invoking the tool is missing.

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

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

Schema description coverage is 100%, and the schema already provides detailed descriptions for all 15 parameters, including defaults, formats, and constraints. The description adds little parameter-level meaning beyond implying the subscriberHash identifies the member, 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 uses a specific verb and resource: 'Replay one member's raw activity events in time order.' This clearly identifies the tool as an event-level timeline for a single member and distinguishes it from sibling tools like sm_get_member_overview or sm_get_member_campaigns, which imply aggregated or campaign-level views.

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 second sentence provides an explicit intended use: 'Use to establish when someone last paid attention and what triggered it.' This gives clear context for when the tool is appropriate, though it does not explicitly state when not to use it or name alternative tools.

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

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

Beyond the readOnly/idempotent annotations, the description discloses the non-obvious failure signal based on unresolved {{tokens}}, explains that the returned arguments include defaults, and clarifies that the output is the rendered instruction text rather than an execution result. This meaningfully improves an agent's ability to verify and recover from incomplete input.

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 four sentences are front-loaded with the core action and outputs, then address error detection and next steps. Every sentence earns its place with no redundant filler, keeping the definition informative without becoming bloated.

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?

Combined with the complete input schema, output schema, and annotations, the description covers valid prompt name sourcing, argument binding, missing-token failure handling, and subsequent tool usage. An agent has everything needed to invoke the tool correctly and respond to incomplete renders.

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%: both 'name' and 'arguments' already document their meaning, examples, and default behavior in detail. The description reinforces the source of names and the default-binding behavior, but adds no material parameter-level information beyond the schema, so the 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 opens with 'Render one Space Monkey prompt workflow with concrete argument values' – a specific verb, resource, and operation. It clearly defines outputs as 'complete instruction text ready to follow' plus 'effective arguments', and explicitly names sm_list_prompts as the source of names, which helps distinguish it from sibling listing 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 provides clear operational context: obtain prompt names from sm_list_prompts, fill missing required arguments if {{tokens}} remain, and call referenced sm_ tools afterwards. It lacks an explicit 'do not use this when...' or direct comparison with alternatives, so it is not a perfect 5.

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

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

Annotations already declare this as read-only, idempotent, and non-destructive, so the bar for behavioral disclosure is lower. The description adds meaningful behavioral detail by explaining that omitting `operation` returns a compact index and passing a selector returns full parameters and resolved response schemas. This goes beyond the annotations without contradicting them.

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

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

Three sentences with no filler. The most important information (what the tool returns and the two modes) is front-loaded, and the usage guidance is placed at the end as a natural conclusion. 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?

Given the annotations, a rich output schema, and a fully documented single optional parameter, the description is complete. An agent knows when to call it, what the two modes do, and how to select a target operation. No critical behavioral or usage context is missing.

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

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

The schema itself already provides 100% coverage of the single `operation` parameter, including the omission behavior and acceptable selector forms. The description largely restates this information rather than adding new meaning, so the baseline score of 3 is appropriate.

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

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

The description names a specific verb ('Get') and resource ('Enterprise API's OpenAPI-derived schema catalog'), and clearly distinguishes this meta-tool from the many sm_get_* and sm_list_* siblings by explaining it returns schema information rather than business data. The dual-mode behavior (index vs. single operation) makes the purpose unmistakable.

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 to use the tool 'before calling an unfamiliar tool to confirm its exact fields,' which gives clear contextual guidance. It does not explicitly enumerate when not to use it or name alternative tools, but the guidance is specific enough that an agent can infer the appropriate invocation 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?

Annotations already declare this a safe, idempotent read, but the description goes well beyond them by disclosing the two distinct failure-recording paths (orchestration errors in run.errorMessage with null results, per-data-type errors in results[].errorMessage with null run.errorMessage) and instructing the agent to treat status as the failure signal. This is the kind of non-obvious behavior that prevents misdiagnosis.

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, zero filler, and the core purpose leads. The longest sentence carries genuinely load-bearing failure-mode guidance rather than padding.

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

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

An output schema exists, so return values need not be re-explained; the description instead supplies the interpretation guidance the output schema can't (how to read errorMessage across two locations). Nothing an agent needs to call and correctly interpret this tool is missing.

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

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

With 100% schema description coverage on both required parameters, the schema already documents runId and projectId fully. The description adds no syntax, format, or constraint detail for the parameters themselves, so baseline 3 applies.

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

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

States a specific verb (Load) and resource (one sync run's full detail), then enumerates exactly what the payload contains (per-stage results, progress, lookback window, pending batch count). It also names sm_list_sync_runs, so an agent can place it relative to its closest sibling.

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 prescribes the workflow: 'Use after sm_list_sync_runs to explain why data is stale or a run failed.' Both the predecessor tool and the diagnostic intent are stated, leaving nothing to inference.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive). The description adds genuinely non-obvious behavior: metrics are sourced from synced BigQuery tables, not a live Mailchimp read, so freshness depends on a per-project sync cadence (manual/daily/weekly). That is exactly the kind of caveat annotations cannot express.

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, no filler. The data-freshness caveat is slightly buried at the end, but the sentence is information-dense rather than padded, so the only minor deduction is for front-loading of the most decision-relevant caveat.

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?

An output schema exists, so return values need not be explained, and the description still helpfully enumerates the report sections. Combined with the sync-lag disclosure and the multivariate scoping, an agent has what it needs to call this correctly; the only gap is not naming the fallback tool for non-variate campaigns.

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% — both projectId and campaignId are thoroughly documented in the schema, including error behavior. The description adds no parameter-level detail, so the baseline 3 is appropriate.

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

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

States a specific verb ('Analyse') and resource ('variate (A/B) campaign') and enumerates exactly what is returned: per-variant reports, statistical significance, engagement velocity, audience quality, geo split. It also distinguishes itself from the sibling insights tools by being scoped to multivariate campaigns only.

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

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

Gives an explicit applicability condition — 'Only meaningful for multivariate campaigns' — which routes the agent away from using it on standard campaigns (cf. sm_get_insights_basic/advanced/expert). It does not, however, name which sibling to use instead when the campaign is not multivariate.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds a non-obvious interpretive fact: engagementScore is raw and decayed and can be negative, unlike a percentile, which prevents an agent from misreading values. This is useful context beyond the annotations and does not contradict them.

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

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

Two sentences with no filler; the first front-loads the verb, resource, and purpose, and the second adds the critical score caveat. It avoids repeating anything already present in the title or schema.

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

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

For a 13-parameter list tool with a full output schema, the description gives the core at-risk definition and the one caveat most likely to trip up an agent. It could say a bit more about which sibling to choose in ambiguous cases, but nothing essential to calling it correctly is missing.

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

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

Schema coverage is 100%, with every parameter already documented including defaults, enums, and required projectId. The description's score caveat applies to a returned or output field rather than to input parameters, so it adds no essential parameter-level meaning. Baseline 3 is appropriate.

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

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

States a specific action, 'Find previously engaged members whose recent activity has collapsed', and a concrete purpose, 'for building save lists'. This expands the title and clearly separates it from sibling list tools like sm_list_members and sm_list_leaders.

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

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

Gives a clear use case (building save lists) and a hint about when to prefer it over the leaders tool via the 'unlike the leaders percentile' note. It does not enumerate exclusions or explicitly name the alternative tool, so it stops short of full when/when-not guidance.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld). The description adds genuinely non-obvious behavior beyond them: the keyset cursor is opaque and valid 24 hours, pageSize is capped at 100, and emailsSent is echoed so the unenumerated majority remains a visible denominator. It stops short of describing the cursor's query-binding failure mode, which the schema covers instead.

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 dense sentences, front-loaded with scope, then filters, then sibling routing, then pagination mechanics. No filler, though the single long sentence packing filters and subscriberHash is heavy and would parse more easily split.

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?

An output schema exists, so return values need not be described. For a high-parameter list tool, the description covers scope, filter intent, routing, and pagination constraints — everything an agent needs 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?

Schema description coverage is 100% and the 23 parameters are each documented in the schema itself, including the action-vs-engagementType distinction and the cursor mismatch behavior. The description reinforces the filter set and the subscriberHash meaning (MD5 of downcased email joining to member-centric tools), but mostly restates what the schema already provides, so baseline 3 applies.

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

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

States a specific verb and resource (list members who responded to one campaign) and immediately draws the boundary against the naive reading — 'never the full send list'. It also names the sibling views it is not (sm_get_campaign, sm_get_member_campaigns, sm_list_members), so an agent can differentiate without opening a 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?

Explicit routing: use sm_get_campaign for the campaign report, sm_get_member_campaigns for member-to-campaign history ('the inverse view'), and sm_list_members for the whole directory. It also gives an in-tool heuristic ('clicked-only is usually a fraction of responders') for when to narrow before paging.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds behavioral context by noting the tool returns performance metrics and by framing the two use cases. It does not describe pagination behavior or default sorting, but the schema covers those details, so the description adds reasonable value beyond annotations.

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

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

Two sentences with zero waste. The first sentence states the core function, and the second gives concrete use cases. Every word earns its place.

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

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

The tool has a rich schema (10 params, all documented) and an output schema, so the description doesn't need to explain return values. The use cases add practical context for an agent. It could mention pagination or default sorting, but those are already in the schema, so the description is complete enough 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?

Schema description coverage is 100%, so the schema already documents all 10 parameters thoroughly. The description adds no parameter-specific meaning beyond what the schema provides, so the 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 ('List'), a resource ('a project's campaigns'), and the key output ('with performance metrics'). It also names two concrete use cases (mapping lastActivityAt onto a real send, finding the latest house send by send_time), which distinguishes it from sibling tools like sm_get_campaign or sm_get_member_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 gives clear context for when to use the tool ('Use to map a member's lastActivityAt onto a real send, or to find the latest house send by send_time'). It does not explicitly name alternatives or exclusions, but the use cases imply when this list tool is appropriate versus a get tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive, so the safety profile needs no restatement. The description earns credit for disclosing real behavioral quirks: engagementScore is a 0-100 percentile here whereas at-risk tools use a raw score that can go negative, memberRating is Mailchimp's 1-5 scale, and subscriberHash is the MD5 of the downcased email used as the join key. It also states pagination is capped at 100 rows. It doesn't cover rate limits or result ordering nuances beyond the default.

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 paragraph is tightly structured and front-loads the core ranking purpose before usage context and the engagementScore/memberRating/subscriberHash semantics. It is a single well-organized block with no filler, though it could be split for faster scanning by an agent.

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

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

Given 16 parameters, five enums, and a rich schema plus an output schema, the description covers the essentials an agent needs: what it ranks, primary filters, score semantics, and the pagination cap. It omits how sorting interacts with percentile scores and does not mention the default leaderOnly=true behavior, which is a notable gap for a tool whose default changes the result set.

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

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

Schema description coverage is 100%, so the schema already documents all 16 parameters, including enums, defaults, and bounds. The description adds semantic color rather than parameter documentation: it explains the percentile vs raw-score distinction and the subscriberHash join key, which helps interpretation but is not tied to specific parameters. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description opens with a specific verb and resource: 'Rank the most engaged members of a project by engagement percentile.' This clearly distinguishes it from sibling list tools like sm_list_members and sm_list_at_risk by naming the ranking behavior and the engagement-percentile basis. It stops short of naming a sibling alternative explicitly, so it lands just shy of a 5.

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 second sentence gives a use context ('when you need who is paying attention right now') and enumerates the applicable filters (rep, tag, rating, status, bot/insider rules). It does not explicitly route the agent to sm_list_at_risk or explain when to choose this list over the general member list, which keeps it out of the 5 band.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered externally. The description adds 'full member directory' scope but says nothing about pagination behavior, result limits, or dataset size — all of which the schema covers instead. Modest added value only.

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, both earning their place: the first states what the tool does, the second states when to use it. Front-loaded and free of repetition of schema content.

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

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

With an output schema present, return values need not be described, and the exhaustive input schema covers all 20 filters and pagination. The description is sufficient for correct invocation, though guidance on cursor replay or combining filters would have made it fully self-contained.

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

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

Schema description coverage is 100% across all 20 parameters, so the schema already carries full parameter meaning. The description's mention of rating, tag, status, and free-text search maps loosely onto minRating/maxRating, tag, status, and search, but adds no syntax, defaults, or edge cases beyond what the schema documents.

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

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

The description states a specific verb and resource: browsing/searching a project's full member directory. It also implicitly contrasts with engagement-ranked siblings via 'rather than by engagement rank', though it never names an alternative tool (e.g. sm_list_leaders or sm_list_at_risk). Clear purpose, but sibling differentiation is left partly to inference.

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

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

It gives an explicit use condition — when you need people by rating, tag, status, or free-text search — and an exclusion against engagement-rank-based retrieval. It stops short of naming the specific alternative tools an agent should pick instead, so routing still requires a guess.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive, so the description's job is to add context. It does: the tool is scoped to the API key's readable projects, it resolves company names, and it must not silently merge projects. This meaningfully extends beyond the structured annotations.

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

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

Two tight sentences with no filler. The primary action is front-loaded, and the usage rule is stated in a compact, memorable way.

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 parameters, an output schema, and annotations covering safety and idempotency, the description provides all remaining context an agent needs: when to call it, what it resolves, and a critical matching constraint. Nothing 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?

The tool has zero parameters and the schema coverage is 100%, so there is nothing for the description to explain about parameters. The mention of companyName gives useful conceptual context even though it is not a formal parameter.

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

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

The description uses a specific verb ('Resolve') and a clear resource ('which Space Monkey projects this API key can read'), immediately distinguishing this from sibling list tools. It also frames the tool's role as a lookup/discovery operation rather than a generic list.

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 trigger condition: 'Call this first when the user names a company rather than a project ID.' It also provides a behavioral rule ('match on companyName') and a firm exclusion ('never silently mix projects'), which is strong guidance for an agent choosing between this and other 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe/read-only nature is covered. The description adds useful behavioral context: these are user-invocable recipes that chain sm_ tools and require following rendered instructions to execute, which indicates this tool only lists metadata rather than running workflows.

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 no filler. It front-loads the action and resource, gives illustrative examples, and ends with a practical next step, all in a compact and scannable structure.

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

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

For a zero-argument, read-only list tool with a rich annotation set and an output schema, the description provides everything an agent needs: what is listed, what each entry contains, and how to proceed with sm_get_prompt. No critical behavioral or usage details are missing.

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

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

The tool has zero input parameters and 100% schema coverage, so there are no parameter semantics for the description to clarify. The description still adds relevant context by noting that each returned entry lists its arguments and category, which is helpful for understanding the output.

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 ('List') and a specific resource ('Space Monkey prompt workflows'), and distinguishes this tool from the sibling sm_get_prompt by framing listing vs. rendering. It also gives concrete examples of what these workflows are, so an agent can identify the tool's purpose without ambiguity.

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

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

The description explicitly directs the agent to use sm_get_prompt after listing, saying to render one with concrete argument values and then follow the rendered instructions. This provides clear routing to the relevant sibling, though it does not enumerate when not to use this tool relative to other list 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?

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description adds pagination behavior and the 100-row cap, but the cap is already stated verbatim in the pageSize schema, and the 'recent' window, cursor replay rules, and ordering are left unspecified.

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

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

Three short sentences, front-loaded with the action and resource before context and pagination notes. Nothing is redundant, though 'with status and results' and the cap sentence are marginally low-value given 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?

With an output schema present, annotations covering safety, and 100% parameter coverage, the description does not need to explain return values. It supplies the missing use-case framing; only the undefined 'recent' window is a small gap for a paginated 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?

Schema description coverage is 100%, so cursor, pageSize and projectId are all fully documented with constraints and defaults. The description restates the pageSize cap without adding syntax or semantics beyond what the schema provides; baseline 3 applies.

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

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

States a specific verb and resource ('List recent data-pipeline sync runs') plus what each row carries ('status and results'), which is enough to distinguish it from sm_get_sync_run's single-run lookup. It never names a sibling explicitly, so the differentiation is implied by 'list recent' rather than stated.

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 a clear operational context: 'checking data freshness before trusting an analysis.' That tells the agent when the tool is relevant, but gives no when-not condition and does not route to sm_get_sync_run for drilling into a specific run.

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