Zambo AI Tools

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

With no annotations provided, the description carries full burden. It discloses return fields, rate limits, and access tiers. It lacks details on auth requirements or potential side effects, but for a non-destructive read tool this is acceptable.

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

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

The description is concise (two main sentences plus a list of return items) and front-loaded with the core action. It is slightly verbose in listing return fields, but overall efficient.

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

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

The description covers the tool's purpose, inputs, outputs, and usage examples. Given no output schema, it effectively describes return values. It is complete enough for an agent to decide when and how to 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 description coverage is 100%, so baseline is 3. The description adds no new information beyond what is already in the schema (e.g., depth, focus descriptions are identical). It does not enhance understanding of parameter behavior or interactions.

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 'Generate' and identifies the resource as a 'comprehensive machine-readable structured briefing'. It clearly states the scope (any URL, product, company, etc.) and distinguishes from siblings like 'zambo_brief' by emphasizing AI agent consumption and flexibility.

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 use cases (onboarding, competitive intelligence, API understanding) and mentions rate limits. However, it does not state when not to use or suggest alternative tools, which would improve 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 burden. It discloses the marketplace's decentralized escrow nature and USDC payment, and explains what each action returns. While it doesn't detail permissions or rate limits, it provides adequate behavioral context for a marketplace 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?

The description is two sentences—concise and front-loaded. First sentence introduces the tool, second summarizes actions and returns. Every sentence earns its place with no 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?

Given 8 parameters, 3 actions, no output schema, and no annotations, the description could be more complete. It doesn't explain prerequisites like wallet setup or the x402 protocol details. The return descriptions are high-level but sufficient for basic understanding.

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 well-documented. The description adds value by grouping parameters by action (e.g., budget_usdc for hire, agent_name for list), but does not significantly enhance 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 clearly states the tool's purpose: 'Browse, hire, or list agents on the Zambo Agent Marketplace.' It specifies the resource (agents on the marketplace) and actions (browse, hire, list), distinguishing it from siblings like agent_brief or agent_identity which focus on other agent operations.

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

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

The description provides context for when to use each action (browse by specialization, hire for a task with escrow, list your own agent). However, it lacks explicit guidance on when not to use this tool or direct alternatives, though the marketplace context 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?

No annotations provided, so description carries full burden. Discloses persistence across switches, actions, and data elements (handle, skills, wallet, context). Does not mention rate limits or error states, but is sufficiently transparent for a simple identity 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?

Well-structured: core purpose first, then use cases, actions, call format. Some marketing language ('digital being with continuity') is slightly verbose but not detrimental. Front-loaded with key 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?

No output schema, so description should explain return behavior. Mentions 'load retrieves full identity + session key' and 'snapshot = full reputation report', but does not detail the structure. Adequate for most agents, but could be more explicit about return format.

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%, yet description adds substantial meaning: explains each action's effect, handle format, skill accumulation, optional wallet for on-chain reputation, and session context. Goes beyond the schema's brief 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?

Clearly states the tool establishes a persistent agent identity across clients, with specific actions (load, save, snapshot). Distinguishes from 'disposable chatbot' and positions itself as enabling continuity. Sibling tools like agent_brief and agent_hire are related but not confused due to explicit focus on persistence.

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 concrete use cases: start in Claude Desktop, continue in Cursor, hand off to Telegram. Mentions other agents can query track record. Lacks explicit when-not-to-use or alternatives, but context 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?

No annotations provided, so description carries full burden. It fails to disclose whether the operation is read-only, modifies any state, or requires specific permissions. The description only hints at returning a package, but does not assure safety or 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?

Description is a single sentence that conveys the core purpose without fluff. It is appropriately concise, though breaking into two sentences could improve readability.

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?

Without an output schema, the description adequately explains the return value: an onboarding package with three components. Given only two simple parameters, this provides sufficient context for an agent to use the 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 baseline is 3. Description adds minimal value beyond schema: it mentions 'for the agent's purpose' but does not elaborate on the 'focus' parameter or provide additional context for either 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?

Description clearly states the verb 'brief' and the target resource 'new AI agent on the complete Zambo + x711 stack'. It differentiates from sibling tools like 'agent_brief' by specifying an onboarding package, which is explicit and 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?

No guidance on when to use this tool versus alternatives such as 'agent_brief' or 'zambo_brief'. The description only states what it does, not when it should be chosen over 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 provided, so the description carries the transparency burden. It lists what the config includes (logging, monitoring, identities, etc.) but does not disclose side effects, required permissions, or what happens on failure. Some behavioral context is given but not comprehensive.

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 main action, and includes a list of features without fluff. 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?

While the description covers the main functionality and usage sequence, it lacks details about return values (no output schema) and error conditions. For a tool generating a config, output format is missing, making it less 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 good descriptions for all parameters. The description does not add extra parameter-specific meaning beyond what the schema already provides (e.g., agent roles are clear from 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 clearly states the tool's purpose: wiring two AI agents via Entangler.tech for trustless coordination and generating a deploy-ready config with specific features. It distinguishes from siblings by mentioning a prerequisite (use after axis_spark_to_swarm) and listing unique config components.

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 axis_spark_to_swarm to wire the agents it planned,' providing clear when-to-use guidance. However, it does not mention when not to use or name alternatives beyond that single reference.

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 only states that it generates a proof and returns a hash, without disclosing side effects, storage behavior, authorization requirements, or reversibility. Minimal 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 a single, well-structured sentence that concisely conveys the purpose, inputs, and output without any redundancy. It is 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?

Given the tool has only 2 parameters and no output schema, the description explains the output (SHA-256 hash) sufficiently. However, it lacks details on return format and differentiation from similarly named siblings like zambot_chain. Still, it covers the essentials for a simple 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 adds context by naming the concepts 'Zambo Spark' and 'x711 execution log', which helps understand the parameters' roles beyond the schema descriptions. Enhances clarity.

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 generates a cryptographic proof chain linking a Zambo Spark strategy to an execution log and returns a SHA-256 hash. It specifies the inputs and output, distinguishing it from many siblings, though some like zambot_chain may overlap in concept.

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

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

The description implies usage for anchoring a strategy to its execution, but it does not provide explicit when-to-use or when-not-to-use guidance nor mention alternatives. The context is clear but lacks explicit direction.

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 describes the output (ranked results with integration paths) and the simultaneous search behavior, but lacks details on rate limits, authentication, or side effects. Adequate but not rich.

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 states the action, second the output. No redundant words, front-loaded with essential 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 no output schema and moderate complexity, the description covers the key aspects: what is searched, which networks, and what the results contain. Could mention result format or pagination, but sufficient for most use cases.

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 no additional semantics beyond the schema; it repeats the network names but that's already in the enum. No extra 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 states the tool searches capabilities and tools across three specific networks (Zambo, x711, Entangler). The verb 'search' and the resource are explicitly defined, and the tool distinguishes itself from siblings by focusing on cross-network search with ranked results and integration paths.

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 implicitly indicates use for cross-network search but does not explicitly state when to use this tool over alternatives like capability_search. No exclusions are provided, but the context is clear enough for most agents.

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 bears full burden. It indicates monitoring and flagging with auto-correction recommendations but does not state whether the tool mutates anything or has side effects. The read-only behavior is implied but not explicit.

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 key action ('Monitor'), and no redundant information. 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?

No output schema, so description should explain return value; it does not. It also lacks information on prerequisites (e.g., how to obtain spark_hash). Parameters are covered, but overall completeness is below what a complex monitoring tool requires.

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 fully described in the schema. The description adds slight context by referencing 'current swarm behavior' corresponding to 'current_outputs', but does not add significant new meaning 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 tool monitors a running agent swarm for drift against its original Zambo Spark, mentioning comparison and flagging misalignment. However, it does not explicitly differentiate from sibling tool 'zambot_drift', which likely has overlapping functionality.

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?

No guidance on when to use this tool versus alternatives like 'zambot_drift' or other swarm-related tools. The description implies use when checking drift but lacks explicit context or exclusions.

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 'Free, no auth' and lists return content (config block, tool directory, architecture overview). No annotations provided, so description carries full burden.

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

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

Three concise sentences, front-loaded with purpose, 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?

Adequately explains return values and nature of tool for a config retrieval with no parameters and 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?

No parameters; schema coverage is trivial. Description adds context on what is returned, exceeding the baseline for zero-parameter tools.

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 'Get the Axis MCP configuration' – a specific verb and resource. Distinguishes from sibling tools by being the config/integration overview tool.

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?

Implies use when needing the combined config or tool directory, but no explicit when-to-use or when-not-to-use vs 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?

With no annotations, the description must cover behavior. It mentions it returns a continuity package and writes to Entangler MEMORIA, but does not disclose side effects, auth requirements, rate limits, or what happens if layers don't exist.

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, mostly direct. The second sentence is somewhat dense but still readable. Could be slightly more concise but overall appropriate.

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 4 parameters, 3 required, and no output schema, the description explains the return package content but omits error handling, idempotency, and is not fully complete.

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

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

Schema coverage is 100%, so baseline 3. The description adds context about the 'context' parameter carrying state, but does not explain the optional 'spark_hash' parameter beyond its schema description.

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's action (package and hand off context), the specific layers involved (Zambo, x711, Entangler), and what the return package contains, distinguishing it from sibling tools that perform other operations like 'axis_agent_onboard' or 'zambo_ask'.

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

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

The description implies usage for layer-to-layer context handoff but provides no explicit guidance on when to use it versus alternatives, nor does it mention prerequisites or when not to use 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?

No annotations are provided, so the description must carry all behavioral info. It mentions submission and cryptographic proof but lacks details on side effects, permissions, rate limits, or what happens on failure. The metaphorical 'closes the loop' adds little practical 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?

Two sentences, efficient in length. The second sentence is metaphorical and contributes limited practical value, making it slightly less concise for an AI agent. Could be restructured to front-load key behavioral 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?

No output schema, moderate tool complexity. The description omits return format, error handling, success/failure indicators, and prerequisites. Not complete for a submission tool without additional 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 description coverage is 100% with basic descriptions for all three parameters. The tool description adds domain context ('real-world outcomes', 'cross-layer Axis workflow') but does not enhance parameter meaning beyond the schema. Baseline 3 due to 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 clearly states the tool submits outcomes from an Axis workflow to the Zambo Proven Spark Registry, with a specific verb and resource. The name and context distinguish it from siblings, though no explicit differentiation is provided.

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?

No guidance on when to use this tool vs. alternatives, no prerequisites or exclusions mentioned. The description only states what it does without context for selection.

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 carry full burden. It mentions returning a trust score and outcome history but does not disclose side effects, authentication requirements, rate limits, or any behavioral traits beyond the basic 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 two sentences, front-loaded with the purpose, and every sentence adds value. 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 one parameter and no output schema, the description covers the return values (trust score, outcome history) and the input (identifier). It lacks prerequisites or dependency context but is adequate for a simple check 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 schema has one parameter ('identifier') with a description covering that it can be Swarm ID, Spark hash, or agent identifier. The description adds no new meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description uses a specific verb ('Check'), identifies the resource ('reputation and track record of any agent swarm or workflow'), and specifies the data source ('provenance chain data') and output ('trust score and outcome history across all three Axis layers'). This clearly distinguishes it from siblings like basehawk_score or zambo_score.

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?

No guidance is provided on when to use this tool versus alternatives (e.g., basehawk_score, zambo_score). The description only states what the tool does, not the context or conditions for use.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns a plan (agent roles, tool assignments, execution sequence) and mentions the underlying services (Zambo for strategy, x711.io for execution). However, it does not explicitly state whether the tool is read-only or destructive, nor does it mention authentication, rate limits, or error conditions. This is adequate but leaves gaps in safety and side-effect awareness.

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 at four sentences, front-loading the core action in the first sentence. Each sentence adds distinct information: purpose, format, service providers, return content, and usage recommendation. However, the second sentence ('Plain English in — structured plan out') is somewhat redundant with the first, preventing a perfect 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?

Given the tool's moderate complexity and no output schema, the description covers the main aspects: what the tool does, what input it expects, what it returns (agent roles, tool assignments, execution sequence), and when to use it (first Axis tool for new workflows). Missing are edge cases (e.g., invalid goals, rate limits, or how to execute the resulting plan), but the agent can infer basic usage. The description is sufficiently informative for an agent to decide to invoke it.

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 both parameters (goal and depth) with descriptions, achieving 100% coverage. The description adds minimal value beyond the schema: it reiterates the format ('Plain English in — structured plan out') and mentions the depth options ('quick (3 steps) or full (multi-phase)'), but these are already present in the schema. Therefore, the description does not significantly enhance parameter understanding.

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's purpose: 'Turn any goal into a full executable multi-agent workflow plan.' It specifies input (plain English) and output (structured plan with agent roles, tool assignments, execution sequence). It also positions itself as the 'best first Axis tool,' distinguishing it from sibling tools. However, it does not explicitly contrast with specific siblings like zambo_swarm or axis_swarm_pattern, so it stops 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?

The description provides usage context: it is the 'best first Axis tool for any new workflow.' This implies it should be used first when starting a new workflow, but it does not explicitly state when not to use it or list alternative tools (e.g., zambo_swarm for execution, axis_swarm_pattern for patterns). No prerequisites or exclusions are given, leaving the agent to infer appropriate use.

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

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

No annotations, so description carries full burden. It lists what is returned, giving a clear idea of output. However, it does not disclose whether the tool is read-only, idempotent, or has side effects. The word 'design' suggests no mutation, but this is not explicit.

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 informative. No fluff. The first sentence sets the scope, the second lists benefits. Could be slightly more structured (e.g., bullet points), but effective.

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 adequately details the return components (roles, topology, config, tool assignments, anchor). For a design tool with 3 parameters, this provides sufficient context for an agent to understand expected output.

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 100% of parameters with descriptions. The tool description adds value by specifying what is returned, but it does not clarify the relationship between the input topology parameter and the output topology. The phrase 'Specify your objective and number of agents' omits mentioning topology as an input, which could cause confusion.

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 designs a full multi-agent fleet architecture. Mentions inputs (objective, agent count) and specific outputs (roles, topology, config, tool assignments, anchor). Distinguishes from siblings by claiming 'full trifecta architecture in one call'.

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?

No explicit guidance on when to use this tool versus alternatives like axis_agent_onboard or axis_agent_wire. The description implies it's for initial design, but no when-not or exclusion 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?

No annotations provided, so description carries full burden. It discloses that the tool dispatches other tools, returns live results and provenance chain, mentions daily free limits, and specifies what the return includes. This provides sufficient behavioral transparency for a routing 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?

The description is long but well-structured with clear sections (call format, example, tool lists, MCP config, returns). It is front-loaded with the most critical information. While dense, every sentence earns its place. A minor reduction could improve conciseness.

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 (3 parameters, extensive sub-tool list with pricing, no output schema), the description covers call format, tool availability, pricing, and return content. It lacks details on error handling or rate limiting beyond free tier limits, but overall it is complete enough for an agent to use the tool correctly.

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

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

Schema coverage is 100%, but the description adds significant value: it clarifies the call format, provides examples, warns against using 'args', specifies the flexible nature of 'input', and explains the optional spark_hash parameter. This goes well beyond the schema's basic type and description.

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's function as dispatching any x711.io tool and returning live results plus provenance chain. It specifies the verb 'dispatches' and the resource 'any x711.io tool', distinguishing it from numerous sibling tools that perform specific tasks.

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 call format, examples, and lists free vs paid tools, guiding when to use which sub-tool. However, it does not explicitly contrast with sibling tools or state when not to use this dispatcher, but the exhaustive tool list and pricing effectively indicate usage 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 takes full responsibility. It discloses the tool's purpose, required authentication (email with pass), and rate limits. However, it does not explicitly state whether the tool is read-only, though the nature of scoring implies no destructive actions.

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

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

The description is a single, well-structured paragraph that front-loads the main action and efficiently covers purpose, output, requirements, and alternatives without any 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 the tool's complexity (scoring with multiple output dimensions), the description covers all necessary context: input requirements, output details, authentication, rate limits, and a fallback alternative. No output schema exists, so the description adequately explains the return value.

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 value by contextualizing the email as 'Zambo Pass email' and noting that wallet can accept ENS names. It also provides alternative usage guidance if the user lacks a 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 clearly states the tool scores Base wallet addresses from 0-1000 and returns a detailed intelligence profile including label and breakdown. It distinguishes itself from the sibling tool `bounty_scan` by noting it requires a Zambo Pass.

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 (score a wallet) and when not (if user lacks a pass, use `bounty_scan`). It also specifies the requirement of an active Zambo Pass and provides a link to get one, as well as a rate limit of 500 calls per day.

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, description discloses that the tool returns errors, estimated savings, and a negotiation script. It does not mention side effects or state changes, but the read-only nature is implied.

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: first covers action and outputs, second lists applicable bill types. No fluff, 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?

Tool has 4 parameters, no output schema, no annotations. Description covers core behavior, supported types, and parameter tips. Could mention if any prerequisites (e.g., user account), but fairly complete.

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

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

Schema coverage is 100%, so baseline is 3. Description adds value by noting auto-detection for service_type, explaining 'account_length' as leverage, and encouraging pasting line items.

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 clearly states it audits bills for errors, overcharges, and negotiation opportunities, and lists specific return items (errors, savings, script). It distinguishes from sibling audit tools by focusing on financial bills and subscriptions.

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?

Description explicitly lists supported bill types (phone, cable, insurance, etc.), implying when to use. It does not explicitly contrast with other audit tools or state when not to use, but the scope 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?

With no annotations, the description carries full burden. It discloses that the tool is free, requires no authentication, and returns estimated USDC values. Minor details like rate limits or data freshness are omitted, but for a simple scan tool this is 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?

Two sentences with no wasted words. The action verb 'scan' is front-loaded, followed by scope (36+ protocols, 5 chains) and output. Efficient and clear.

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 low complexity (one required parameter). No output schema, but the description specifies the return type (list with USDC value). It is complete enough for an agent to understand the tool's capability and output format.

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 describes 'address' as an EVM wallet address. The description adds context about scanning for bounties/rewards but does not provide additional parameter details 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 clearly states the tool scans a wallet for unclaimed DeFi bounties, airdrops, claims, and yields across 36+ protocols on 5 chains, returning a list with USDC value. This distinguishes it from siblings like 'contract_scan' or 'tokendiet_analyze' which have different focuses.

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 (wallet address, free, no auth) and implies usage for finding unclaimed rewards. It does not explicitly exclude scenarios or mention alternatives, but the sibling list is large and varied, making implicit differentiation acceptable.

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 tool is a GET request, returns active:true for both passes, and lists included features. It adds value by explaining the pass types and pointing to a full spec.

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, then adds relevant details about passes and usage. While somewhat lengthy, it is well-structured and each sentence contributes meaning.

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 1-parameter tool without output schema, the description is fairly complete: it describes the action, return value, pass details, usage recommendation, and links to full spec. Minor gaps like error handling are acceptable given the tool's simplicity.

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

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

Schema coverage is 100% with the email parameter already described. The description adds context about passes but does not significantly enhance parameter understanding 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?

The description clearly states the tool checks whether an email has an active Zambo Pass or Day Pass. It uses a specific verb (check) and resource (pass), and distinguishes from siblings like day_pass_activate by focusing on status checking.

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 a specific usage scenario: 'Use before bulk API calls to know actual rate limits.' While it doesn't explicitly mention alternatives, it gives clear context for when to use this tool.

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

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

Discloses on-chain payment, auto-expiry, auditability, and attribution. No annotations provided, so description carries full burden. Lacks details on what happens on expiry, but overall good.

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?

Contains some marketing fluff ('This makes Zambo the economic layer...') but effectively front-loads purpose and usage. Could be more concise without losing essential info.

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 most aspects but omits return value or confirmation message. Since no output schema exists, a brief description of what the tool returns would improve completeness. Otherwise 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?

Adds significant value beyond the input schema: pricing per capability, default duration (1 hour), max duration (8 hours), and call format example. Schema coverage is 100%, and description enhances usability.

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 'rent' and the resource 'capability', listing specific capabilities. It distinguishes from sibling tools like capability_search, which is for searching rather than renting.

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

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

Provides clear context for when to use (temporary elevation) and how (payment in $ZAMBO, auto-expires). Includes example call format. Does not explicitly state when not to use or list alternatives, but coverage 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?

No annotations provided, so description carries full burden. It discloses return format (up to 8 results with relevance scores, descriptions, taglines, API endpoints). However, it does not explicitly state that the tool is read-only or safe, though the search nature implies it.

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: first states purpose, second provides return format and usage guidance. No redundant information, highly efficient 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?

Given no output schema, the description covers return content adequately. It mentions the scope (all 100+ tools) and result count (up to 8). Could mention error handling or no-results scenario, but overall sufficient for a search 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% with parameter descriptions, and the tool description adds a helpful list of example queries ('code audit', 'prompt injection defense', etc.), providing strong semantic guidance 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 searches across all 100+ Zambo Stack tools by keyword to find fitting products. It distinguishes itself from sibling zambo_universal by advising to use this before that tool when the exact product is known.

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 'Use this before zambo_universal when you know exactly which product you want.' This provides clear when-to-use guidance and names an alternative tool, which is thorough and helpful.

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 discloses output structure and input limits (max 5000 chars), but lacks explicit mention of read-only nature or 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 concise sentences with front-loaded purpose and efficient use of words; 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?

Despite no output schema, the description covers return values and input constraints comprehensively for a code review 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%, and description adds practical details (e.g., paste directly, auto-detect language, default focus) that aid usage.

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 performs a deep code review with specific outputs (severity-rated issues, security flags, etc.) and lists example triggers, distinguishing it 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?

Explicitly tells when to use (when user says 'review this', etc.) but does not mention when not to use or 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?

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It mentions a usage limit (3 free/day) and indicates the output is ready-to-post copy, but does not disclose whether the tool is destructive, requires authentication, or has any side effects. Given the generative nature, it is likely non-destructive, but this is not explicitly stated.

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 extremely concise: three sentences front-loading the core purpose, detailing the output, and stating a key limitation. Every sentence adds value without redundancy or 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?

Given the absence of an output schema and annotations, the description provides adequate context for a generative tool: what it does, what it returns, and a usage limit. However, it lacks details on expected response format, error handling, or whether it can handle multiple products in one call (the schema only requires one product). It is sufficient but not fully comprehensive.

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 tool description does not add significant meaning beyond the parameter descriptions in the schema; it provides overall context but does not clarify parameter syntax, defaults, or relationships 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?

The description clearly states it generates a complete, platform-optimized content strategy for any product, feature, achievement, or idea, and specifies the platforms and elements included (hooks, thread structures, hashtags, timing). This provides a specific verb-resource combination and differentiates from siblings like 'thread_craft' or 'email_write' by covering multiple platforms and formats.

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 does not provide any guidance on when to use this tool versus alternatives, nor does it mention when not to use it. It gives no context about prerequisites, limitations other than the 3-free-per-day rate, or comparison with similar tools like 'thread_craft' for threads or 'email_write' for newsletters.

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 mentions the tool returns risk level, red flags, negotiation points, and processes in plain English. It does not specify whether the tool is read-only or stores data, which could be important. The behavioral traits are adequately but not exhaustively 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 concise: two effective sentences without waste. The first sentence states purpose and scope, the second lists outputs and usage. 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 tool's complexity, the description covers purpose, inputs, and outputs fairly well. However, without an output schema, the description could be more precise about the format of the returned data (e.g., JSON structure). The mention of 'plain English' and specific outputs helps but leaves some ambiguity.

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% for all 3 parameters, so the description adds little extra semantic value beyond what the schema already provides. The description mentions auto-detection and default party, which is mildly helpful but not substantial.

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 'scan' and the resource 'any contract, terms of service, employment agreement, or legal document'. It lists specific outputs: risk level, red flags with clause location, negotiation points. This is specific and distinguishes it from sibling tools, none of which appear to perform contract scanning.

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 when user pastes a contract... and wants to know what to watch out for.' This provides clear usage context. However, it does not mention when not to use the tool or point to alternatives, though no obvious sibling alternative exists, it could be more explicit.

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

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

No annotations are provided, so the description carries the full burden. It discloses key behaviors: 'Free, no auth', 'Verified daily — dead links auto-removed', and that it's a live index. It does not mention any destructive actions, which is appropriate for a read-only 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?

The description is moderately concise and front-loaded with the tool's name and value proposition. It includes key details but could be slightly shorter. Every sentence adds information, though some repetition exists.

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 simple purpose (listing credit programs) and the thorough schema descriptions, the tool description provides sufficient context. It covers what the tool does, how to use it, and key constraints. Without an output schema, the description doesn't detail return values, but that is acceptable 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?

All three parameters have descriptions in the input schema (100% coverage), so the baseline is 3. The tool description adds minimal value beyond the schema, only restating the purpose of the 'stack' parameter. The schema already includes examples, so no significant addition.

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's purpose: a live, verified index of AI/cloud startup credit programs. It specifies the action ('get matched recommendations') and resource ('credit programs'), and distinguishes it from siblings by focusing on credit programs rather than general startup 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 explains when to use (pass tech stack for recommendations) and provides an alternative (leave empty to get all programs). It does not explicitly state when not to use or compare to siblings, but the context 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?

No annotations are provided, so the description carries full burden. It discloses that activation grants 'instant 24h unlimited access' and specifies exact addresses and amounts. However, it doesn't mention error handling, transaction validity checks, or any idempotency. Still, the core behavioral impact 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?

Two well-structured paragraphs: first instructs core activation with payment options, second provides non-crypto alternatives and monthly option. Every sentence is necessary, front-loaded with key action, and no redundant 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 payment-activated pass with 2 parameters and no output schema, the description fully explains the outcome ('grants instant 24h unlimited access') and covers all payment paths and prerequisites, leaving no gaps for an AI agent to understand 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 detailed descriptions for both parameters (email, tx_hash). The description adds minor context (e.g., email used to link pass, tx_hash sources) but does not significantly improve understanding 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 tool activates a 24-hour unlimited Zambo Pass for $1.49, specifying verb ('activate') and resource. It distinguishes from sibling tools by focusing on this specific one-day pass activation, with no similar tools among 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?

Explicitly provides two crypto payment options (USDC, $ZAMBO) and prerequisites (call zambo-quote for option B), plus alternatives: Card/Apple Pay link for no crypto, and a monthly subscription link. Clearly indicates when to use this tool (after sending payment) and when not.

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 full burden. It discloses the tool returns structured data and works on publicly accessible URLs, implying read-only behavior. However, it does not explicitly state that no data is modified, nor does it mention potential rate limits or authentication requirements beyond the free tier.

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

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

The description is a single paragraph that efficiently front-loads the main purpose, then lists outputs, use cases, and limits. No extraneous information; 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 tool's complexity, the description covers input options, output fields, use cases, and limits. While it lacks an output schema, the listed fields provide adequate context. No mention of error handling or accessibility issues, but the description is reasonably complete for an agent.

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

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

The input schema has 100% parameter description coverage, so baseline is 3. The description adds value by explaining that url and text are alternative inputs and that email enables unlimited analyses, which clarifies usage beyond the schema's 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 extracts structured intelligence from documents, listing document types and return fields. It uses specific verbs and resources. However, it does not explicitly distinguish itself from sibling tools like pdf_extract or contract_scan, which have overlapping capabilities.

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 use cases (e.g., 'summarize this PDF') and mentions free tier limits, but it lacks guidance on when not to use this tool versus more specialized siblings, such as contract_scan for contracts or ghost_audit_report for security audits.

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 mentions 'fast and professionally' but provides no details about auth needs, rate limits, side effects, or what gets destroyed/modified. This is insufficient for a tool that generates content, though it is not 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?

The description is two sentences, front-loaded with purpose and usage. Every sentence adds value with no waste. Highly 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?

Given no output schema, the description covers the return format. It also explains the tool's generative nature well. Only minor gap: no mention of error handling or response structure beyond subject+body.

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 each parameter described. The tool description does not add further meaning beyond the schema, 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 clearly states the verb 'write' and the resource 'email' with specific examples like cold outreach and complaints. It also explains the return value (subject line + full email body). No sibling tools overlap, so differentiation is not needed.

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 lists use cases: 'when user says write an email, help me email, draft a message to, how do I respond to.' It does not mention when not to use or alternatives, but with no email-related siblings, this 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 provided, so description carries full burden. It describes the tool as a search returning specific fields, with no side effects. Mentions free, no auth, unlimited searches. Lacks info on latency or rate limits, but overall clear and honest.

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

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

Four sentences, no redundancy. Each sentence adds distinct value: purpose, return fields, use case, and constraints. Front-loaded with key action ('Search the Zambo Agent Registry').

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 search tool with no output schema, the description covers all essential aspects: what it does, what it returns, how to use it, and how it integrates with other tools (axis_tool_dispatch). Nothing 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%, but description adds value by explaining query types (name, keyword, capability) with concrete examples (e.g., 'web scraping'). Reinforces the purpose of limit and capability parameters. Slightly above 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 it searches a registry of AI agents by capability/name/description, returning specific fields. It distinguishes itself from siblings by mentioning routing via axis_tool_dispatch, and the context of public phone book makes 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?

Explicitly says when to use: 'discover agents that can perform specific tasks'. Mentions alternative action (connect directly or route payments via axis_tool_dispatch). Also notes it's free, no auth, unlimited searches, providing clear usage constraints.

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 generates 3 recipes with step-by-step instructions, cook time, difficulty, and a shopping list, and that it is free and unlimited. However, it does not mention whether it modifies any data or has side effects, but given it is a generation tool, this is acceptable.

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

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

Description is concise (3 sentences) and front-loaded with the core action. It efficiently covers purpose, output, and examples without 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?

Given moderate complexity (4 params, no output schema), description adequately explains the output format (3 recipes with details) and usage scenarios. Lacks only depth on edge cases but sufficient for most agents.

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. Description adds value by providing example input for ingredients and context for optional parameters like vibe and dietary, but does not significantly extend beyond 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?

Description uses specific verb ('turn whatever is in your fridge into a real dinner plan') and resource, clearly stating it returns 3 complete recipes. Distinguishes from sibling tools like meal_plan by focusing on ingredient-based generation and specific output details.

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 with example use cases ('what can I cook tonight?', 'I have eggs and pasta') and mentions dietary preferences. However, does not explicitly state when not to use this tool or mention alternatives 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?

No annotations provided, so description must disclose behavioral traits. It implies read-only retrieval but doesn't explicitly state non-destructiveness or authentication requirements. Rate limits are mentioned, but overall disclosure is adequate 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?

Four sentences, well-structured: purpose first, then details, prerequisite, rate limits. No unnecessary words, 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?

No output schema, but description thoroughly explains return value (full markdown report with score, findings, analysis, fixes). Covers prerequisites and rate limits. Complete for a retrieval 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 for the single parameter audit_id is 100%. The description adds context by specifying that the audit_id comes from ghost_audit_site, which clarifies its origin and ensures correct usage.

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 retrieves a full markdown report for a completed Ghost Audit, listing specific contents (score, findings, analysis, fixes). It distinguishes from siblings like ghost_audit_status (checks completion) and ghost_audit_site (initiates 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?

Explicitly instructs to call ghost_audit_status first to confirm completion, and mentions rate limits (Free: 1 audit/day, Pass: unlimited). Provides clear context on when and how to use the 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 fully discloses behavior: it returns an audit ID, streams output via SSE, and generates a full report in ~90 seconds. The read-only nature is implied by 'audit,' and rate limits are mentioned. No contradictions present.

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 with information but well-structured: purpose first, then stages, then outputs, then limits. It could be slightly shorter, but each sentence adds value. The stage list is clear.

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 one parameter and no output schema, the description adequately covers the audit scope, output formats, and timing. It lacks fine details on finding types but is complete enough for an agent to decide to use it.

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 one param (url) with 100% description coverage. The description adds clarity by requiring 'https://' and providing an example, going beyond the schema's minimal description.

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 runs a '10-stage ghost audit' on any website, specifying the output categories (SEO gaps, AI discoverability issues, etc.) and the stages. This distinguishes it from sibling tools like ghost_audit_report and ghost_audit_status, which handle results separately.

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 usage context: it mentions the free tier (1/day), Zambo Pass for unlimited, and a link for purchase. It also explains the output delivery (stream and download). However, it does not explicitly state when not to use it or suggest alternatives, though the context 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 that the tool returns status and elapsed time, and that 'complete' indicates the report is ready to download. No annotations provided, so description carries full burden; it adequately describes the polling behavior and no destructive side effects. Could mention any rate limits or authentication needs, but not critical for this simple 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 sentences, all essential. No redundant information. Purpose is front-loaded in the first sentence, and each sentence adds value (how to use, output, polling guidance, timing).

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 (1 required parameter, no nested objects, no output schema), the description provides complete coverage: input source, output states, and usage pattern. No gaps remain for an agent to understand how 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?

Schema coverage is 100% with a single parameter audit_id described as 'The audit_id returned by ghost_audit_site'. The description adds the phrase 'Pass the audit_id returned by ghost_audit_site', which reinforces but does not significantly extend 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 clearly states the verb 'check' and the resource 'status of a Ghost Audit'. It specifies the input (audit_id from ghost_audit_site) and the output (complete/running with elapsed time). This distinguishes it from siblings like ghost_audit_site and ghost_audit_report.

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 advises to poll every 15-30 seconds after starting an audit, and gives typical completion time (60-120 seconds). This tells the agent when to use the tool and how often to poll, including implied when not to use (before an audit is started).

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 return behavior (direct URL, looping, embeds inline in Claude/markdown), the auto-selection of motion presets with concrete content mappings (ocean→wave, fire→heat, space→stars), and rate limits. It also clarifies that it both generates the image and applies motion, leaving no ambiguity about 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?

Each sentence serves a distinct purpose: operation, output format, auto behavior, and usage/quota. Information-dense yet not padded, and the main verb+resource is front-loaded. 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 and no annotations, the description fully compensates: it explains the returned URL and embeddability, the workflow, auto-motion presets, trigger phrases, and usage limits. All required parameters are documented, and the tool is easy to invoke correctly with no missing 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 input schema already covers all 3 parameters with descriptions and defaults (100% coverage), so baseline is 3. The description adds valuable semantics by explaining the motion auto-selection logic ('ocean → wave ripple, fire → heat haze, etc.') and giving vivid-description guidance. This extra context justifies a 4.

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

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

The description opens with 'Generate a cinematic animated GIF from any description' — a specific verb+resource. It clearly differentiates from siblings like image_generate (static image) and video_create (video) by explaining the two-step process (AI image + Ken Burns motion effect) and the output format (looping GIF URL).

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 explicit trigger phrases: 'Use when user says: make a GIF of X, animate this, create a loop, make it move' and mentions the quota ('3 free/day · Zambo Pass: unlimited'). However, it does not explicitly contrast alternatives like image_generate or video_create, so it stops short of 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?

No annotations exist, so description carries full burden. It discloses output structure ('grouped changes: features, fixes, breaking changes') and mentions formatting styles. However, it omits potential side effects or limits (e.g., character truncation beyond 3000 chars, error handling for invalid input). Overall, good disclosure for a read-like 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?

Description is two sentences plus a usage phrase, no fluff. Key information is front-loaded. Every sentence adds value. Excellent conciseness.

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 explains the return format (grouped changelog entries). It covers the tool's scope and usage scenarios. Minor missing details: error handling and behavior for malformed input. But overall sufficiently complete for an AI agent.

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 clear descriptions for all four parameters (style, commits, version, repo_url). The description adds no new semantics beyond the schema, but it does not detract. Baseline 3 is appropriate since schema already documents parameters well.

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 clearly states the tool's purpose: converting raw git commits/diff into a professional changelog formatted for various outputs (GitHub releases, CHANGELOG.md, product update). The verb 'turn' and specific resource/output make it unambiguous. No sibling tools share this exact 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?

Description provides explicit when-to-use triggers: 'when user pastes commits, says write a changelog, release notes for, what changed in this diff.' While it implies not using for raw git operations, it does not explicitly list alternatives or when not to use. Still clear context for AI 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 provided, the description fully discloses behavioral traits: polling pattern, status handling, and that approved content may be edited by human. It even instructs to always use the human's version over the original. No contradictions.

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 reasonably concise for the amount of information conveyed. Each sentence serves a purpose, though it could be slightly tightened. It front-loads the core purpose and then details status actions.

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 explains the meaning of each possible status and the content field. It covers all necessary aspects for an agent to use the tool effectively, including error handling for expired status.

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 'review_id'. The description adds value by specifying the format (UUID) and source ('from-hitl_submit'), and includes a call format example that clarifies usage 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 checks approval/rejection status of a review submitted via hitl_submit, with specific verb 'Check whether a human has approved or rejected'. It distinguishes itself from sibling hitl_submit by specifying it is the polling counterpart.

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

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

Provides explicit polling frequency (every 5-10 seconds) and actions for each status (use approved content, stop on rejected, wait on pending, resubmit on expired). Context is clear, but lacks explicit exclusions or alternative tools beyond the reference to hitl_submit.

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. Clearly explains flow: submit, get URL, poll with hitl_check, handle edits. Could mention side effects (creates review request) but overall 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?

Well-organized into usage guidelines, call format, and explanation. Concise but includes necessary details. Could be slightly tighter without losing clarity.

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, but description explains return of review URL and references hitl_check for polling. Covers the main flow, though exact return format could be more explicit. Adequate for agent understanding.

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. Description adds context about context parameter stakes, expires_minutes defaults and max, content max chars. Adds 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?

Describes submitting content for human review, with specific examples (voice transcript, plan, action). Distinguishes from sibling hitl_check which polls for results.

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

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

Provides explicit 'WHEN TO USE' section listing applicable workflows, and shows CALL FORMAT with example. Implicitly indicates when not to use (if no human review needed), covers 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?

With no annotations, the description carries full burden. It discloses capabilities (describe, OCR, code, style), input requirements (public image URL), and rate limits (10/day free, unlimited with Zambo Pass). It doesn't cover error handling or unsupported formats, but overall transparency is good.

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 four sentences, front-loaded with key capabilities, then input requirements, use cases, and limits. 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?

Given no output schema, the description implies return types by listing analysis modes (description, text, code analysis). It covers input, usage, and limits. Missing details on output format, but sufficient for common 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 coverage is 100%, so baseline is 3. The description adds value by explaining each parameter's intent (e.g., mode examples, question examples, URL examples) beyond the schema descriptions, making them more 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 description clearly states the tool's purpose: analyzing images with AI vision, listing specific capabilities (describe, OCR, code review, etc.). It distinguishes from siblings like 'image_generate' by focusing on analysis rather than generation.

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 usage scenarios (e.g., user asks 'what is this?', 'read the text'), and mentions free tier limits. It doesn't explicitly exclude alternatives, but no competing image analysis tools are present among siblings, making the guidance 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?

No annotations are provided, so the description carries the full burden. It discloses the internal pipeline (Groq enhancement, Pollinations rendering), the return format ('direct image URL + markdown embed'), inline rendering behavior, and quota details ('5 free/day · Zambo Pass: unlimited'). This goes well beyond the schema and gives the agent clear expectations.

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 at roughly six sentences and front-loads the purpose before diving into parameter guidance and quota info. It contains some marketing-style phrasing ('stunning', 'anything'), but every sentence contributes actionable information, making it appropriately sized for an 8-parameter tool.

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

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

With no output schema, the description adequately covers the return value (URL + markdown embed), the rendering behavior, the generation pipeline, and quota limits. It also gives recipe-style guidance for common use cases. Minor gaps remain around error handling and image lifetime, but these don't undermine the tool's usability for an agent.

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 8 parameters are described in the schema), so the baseline is 3. The description adds extra practical semantics: 'portrait' for phone/social, 'story' for TikTok/Reels, 'banner' for headers, style examples, negative prompt usage, and count:4 for a variation grid. It doesn't add much for width/height/quality, but the added value is meaningful.

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 identifies the tool as an image generator: 'Generate stunning AI images from any description.' It names the pipeline (Groq enhances, Pollinations renders) and explicitly distinguishes from sibling tools by stating 'image_generate' is the way to generate images in Claude, unlike image_analyze which analyzes images.

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 strong usage context: 'Claude has no native image generation — this is how you unlock it.' It also provides practical when-to-use guidance for each aspect ratio and style, but it doesn't explicitly mention alternative tools for non-generation tasks or state when not to use it, so it lacks explicit exclusions.

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 discloses key behaviors: returns 5 leads with contact info in under 60 seconds, supports 24 trades and any US city, has a daily limit of 3 free searches per IP, and requires no authentication. It does not detail error handling or rate limit enforcement, but covers the main 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?

The description is extremely concise: four short sentences totaling under 40 words, with the core action and output in the first two sentences. 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?

While the description covers the high-level purpose and constraints, it lacks detail on the output format (e.g., structure of lead data) and does not mention error conditions or edge cases. For a simple tool, it is adequate but not comprehensive.

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 both parameters. The description adds value by specifying that the tool supports 24 trades and any US city, and clarifies that the output is 5 qualified leads. This goes 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's purpose: lead generation for contractors and local service businesses by providing a trade type and city to get 5 qualified leads with contact info. It is distinct from siblings like 'leadsignal_generate' by mentioning specific outputs and limits.

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

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

The description implies usage by saying 'provide a trade type and city' and mentions '3 free searches per day per IP' and 'No auth', but it does not provide explicit guidance on when to use this tool versus alternatives or when not to use 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?

No annotations provided, so description carries full burden. Discloses output (5 qualified leads with contact info), speed (under 60 seconds), and usage limit (3/day). Could be more specific about output format or data handling, but covers key behavioral aspects.

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 wasted words. Front-loaded with alias and purpose, followed by key details. Efficient 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?

Given no output schema, description adequately explains what to expect: 5 leads with contact info, and constraints (trades, cities, limit). Could mention output format or handling of limits, but it's mostly complete for a simple 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% with descriptions for both parameters. Description adds value by providing concrete examples ('plumber', 'Chicago'), clarifying the combination and typical usage 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?

Description clearly states it's an alias for leadsignal and specifies the function: AI lead generation for contractors by providing trade and city. It differentiates from siblings by clarifying the alias relationship, and the action is concrete.

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 on when to use: for contractor lead generation. Mentions supported trades (24) and US cities, and daily limit (3 free searches). However, doesn't explicitly state when not to use or compare to 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 provided. Description implies read-only lookup from CoinGecko, but does not explicitly state non-destructiveness, rate limits, or error handling for unknown coins. Adequate but lacks full behavioral disclosure that would be expected without 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, no wasted words. First sentence defines purpose and output, second sentence gives usage guidance. Front-loaded with essential information, quick 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?

For a simple lookup tool with one parameter and no output schema, the description explains what is returned (USD price, change, market cap) and data source. Missing explicit mention of response format or error cases, but covers the main context needed for an AI agent to decide 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?

Only one parameter 'symbol' with 100% schema coverage and a detailed schema description listing many coin tickers. The tool description adds no new semantic info beyond what the schema already provides, meeting the baseline but not exceeding it.

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 clearly states 'Real-time cryptocurrency price lookup for any coin', lists popular coins (BTC, ETH, SOL, etc.), and specifies returned data (live USD price, 24h % change, market cap). It distinguishes itself from sibling tool 'market_pulse' by explicitly saying not to use that for specific coin prices.

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: 'for ANY "what is X price", "X price now", "how much is X", or "X USD" query.' Also gives clear exclusion: 'Do NOT use market_pulse for specific coin prices — use this tool.' Names alternative 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?

No annotations are provided, so the description carries the full load. It discloses caching (30-minute cache) and rate limits (20 free/day), but does not state whether the tool is read-only, requires authentication, or has side effects. The 'deep' depth option implies fresh data, but permissions or idempotency are not addressed.

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 relatively concise with three sentences that cover core purpose, data sources, return items, and usage limits. The list of return items is helpful but slightly verbose. The structure is front-loaded with key information, making it easy to scan. It could be trimmed slightly without losing meaning, but overall 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?

Given no output schema, the description adequately explains return values by listing expected components (headline signal, trending items, etc.) and notes caching and free usage. For a snapshot tool with three optional parameters, this provides sufficient context for an agent to understand what to expect. However, it could elaborate on the structure of individual return items (e.g., momentum rating format).

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

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

Input schema covers all parameters with descriptions (100% coverage). The description adds value by explaining the 'depth' parameter's behavior: 'snapshot' uses cache, 'deep' is always fresh. This goes beyond the enum names. For 'focus' and 'domains', the schema already provides sufficient context, so the description's extra contribution is marginal but beneficial.

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 provides a 'real-time market intelligence snapshot' aggregated from multiple sources, listing specific data origins. The verb 'aggregates' and mention of returns indicate its function. However, it does not explicitly distinguish this tool from sibling tools that may offer similar data (e.g., substrate_breakthroughs, credithunt), missing an opportunity for 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 implies usage for a broad market overview ('snapshot') and mentions caching and free limits, but does not specify when to use this tool versus alternatives or when not to use it. With many sibling tools, explicit guidance on selection criteria would improve usability.

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 grant of 10 calls, uniqueness constraint (one per email), return of success status and upgrade links, and future purchase options. With no annotations, description carries burden and covers key behaviors.

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, front-loaded with main purpose. No redundant words. Each sentence adds essential 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 simple 1-param tool with no output schema, description explains what it does, when to use, and post-use options. Could mention error behavior but overall 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 has 100% coverage with description 'User's email address — gets 10 more free calls + an upgrade pitch email'. Description adds uniqueness constraint 'One extension per email, ever', providing meaningful 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?

States specific action (grant 10 additional free daily calls) and condition (user reached free tier limit). Verb+resource is clear, but does not explicitly distinguish from sibling tools like day_pass_activate.

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 'when a user has reached the free tier limit' and 'Requires an email address. One extension per email, ever.' Provides context but no explicit when-not or 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?

No annotations are provided, so the description carries the full burden. It notes the tool is 'Free, always,' which adds cost context, but it does not disclose side effects, read-only vs destructive nature, or rate limits. The description is adequate but not detailed.

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-loads the main function, and includes usage context and a note about being free. No wasted words – 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?

For a simple tool with 2 optional parameters and no output schema, the description provides enough context: what the tool returns, when to use it, and a free note. It could mention the response format but is sufficiently complete for effective 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 description coverage is 100%, so the description adds limited value beyond what the schema already provides. It lists the target options again and explains the context parameter, but this is not additional insight. 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 the tool returns an install guide and ready-to-paste config blocks for multiple platforms. The name 'mcp_install_guide' aligns with this purpose. Sibling tools like 'zambo_brief' or 'zambo_help' are distinct, so this tool stands out.

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 call: when a user asks about MCP tools or needs install configs for Claude/Cursor/Windsurf. It does not mention when not to use it or list alternatives, but the guidance is clear and actionable.

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 carry the behavioral burden. It mentions returns structured data with prep times, but does not disclose side effects (e.g., persistence), authorization needs, or whether it is a pure generation (read-only). This is adequate but not thorough.

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 extremely concise: two sentences packing purpose, outputs, inputs, and usage triggers. Every sentence adds value with no fluff, and the key info 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?

Given no output schema, the description mentions return type ('structured daily meals with prep times'), which is helpful. It also hints at defaults via examples. However, it doesn't explain error handling, parameter constraints (like days 1-14), or fallback behavior for missing inputs.

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 6 parameters. The description only summarizes the main inputs ('dietary restrictions, budget, cuisine preferences, and number of days'), adding no new meaning 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 clearly states the tool generates personalized meal plans with specific outputs (recipes, macros, shopping list) and lists key input parameters. It distinguishes itself from sibling tools like 'fridge_forge' and 'workout_build' by focusing on meal planning.

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 use cases with example user phrases ('meal plan', 'what should I eat', etc.), making it easy for an agent to match intents. However, it lacks when-not-to-use guidance or alternatives, such as 'fridge_forge' for ingredient-based plans.

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 output is a direct image URL but omits retention policies, rate limits, permissions, or whether the meme is stored. Minimal behavioral context.

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 well-structured sentences: core function, parameter guidance, and usage triggers. No superfluous information; highly 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 meme generator with no output schema and basic parameters, the description covers key aspects. It could add size limits or URL expiry, but overall it's adequate given tool 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 coverage is 100% with clear descriptions for each parameter. The description reiterates 'scene and top/bottom text' but adds no new meaning 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 clearly states it generates a meme image with overlaid caption text as a shareable URL. It distinguishes itself from sibling tools like 'image_generate' by focusing on meme format with text overlays.

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?

Description explicitly lists trigger phrases ('make a meme', 'generate a meme about X') but does not mention when to avoid using it or provide alternatives like 'image_generate' for non-meme images.

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 must carry weight. Discloses rate limit (30 free/day) and pricing accuracy (June 2026). Does not mention side effects or permissions, but minimal for a read-like 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 sentences, front-loaded with purpose, no fluff. Could be slightly more structured (e.g., bullet list) but 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, but description does not mention return format (list of models? scores?). For a recommendation tool, output structure is critical missing 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%, baseline 3. Description adds value by explaining use_case parameter ('personalized Groq-powered insight') and clarifying budget default ('any').

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 clearly states tool provides ranked model recommendations for given task, token budget, and cost constraints. Lists specific providers and use cases, making purpose distinct 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?

Includes best-for examples and notes on free tier (30/day). Does not explicitly state when not to use or mention alternatives, but context 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?

With no annotations, the description fully discloses caching (60 seconds), free access, no authentication required, and interprets the NadHawk score thresholds. It also explains API key auto-provisioning for Zambo MCP users, which are critical behaviors.

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: it first states the primary output, then elaborates on tiers and scores, followed by use cases and API key information. While it is somewhat lengthy, every sentence adds value and the key information is front-loaded.

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

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

Given no input parameters and no output schema, the description comprehensively covers the tool's behavior, output format, and interpretation. It leaves no ambiguity about what the tool returns and how to use it.

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

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

There are no parameters, so schema coverage is 100%. The description adds meaning beyond the empty schema by detailing the returned fields, tier meanings, and score interpretation, which aids an agent in understanding the output even without an explicit output 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 returns top contracts and whale wallets on Monad mainnet, specifying counts (top 10, top 8) and additional data like district breakdown and tier levels. It distinguishes itself from sibling tools which cover diverse other functionalities like agent management, trading, or auditing.

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 use cases are provided: 'contract due diligence, whale tracking, or mapping what's actually active on Monad before deploying or integrating.' It does not explicitly discuss when not to use it or compare to alternatives, but the context is clear enough for an agent to decide.

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 caching behavior ('Cached 30 seconds'), authentication ('Free, no auth'), and all returned fields. It also mentions API key retrieval for direct calls, which adds useful context. Minor omission: no mention of rate limits or potential throttling.

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 slightly verbose (5 sentences) but well-structured: it front-loads the purpose and key metrics, then provides caching and auth info, then usage guidance, and finally API key retrieval details. The API key info could be considered secondary but is relevant for power users.

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 it has no parameters and no output schema, the description covers all necessary context: what the tool returns, how to interpret results, caching behavior, authentication, and even the threshold for network stress. It is entirely self-contained and leaves no ambiguity.

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 with 100% schema description coverage, so baseline is 3. The description does not need to add parameter information. It correctly refrains from repeating what the schema already conveys.

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

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

The description clearly states 'Live Monad mainnet network stats via NadCity' and lists specific metrics. It distinguishes from siblings by focusing on a specific niche (Monad network health) and explicitly states the use case. While 'monad_city' is a sibling, the description's specificity makes the 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?

The description explicitly states when to use: 'Use before any on-chain Monad action to check network health.' It provides actionable thresholds: 'If avgBlockTimeMs > 500 or wsConnected is false, the network is under stress.' This gives clear guidance on interpretation and usage 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?

No annotations are provided, so the description carries full burden. It only says 'Register' without disclosing side effects, idempotency, or what happens upon success, leaving significant behavioral unknowns.

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 extremely concise with two sentences, each carrying essential information. No filler or redundancy, and the most important action ('Register') 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 low complexity (3 params, no output schema), the description lacks details on return value, error conditions, or next steps post-registration, leaving a significant completeness gap for a critical action 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% with parameter descriptions already present. The description adds minimal value by mentioning 'wallet address for payouts' and 'partner_id', but the latter does not match the schema parameter name, reducing clarity.

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 'Register as a Zambo partner' which is a clear verb and resource, but it also says 'Provide a partner_id' while the schema requires 'agent_id', creating a contradiction that undermines 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 includes a condition 'No Zambo Pass required', offering some context for when to use, but it does not explicitly state when not to use or mention alternative tools among the long list of 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, and the description does not disclose behavioral traits (e.g., read-only nature, permissions, side effects). Lacks transparency for a read 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?

Extremely concise single sentence, front-loaded with key info. Could benefit from structured format but is efficient.

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

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

For a simple stats tool with no output schema, the description adequately conveys return values. Completeness is acceptable given low complexity.

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. Description adds no extra meaning beyond the schema; it mistakenly suggests 'partner_id' as a 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?

Clearly states 'Check partner stats' and lists specific outputs (total conversions, pending payout balance). However, it mentions 'partner_id' which doesn't match the parameter names (agent_id, ref_code), causing slight confusion.

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 no guidance on when to use this tool versus alternatives like partner_register. No context on prerequisites or exclusions.

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 states the tool works on public URLs and returns text, word count, and summary, but fails to disclose rate limits, authentication requirements, or error handling for inaccessible URLs.

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 concise sentences with no fluff. The first sentence front-loads the core action and resource, and the second provides clear usage triggers.

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 3 parameters, no output schema, and no annotations, the description is fairly complete. It covers input, process, and output. However, it could mention supported file size limits or that only text is extracted (not images).

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 value by explaining the return fields (text, word count, summary) and implying the purpose of max_chars and summarize, which the schema only 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 uses specific verbs ('Fetch and extract') and resources ('text content from any public URL') and explicitly lists supported document types (PDF, web pages, articles, docs). It clearly distinguishes from sibling tools by focusing on extraction and summarization from URLs.

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 use cases ('when user says read this PDF, extract from this URL, summarize this document') but does not mention when not to use the tool or suggest alternatives like doc_intel for structured data.

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; description discloses actions and parameter structure with an example, but lacks details on side effects, auth requirements, or return behavior beyond the schema.

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

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

Description is very concise: two sentences plus a call format example. Every piece 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 complexity of actions and lack of output schema, the description covers actions and parameters but does not explain return values, error handling, or what the agent can expect after execution.

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 already covers all 3 parameters with descriptions (100% coverage), but the description adds value by enumerating action values and showing params structure in a concrete example.

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 clearly states 'Perform an action with a Presence identity' and lists four specific actions (submit_form, post_json, wait, scroll), distinguishing it from sibling tools like presence_navigate or presence_post.

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 lists available actions and provides a call format example, but does not explicitly state when to use this tool versus alternatives, nor when not to use 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?

No annotations are provided, so the description carries full burden. It mentions using a 'Presence identity's session' but does not clarify session prerequisites, whether the extraction is read-only, error behavior for invalid URLs, or any other side effects. The behavioral disclosure is minimal.

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 extremely concise: a single sentence stating purpose, followed by a list of targets and a call format example. Every word is informative, and the structure is front-loaded with the core purpose. No unnecessary 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 output schema, the description does not explain the return format. It also fails to mention session validity requirements or error handling. For a tool with three simple parameters, this is sufficient to understand basic invocation, but it lacks detail on prerequisites and output structure.

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 provides basic descriptions for all three parameters. The description adds value by explaining the meaning of each target option (e.g., 'meta (title/description/h1)') and includes a call format example. This additional context helps the agent understand parameter semantics 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?

Description clearly states the tool extracts structured data from a URL using a Presence identity's session. It lists the four target types (meta, text, links, all) with brief explanations. This distinguishes it from sibling presence tools like presence_screenshot, presence_navigate, etc., which serve different 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 implicitly indicates usage for extracting structured content from a URL, but it does not explicitly state when to use this tool versus alternatives (e.g., presence_screenshot for visual capture, presence_navigate for navigation). No when-not-to-use guidance is provided.

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

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

With no annotations, the description discloses session persistence and return values. However, it omits potential side effects (e.g., rate limits, authentication requirements, or destructive actions), leaving the agent partially informed.

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 plus a code example, all essential. Information is front-loaded with purpose, return values, and session behavior. No 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?

Covers return values and session persistence, which is sufficient for a navigation tool without an output schema. Could mention HTTP method and body usage, but 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% with descriptions for all 4 parameters. The description adds a call format example (identity_id and url) but does not elaborate on 'body' or 'method' beyond what the schema provides, adding minimal new insight.

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 action 'Navigate to a URL' using a specific resource 'Presence identity's persistent session'. Distinguishes from sibling tools like presence_act or presence_extract by focusing on navigation and session persistence. Also lists returned data (page title, text, links, HTTP status, cookies).

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?

Implicitly suggests use for navigating with a persistent session and mentions cookie carry-over, but does not explicitly state when not to use this tool or provide alternatives among the presence 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 the full burden. It discloses authentication requirements, platform list, and character limit for X. However, it does not mention error handling, idempotency, or whether posting overwrites existing content.

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 plus a concise code example. All information is front-loaded: purpose, prerequisite, platforms, call format. 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 posting tool with 4 parameters and no output schema, the description covers purpose, auth, platform list, and example. However, it lacks information about the return value or error cases, which would be helpful given 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?

Schema coverage is 100% with parameter descriptions. The description adds value beyond schema by explaining the auth requirement, listing supported platforms, and providing a call format example. This compensates for the schema's minimal 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 action 'Post content as a Presence identity on a given platform', specifies the resource, and lists specific platforms. This distinguishes it from sibling tools like presence_act, presence_reply, 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 explicitly mentions a prerequisite: 'Requires an attached session with valid auth cookies.' It also provides a list of supported platforms and an example call format. However, it does not mention when not to use this tool or 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?

With no annotations provided, the description carries the full burden. It discloses the auth requirement but does not detail behavioral traits such as rate limits, idempotency, error handling, or return behavior. Some transparency is present via the call format example.

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 extremely concise: two sentences and a code example, with no extraneous information. The purpose is front-loaded, making it easy for an agent to quickly understand the tool.

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

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

Given the tool's mutation nature (replying), the description adequately covers the action and auth requirement. However, it omits details about the return value (e.g., success/failure indication) and any potential side effects. Minor 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?

The input schema has 100% coverage with descriptions for all four parameters. The description adds value by providing a call format example with concrete values (e.g., 'uuid', 'x', 'tweet_id_here'), which clarifies expected formats beyond the schema definitions.

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's function: replying to a post/comment as a Presence identity. It uses a specific verb ('Reply') and resource ('post/comment'), distinguishing it from sibling tools like presence_post (creating new posts) and presence_act (a broader action).

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 a prerequisite ('Requires an attached session with valid auth cookies') but does not explicitly state when not to use the tool or compare it to alternatives. Usage context is implied but not fully specified.

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. States return type (structured text) and runtime (HTTP). Mentions using a Presence identity's session; lacks details on prerequisites, errors, or idempotency, but sufficient for core behavior.

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 focused sentences: purpose, output type, call format. No redundancy, essential info 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?

Adequately describes inputs, outputs, and key differentiator (vs visual screenshot). Missing mention of session prerequisite and error cases, but overall sufficient for a simple 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 descriptions cover 100% of params, but description adds value with call format (uuid, https validation) and clarifies role of identity_id and url beyond schema labels.

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-result: 'Get a structured content summary of a URL' with explicit elements (title, H1, description, body text, links). Distinguishes from visual screenshots via Playwright mention, defining scope precisely.

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?

No explicit when-to-use or when-not-to-use vs siblings like presence_extract or presence_navigate. Implies usage for text extraction vs visual, but no direct comparison or exclusion criteria.

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 cookies are encrypted with AES-256-GCM before storage, which is a critical security detail. No annotations present, so description carries the burden. Could add information about 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?

Two concise sentences plus a formatted call example. Every sentence adds unique value: purpose, prerequisite instructions, encryption detail, and call format. 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?

No output schema and no description of what the tool returns (success/failure, attached session info). For a mutation tool, knowing the response is important. Otherwise, the description covers purpose, usage, and security 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 coverage is 100% (3 parameters all have descriptions). The description adds value by showing the exact JSON array format for cookies and providing a sample call with real values, which helps the agent understand the expected structure.

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 'Attach' and resource 'real browser session cookies to a Presence identity' clearly state the tool's action. Distinguishes from sibling tools like presence_session_create which manage sessions at a different level.

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

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

Provides explicit step-by-step instructions for exporting cookies from DevTools and a call format example. However, does not mention when to use this tool versus other presence tools like presence_session_create or presence_session_kill.

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 discloses that a persistent identity with encrypted storage, audit log, and policy controls is created, but does not describe the return value, side effects, or lifecycle implications. The behavioral 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 four sentences long and front-loaded with the primary purpose. It includes an example call, which is useful. No redundant information; each sentence adds value. Could be slightly more structured, but currently concise enough.

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 (4 parameters, no output schema, no annotations), the description covers the purpose and key features but lacks information on the return format (e.g., session ID) and how to use the created identity with sibling tools. It is minimally complete but has notable gaps.

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