Zambo AI Tools

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

No annotations are provided, so the description carries the burden. It discloses rate limits ('5 free/day') and premium access ('Zambo Pass: unlimited'), which is helpful. However, it does not state whether the tool is read-only, whether it fetches external data, or any side effects (e.g., caching, API calls). With zero annotations, more behavioral detail would be warranted.

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 long but front-loaded with the main action and outputs. Every sentence adds value (outputs, use cases, limits). Minor improvement: the list of outputs could be more concise, but still 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?

Given the tool's complexity (multiple input parameters, no output schema), the description adequately covers inputs, outputs, use cases, and constraints. It lacks details about error responses or output format, but overall is sufficient for an AI agent to understand the tool's capabilities.

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 each parameter. The description adds context for the overall tool but does not elaborate on individual parameter semantics beyond what the schema provides (e.g., default depth is 'quick', focus area options). 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 ('generate') and clearly defines the resource ('structured briefing') on a wide range of topics. It lists concrete outputs (capabilities, endpoints, pricing, etc.) and target use cases (onboarding, competitive intelligence). This differentiates it from sibling tools, which appear to focus on hiring, access, scoring, 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 states the tool is 'perfect for' four specific scenarios (onboarding, competitive intelligence, understanding APIs, generating docs). However, it does not mention when NOT to use it or provide alternatives, so it falls short of a 5.

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

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

With no annotations, the description carries the transparency burden. It discloses the x402 escrow mechanism and USDC settlement, but lacks detail on side effects (e.g., irreversible hires, listing modifications), auth requirements, or rate limits. Some behavioral context is provided but incomplete.

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

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

Two sentences with no waste. Front-loaded with the tool's purpose and ecosystem. Essential information is presented efficiently.

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

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

Given 8 parameters and no output schema, the description provides an overview and return categories but lacks detailed error handling, pagination (for browse), or structured return field explanations. Sufficient for simple use but incomplete for complex scenarios.

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 groups parameters by action and adds marketplace context, but does not significantly enhance parameter meaning beyond the schema descriptions. It adds narrative value but not technical depth.

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 browses, hires, or lists agents on the Zambo Agent Marketplace, with specific actions and ecosystem context. It distinguishes from potential siblings like find_agent by offering a unified marketplace interaction.

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 when to use each action (browse, hire, list) but does not explicitly compare to sibling tools or state when not to use this tool. No exclusions or alternatives are mentioned.

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 full burden. It describes actions (load, save, snapshot) and notes skills accumulate over time, wallet and context persistence. However, it does not specify whether save overwrites or merges, or mention any side effects or auth requirements.

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

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

The description is reasonably concise given the complexity, with a clear front-loaded statement of purpose. Every sentence adds value, though the bulleted actions and call format could be slightly streamlined.

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 5 parameters, 2 required, 100% schema coverage, and no output schema, the description explains the function well. It covers the main actions and parameters, but lacks details on return values or error conditions, which is acceptable without an 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 description coverage is 100%, but the description adds significant value by explaining the overarching purpose and providing context for each action (e.g., 'load = retrieve full identity + session key'). It also clarifies the call format, which 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 establishes a persistent agent identity across clients, model updates, and chain migrations. It distinguishes from sibling tools by focusing on identity persistence and continuity, and includes specific verbs like load, save, snapshot.

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 context for use (cross-client persistence) and gives a call format example. It mentions other agents can query track record, but does not directly compare to siblings or state when not to 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 of behavioral disclosure. It states it returns an onboarding package, but does not mention safety, permissions, side effects, or whether the operation is read-only or modifies state. This is a significant gap for a tool that likely interacts with an agent's configuration.

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 one concise sentence that efficiently communicates the tool's purpose and output. No redundant information. Could be slightly more structured (e.g., bullet points) but is acceptable.

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

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

The description explains what the tool does and what it returns, which is sufficient for a briefing tool. Since there is no output schema, the description compensates by listing the return content (stack capabilities, tool inventory, workflows). However, it lacks details on error handling or prerequisites, but overall is reasonably 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% as both parameters have descriptions. The description adds no new meaning beyond the schema: 'agent_purpose' is described as 'for the agent's purpose' (repeating the schema), and 'focus' is not elaborated. Baseline 3 is appropriate since the schema already documents the parameters adequately.

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 'brief' and the resource 'new AI agent on the complete Zambo + x711 stack'. It specifies the output: an onboarding package with stack capabilities, tool inventory, and workflows. However, it does not differentiate from the sibling tool 'agent_brief', which likely serves a similar 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?

No guidance is provided on when to use this tool versus alternatives. The description implies usage for onboarding new agents but lacks explicit when-to-use or when-not-to-use statements, and does not reference any sibling tools for comparison.

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 features (logging, monitoring, identities) but doesn't mention side effects, authentication requirements, or whether it deploys or only generates config.

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 usage note, all front-loaded with key information. 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 4 parameters and no output schema, description provides adequate context but lacks details about the generated config structure or deployment steps.

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 limited parameter context beyond schema; it doesn't explain topology options or task format further.

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 wires two AI agents via Entangler.tech for trustless coordination, generating a config with specific features. It distinguishes from sibling tools like axis_spark_to_swarm by stating it's used after that 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?

Explicitly says 'Use after axis_spark_to_swarm to wire the agents it planned.' This provides clear sequential context 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, the description must fully disclose behavior. It mentions the output (SHA-256 hash) but does not state if the tool modifies state, requires permissions, or has side effects. It is unclear whether this is a pure read operation or if it creates records. The missing behavioral details are a significant gap.

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, front-loaded sentence that efficiently conveys the action, inputs, and output. Every word contributes meaning without redundancy. Ideal conciseness for a tool of this complexity.

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

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

Given the absence of an output schema, the description sufficiently explains the return value (SHA-256 hash). It names the input parameters in context. However, it lacks prerequisites (e.g., how to obtain a spark hash) or error conditions, which slightly reduces completeness.

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

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

Schema coverage is 100% with both parameters described. The description adds minimal extra meaning beyond restating the parameters in context ('Zambo Spark', 'x711 execution log'). It does not introduce new constraints or format details, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: it generates a cryptographic proof chain linking a Zambo Spark strategy to its execution log, returning a SHA-256 hash. It uses specific terms like 'Zambo Spark' and 'x711 execution log', which distinguishes it from sibling tools like 'proof_certify' or 'zambot_verify'. No ambiguity.

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

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

The description implies usage when one has a strategy and execution log to prove provenance, but it does not explicitly state when to use this tool versus alternatives (e.g., 'proof_certify'). No when-not or explicit context is provided, limiting guidance for an 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?

No annotations are provided, and the description only mentions that the tool searches simultaneously and returns results. It does not disclose any behavioral traits such as rate limits, authentication needs, or potential side effects, leaving the agent without critical safety information.

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

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

The description is a single, well-structured sentence that efficiently conveys the tool's purpose and output. Every word contributes to understanding, making it appropriately concise and front-loaded.

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

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

The description is adequate for a simple tool with few parameters, but it lacks details on the output format, ranking criteria, and the nature of 'integration paths.' No output schema exists to fill these gaps, so slightly more context would improve completeness.

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

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

Schema coverage is 100% (both parameters have descriptions), so the baseline is 3. The description adds no additional meaning beyond what the schema already provides, making it adequate but not value-adding.

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

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

The description clearly states that the tool searches capabilities and tools across three specific networks (Zambo, x711, Entangler) simultaneously and returns ranked results with integration paths. This differentiates it from sibling tools like capability_search by specifying the scope and result type.

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 cross-network searches by naming the three networks, but it does not explicitly state when to use this tool vs alternatives like individual network searches or other sibling tools. No context on when not to use it 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?

No annotations are provided, so the description carries the full burden. It describes the core behavior (comparison, flagging, recommendations) but does not explicitly state if the tool is read-only, has side effects, or requires specific permissions.

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 efficiently convey the purpose and behavior. No redundant words, and the core action 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 clear purpose and parameter descriptions, the description lacks details about the output format (e.g., what does 'flags misalignment' mean in terms of return value?). Without an output schema, the description should specify the response 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 coverage is 100% with both parameters described. The description reinforces the schema by linking 'spark_hash' to 'original strategy plan' and 'current_outputs' to 'swarm behavior', but adds no new semantic detail beyond the schema.

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

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

The description uses a specific verb 'monitor' and resource 'running agent swarm', clearly stating it compares drift against an original plan. It distinguishes itself from siblings like 'zambot_drift' by mentioning 'auto-correction recommendations'.

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 monitoring drift, but does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives among sibling tools.

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

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

No annotations provided, so the description carries full burden. It states 'Free, no auth' indicating safe access, and describes the return content, but lacks details on potential rate limits, data size, or other behavioral traits beyond what is returned.

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

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

Three sentences, no fluff. First sentence states purpose, second lists returns, third adds value (free, no auth). Every sentence earns its place.

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

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

For a simple parameterless tool with no output schema, the description is complete. It clearly states what the tool returns and that it requires no authentication, which is sufficient for an agent to understand 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?

The tool has no parameters, so the description does not need to add parameter information. Baseline score of 4 is appropriate.

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

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

The description clearly states the tool retrieves the Axis MCP configuration, listing the returns (config block, tool directory, architecture overview). However, it does not explicitly differentiate from sibling tools, many of which are axis_ 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?

No guidance on when to use this tool vs alternatives. The description mentions it's free and requires no auth, but does not specify scenarios where this configuration retrieval is needed or when other tools are more appropriate.

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 continuity package with unique IDs, serialized context, and a write call to persist via Entangler MEMORIA. This implies a write operation but doesn't elaborate on side effects or permissions.

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 long, front-loads the action and mechanism, and succinctly describes the return value. 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 tool's simplicity (4 params, no output schema), the description adequately covers the process and return value. It lacks error cases or prerequisites but provides enough information for an agent to understand the core functionality. With output schema absent, the description compensates reasonably well.

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, including enums for from_layer and to_layer. The description adds high-level context (e.g., 'any direction') but does not provide additional parameter-specific semantics beyond what the schema already conveys. 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's purpose: packaging context from one layer and handing it off to another via Entangler MEMORIA. It explicitly lists the possible layers (Zambo, x711, Entangler) and directions, making it distinct from sibling tools like axis_agent_wire or axis_chain_proof.

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

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

The description provides clear context on when to use the tool (for cross-layer handoffs) with concrete examples of directions. However, it does not explicitly state when not to use it or mention alternative tools, so it misses some guidance.

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

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

No annotations exist, so the description must disclose behavioral traits. It mentions 'cryptographic proof' but does not specify side effects, permissions, or whether the operation is destructive. The submission nature implies writing, but details are missing.

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

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

The description is two sentences with no unnecessary text, but uses jargon ('cross-layer Axis workflow', 'cryptographic proof') that may reduce 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?

With 3 parameters, no annotations, and no output schema, the description should provide more behavioral and outcome context. It lacks details on return values, error handling, or validation, making it insufficient for a submission 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 all parameters. The tool description adds no additional semantic context beyond what the schema provides, meeting the baseline for full 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 action (submit outcomes) and the target resource (Zambo Proven Spark Registry), but does not differentiate from sibling tools like zambot_outcome or zambot_verify.

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 vs alternatives. The description implies it's for closing a workflow loop but lacks context for when not to use or prerequisites.

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 states that the tool 'checks' reputation using provenance chain data and returns a trust score and outcome history, implying a read operation. However, it does not disclose any side effects, authentication needs, rate limits, or what happens if the identifier is invalid. The behavioral transparency 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 extremely concise with two sentences. The first sentence states the action and resource, the second states the output. Every word is necessary, no 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 tool's simplicity (one parameter, no output schema, no annotations), the description is minimally complete. It explains what the tool does and what it returns. However, it lacks context about the 'three Axis layers' and does not clarify the output format or any limitations. For a tool with zero annotations, more detail would improve completeness.

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

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

Schema description coverage is 100% for the single required parameter 'identifier', and the schema description already says 'Swarm ID, Spark hash, or agent identifier'. The tool description does not add any additional meaning or format guidance beyond that. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the verb 'Check' and resource 'reputation of agent swarm or workflow', and specifies using provenance chain data. It also mentions the return values: trust score and outcome history across three Axis layers. This distinguishes it from many sibling tools, though it does not explicitly differentiate from similar check tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, typical use cases, or scenarios where this tool is preferred over others like 'axis_drift_monitor' or 'axis_chain_proof'. The agent must infer usage from the purpose alone.

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 outputs and mentions the agents involved (Zambo, x711.io), but does not disclose whether the tool is read-only, what side effects exist, or if it requires certain permissions. The lack of destructive or mutability hints is a gap, though the tool appears to be a planner.

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 (4 sentences), front-loaded with the primary action, and every sentence adds distinct value: purpose, medium, component roles, output summary, and usage recommendation. 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 moderate complexity (2 params, no output schema), the description adequately specifies the output (agent roles, tool assignments, execution sequence) and mentions key agents. It provides enough context for an agent to understand the tool's scope, though it lacks examples or edge-case handling.

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 both parameters already described (goal: 'Your goal in natural language — any domain'; depth: enum with quick/full). The description adds only minimal extra context like 'Plain English in' and 'structured plan out,' which does not significantly enhance parameter semantics.

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

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

The description clearly states a specific verb ('Turn...into') and resource ('multi-agent workflow plan'), and distinguishes from siblings by calling it 'Best first Axis tool for any new workflow,' setting it apart from the many specialized sibling tools.

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

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

The description explicitly guides when to use this tool ('best first Axis tool for any new workflow'), providing strong context. However, it does not mention when not to use it or compare to specific alternatives among the numerous sibling tools.

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

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

No annotations are provided, so the description carries full burden for behavioral traits. It describes the tool's positive output (returns roles, config, assignments) but does not disclose any side effects, authentication requirements, rate limits, or potential failure modes. For a tool generating a full architecture, this is insufficient transparency.

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

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

The description consists of two succinct sentences. The first sentence immediately conveys the core purpose. The second sentence lists the key outcomes without extraneous details. Every word earns its place, making it highly efficient for an agent to parse quickly.

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 (swarm architecture with multiple outputs) and no output schema, the description provides a high-level summary but lacks detail on output format, prerequisites (e.g., user account on Entangler), or error handling. It is adequate for basic understanding but incomplete for precise invocation 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 coverage is 100%, so the baseline is 3. The description mentions specifying objective and number of agents, but adds no deeper semantics beyond what the schema already provides (e.g., constraints on agent_count, default values). It does explain the output structure, which relates to parameters indirectly but does not 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 verb 'Design' and the resource 'full multi-agent fleet architecture on Entangler.tech'. It specifies what the tool provides: agent roles, topology, config, assignments, and anchor. This distinguishes it from sibling tools that focus on individual aspects (e.g., axis_agent_wire for wiring, axis_spark_to_swarm for conversion).

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 when needing a complete architecture design by saying 'Specify your objective and number of agents — get back ...'. However, it does not explicitly mention when not to use this tool or suggest alternatives like axis_agent_onboard for onboarding steps. The context is clear but lacks exclusion guidance.

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

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

No annotations are provided, so the description carries full burden. It explains the dispatch mechanism, return of live results and provenance chain, and even notes what the return includes: exact call format, expected output, and which Axis tool to chain next. It lacks details on destructive actions or rate limits but is otherwise transparent.

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

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

The description is overly long (multiple paragraphs) with a large block listing all 33+ tools by name. While front-loaded with the call format, the tool list includes pricing and MCP config that could be referenced elsewhere. Not every sentence earns its place; the description is verbose.

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 dispatching to 34+ tools, the description is comprehensive. It covers: the dispatch pattern, required and optional params, free vs paid tools, MCP config, return contents, and chaining hints. There is no output schema, but the description compensates by describing return aspects.

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

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

Schema coverage is 100% with all three parameters described. The description adds significant value: it warns against using 'args', explains 'input' as query/URL/address/task, provides concrete examples, and lists permissible tool values. This goes well 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 dispatches any x711.io tool and returns live results + provenance chain. It uses specific verb 'dispatches' and resource 'x711.io tool', distinguishing it from siblings like axis_agent_onboard or axis_mcp_access which are specific sub-tools.

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

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

The description provides the call format, required parameters, examples, and distinguishes between free and paid tools. It does not explicitly state when not to use this tool or list alternatives, but the extensive example usage and tool catalog imply appropriate contexts.

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 fully handles behavioral disclosure. Discloses pass-gated access, daily rate limit (500 calls/day), and mentions response structure. Could explicitly state read-only nature but 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?

Three concise sentences: purpose, output details, usage restrictions with alternative. No wasted words, front-loaded with core action.

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 2 parameters, no output schema, and no annotations, the description covers purpose, output breakdown, access requirements, rate limit, and alternative tool. Missing response format details, but overall complete for agent invocation.

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

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

Schema coverage is 100% and already includes descriptions for both parameters (email and wallet). Description does not add meaning beyond schema; it merely repeats the requirement and the fact that wallet can be an ENS name, which is already in schema. Baseline score of 3 applies.

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

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

Clear verb 'Score' and specific resource 'Base wallet address'. Specifies output: intelligence profile with score, label, and breakdown across categories. Distinguishes from sibling tool 'bounty_scan' for users without a 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?

Explicitly states requirement of an active Zambo Pass and provides link. Directs users without a pass to use 'bounty_scan' as a free alternative, offering clear when-to-use and when-not-to-use guidance.

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

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

With no annotations, the description carries the full burden. It discloses that the tool returns errors, estimated savings, and a negotiation script. No destructive behavior is implied, and the audit nature is non-destructive, meeting expectations for transparency.

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

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

The description is concise, using three sentences to convey purpose, outputs, and scope. It is front-loaded with the primary function and well-structured.

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

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

Despite no output schema, the description explains return values (errors, savings, script) sufficiently. Given tool complexity and high schema coverage, the description is complete enough for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds minimal extra meaning beyond schema examples (e.g., service_type list matches schema). It provides context for bill_description but 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 audits bills, subscriptions, or service charges for errors and overcharges, and lists specific use cases. It distinguishes itself from sibling tools by focusing on financial audit and negotiation.

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 enumerates supported bill types (phone, internet, etc.), providing clear context for when to use. It does not explicitly mention when not to use or compare with alternatives, but the scope is well-defined.

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 auth, and returns a list of claimable positions with estimated USDC value. This implies a read-only operation with no side effects. It could mention idempotency or rate limits, but it's sufficient.

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

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

The description is two sentences long, front-loaded with the core functionality, and every word adds value. No superfluous 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 only one parameter, no output schema, and no annotations, the description covers the core functionality: chains, protocols, returned data, and authentication. It could explicitly state that only EVM addresses are supported (only in schema description), but overall it is 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 one parameter. The description does not add significant meaning beyond the schema's parameter description ('Wallet address to scan for unclaimed bounties and rewards'). With high coverage, 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, and rewards across 36+ protocols on 5 chains, with a specific verb ('Scan'), resource ('wallet'), and scope. It effectively distinguishes from sibling tools that focus on agent onboarding, audits, or other functions.

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 usage-related notes ('Free, no auth required') and clearly implies the tool is for checking unclaimed rewards. However, it lacks explicit guidance on when not to use it or comparisons to alternative scanning tools like basehawk_score.

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?

Despite no annotations, the description discloses key behavioral traits: it returns 'active:true' for both passes, lists the features of each pass, and gives the exact API endpoint. It implies a read-only operation, which is appropriate for a check 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 relatively long but well-structured, starting with purpose, then pass details, usage guidance, and endpoint. While not overly verbose, it could be slightly more concise 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?

Given the single parameter and no output schema, the description provides all necessary context: what the tool checks, what the passes include, why to use it before bulk calls, and the API endpoint. It is sufficiently complete for an AI agent to use correctly.

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

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

The sole parameter 'email' is already well-described in the schema ('Email address to check for active Zambo Pass'). The description adds slight context by mentioning both Zambo Pass and Day Pass, but does not significantly enhance parameter understanding beyond the schema.

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

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

The description begins with a clear statement: 'Check whether an email address has an active Zambo Pass or Day Pass.' It specifies the verb (check) and resource (email address), and distinguishes from siblings like 'day_pass_activate' which is for activation, not 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 explicitly advises 'Use before bulk API calls to know actual rate limits,' providing a clear usage scenario. It does not, however, mention when not to use or list alternative tools among the siblings, which keeps it from a perfect score.

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

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

Since no annotations are provided, the description carries full burden. It discloses on-chain payment in $ZAMBO, auto-expiry, auditing, and storage in agent identity track record. It does not mention destructive actions or side effects beyond burning tokens, but the behavior is adequately transparent.

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

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

The description is verbose with marketing language ('This makes Zambo the economic layer...') that could be removed. The core information is present, but conciseness suffers. The call format example is useful but could be integrated more succinctly.

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 3 parameters, the description covers purpose, parameters, behavior (payment, expiry, audit), and provides a usage example. It is fairly complete for an agent to understand how to invoke 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%, so the schema already documents parameters. The description adds context: email ties to agent identity, capability enum with prices, duration_hours default/max. It also includes a call format example, adding value 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: temporarily elevating an agent to a higher-capability tier by renting a premium capability. It lists specific capabilities with prices and provides a call format example. This distinguishes it from sibling tools like capability_search, agent_brief, etc., which serve different functions.

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 temporary capability upgrades without subscriptions or lock-in, and mentions auto-expiry. It provides a call format example. However, it does not explicitly state when not to use or compare to alternatives, 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?

Discloses return contents (up to 8 products with scores, descriptions, etc.) and the scope (all tools, 2 MCPs). No annotations are provided, so the description carries the full burden, which it does well for a search tool.

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

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

Two sentences with no wasted words: first sentence states purpose and scope, second gives usage guidance and limit. Front-loaded and efficient.

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

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

No output schema, but the description explains return formats. Covers purpose, usage, and constraints. Could add error handling or prerequisites, but 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%, and the schema already provides a description and examples for the only parameter 'q'. The tool description adds minimal extra semantic value 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 50+ Zambo Stack tools (2 MCPs) by keyword to find tools fitting the use case, distinguishing it from siblings as a meta-search 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?

Explicitly advises using this before zambo_universal when you know exactly which product you want, providing clear usage context. However, it does not mention when not to use it or list other alternatives.

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

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

No annotations are provided, so the description carries the full burden. It discloses the review depth, severity levels, and output categories. However, it could mention the 5000-char limit and any side effects (none expected) for completeness.

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 defines the tool's capability, second lists usage triggers. No fluff, front-loaded with key 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, the description compensates by listing return types (critical/high/medium/low issues). The usage triggers and parameter hints make it complete. Could mention max input length explicitly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no supplementary parameter information 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 it performs deep code review with severity-rated issues, security flags, performance notes, and specific fix suggestions, which distinguishes it from all sibling tools.

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

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

Explicitly lists trigger phrases like 'review this', 'what's wrong with', 'is this secure', and 'how can I improve', making the usage context unambiguous.

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

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

No annotations provided, so description carries full burden. Discloses outputs (copy for platforms, hooks, hashtags, timing) and rate limit. Does not mention side effects, authentication needs, or whether generated content is saved or editable.

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

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

Three sentences, no fluff, front-loaded with main purpose. Each sentence adds meaningful information: what it does, what it returns, and a usage constraint.

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, description covers key aspects: input types, output content, platforms, tone options, and rate limit. Missing details like whether output is editable or if any data is stored, but overall sufficient for an 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 each parameter described. Description adds context about platforms and tones but does not significantly enhance beyond schema definitions. 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?

Clearly states what the tool does: generate a platform-optimized content strategy with ready-to-post copy. Specific verb 'Generate' and resource 'content strategy'. The description uniquely identifies the tool's output for multiple platforms.

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?

Mentions '3 free/day' implying a rate limit, but no explicit guidance on when to use this tool over alternatives. Sibling tools include other content-related tools like zambo_compose, but no comparison 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?

No annotations are provided, so the description carries the full burden. It states the output (risk level, red flags) but does not disclose any behavioral traits such as whether the tool stores data, requires authentication, or has side effects. For a read-only scanning tool, this is adequate but not excellent.

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 output, second covers usage examples. Every sentence adds value, front-loaded with key information. No wasted words.

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

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

For a tool with 3 parameters, no output schema, and no annotations, the description fully explains input parameters and return values (risk level, red flags, clause locations, negotiation points). It is complete enough for an AI agent to invoke correctly.

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

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

Schema description coverage is 100%, and the description adds meaning beyond the schema by explaining contract_type as a hint that is auto-detected, perspective as the party, and contract_text as the full text. It also lists example document types, enhancing context.

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 contracts/legal documents for red flags, returning risk level, specific red flags with clause location, negotiation points, and what to push back on. It specifies the resources (contracts, TOS, NDA, etc.) and the action (scan and explain), distinguishing it from other 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 explicitly says 'Use when user pastes a contract, TOS, NDA, lease, or employment agreement' and provides examples of when to use it. It gives clear context for invocation.

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

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

No annotations provided, so description carries full burden. It discloses that data is verified daily and dead links are auto-removed, providing behavioral context beyond just the tool's function.

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, uses bullet-like list of examples, and 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 the tool's simplicity (3 optional parameters, no output schema), the description fully covers what the tool does, how to use it, and what to expect, making it 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 description coverage is 100%, and the description adds extra meaning by explaining examples, default values, and optional use, surpassing the schema alone.

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's a live index of startup credit programs and provides matched recommendations. It distinguishes itself from sibling tools by focusing on credits and tech stack matching.

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

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

It explains how to use: pass tech stack for recommendations or leave empty for all. It mentions free and no auth, but doesn't explicitly state 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?

With no annotations, the description fully discloses the required off-chain payment step, the exact amount and address, the chain, and that activation grants instant 24h unlimited access across both MCPs. It also provides an alternative payment path. It does not detail any side effects beyond activation, but the core behavior is transparent.

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

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

The description is front-loaded with the main action and cost, then provides numbered steps, result, and alternatives. It is a bit long but every sentence serves a purpose. Minor redundancy (e.g., '24h' repeated) but overall well-structured for an activation instruction.

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 what the tool grants (instant 24h unlimited access to 50+ tools across both MCPs) and includes alternative payment links. It covers the activation flow and post-activation benefit. The only missing piece is detailed response structure, but the description sufficiently sets expectations.

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

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

Schema coverage is 100%, and the description adds substantial meaning: email links the pass to the account, tx_hash must come from the specific transaction. It also tells the user how to obtain the tx_hash (from wallet or basescan.org). This goes well beyond the schema descriptions.

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

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

The description clearly states the tool activates a 24-hour unlimited Zambo Pass for a specific cost and chain. It uses the verb 'activate' and resource 'Zambo Pass', distinguishing it from siblings like zambo_token or zambo_pulse which handle other aspects. The purpose is 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 provides explicit steps for use (send USDC, then call tool with email+tx_hash) and alternative payment methods. It mentions monthly options via a different link, giving context on when this tool is appropriate. However, it does not explicitly contrast with sibling tools for pass management, but the instructions are clear enough for the intended use case.

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 rate limits (3/day free), access requirements (Zambo Pass for unlimited), and that it works on publicly accessible URLs. However, it does not explicitly state the operation is read-only or mention potential 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?

The description is concise and front-loaded with the primary action. It uses two paragraphs efficiently, with examples and constraints. No redundant language.

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 lists all return fields and covers key constraints (public URLs, rate limits). It provides a comprehensive overview for an agent to understand the tool's capabilities.

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 value by explaining the email parameter's purpose and reinforcing that url/text are alternatives. The additional context about free tier and Zambo Pass aids 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 extracts structured intelligence from various document types and lists specific output fields. It distinguishes itself from siblings due to its unique document analysis capability.

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

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

The description provides concrete use cases (e.g., 'summarize this PDF', 'extract key risks') and mentions access tiers, but does not explicitly state when not to use it or suggest 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?

Description mentions speed, professionalism, and tone-matching. With no annotations, the description covers the core behavior. It could benefit from mentioning any input limits or generative AI dependency, but it 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?

Three sentences cover examples, output, and use cases. It is concise but the structure could be slightly improved (e.g., bullet points) for 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?

For a simple generative tool with no output schema, the description adequately explains inputs, outputs, and use cases. No gaps remain for the agent to guess.

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 all parameters have descriptions. The description adds minor context (auto-detection, defaults), but the schema already handles it. Baseline 3 is appropriate.

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

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

Description clearly states the tool writes various email types (cold outreach, negotiation, etc.) and returns subject line and body. No sibling tool appears to conflict; the purpose is specific 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?

Explicit usage triggers are given ('write an email', 'help me email', etc.). However, it does not explicitly state when not to use it or suggest alternatives, which would make it a 5.

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

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

No annotations exist, so the description carries full burden. It states it's a search operation, is free, requires no auth, and returns specific fields. It does not mention pagination or sorting, but the behavior is transparent as a read-only search. The description adequately covers the non-destructive nature and access requirements.

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

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

The description is a single, well-structured paragraph of four sentences. It front-loads the main purpose, then lists return fields and usage hints. Every sentence adds value with no redundant or unnecessary text.

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

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

Without an output schema, the description informs the user of all key return fields. It covers parameters, usage context, a related tool, and constraints (free, no auth, unlimited). For a search tool with 3 parameters, the description is 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% with good descriptions. The tool description adds additional value by providing example queries ('web scraping', 'code review'), context for the 'capability' parameter (exact match filter), and clarifies that 'limit' defaults to 10 and maxes at 50. This enhances understanding beyond the schema.

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

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

The description clearly states the tool searches the Zambo Agent Registry for AI agents by capability, name, or description, and returns specific fields (handle, endpoint URL, wallet address, online status). It distinguishes itself from siblings like capability_search and agent_brief by describing a direct search use case.

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

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

It explicitly says when to use (discover agents for tasks) and mentions a related tool (axis_tool_dispatch) for subsequent payments. It notes that it's free, no auth, unlimited searches. While it doesn't provide explicit when-not-to scenarios, the guidance is clear enough.

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

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

With no annotations, the description carries the full burden. It mentions features (free, unlimited, dietary support) and output structure (3 recipes, steps, shopping list), but lacks disclosure on limitations, failure modes, or the AI-generated nature of recipes.

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 with efficient front-loading of purpose, followed by output details and use cases. Every sentence adds value without unnecessary fluff.

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

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

The description covers the tool's output (recipes, steps, difficulty, shopping list) and dietary flexibility. Lacking only a mention of potential limitations (e.g., insufficient ingredients) but sufficient for intended 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?

Despite 100% schema coverage, the description adds significant value by providing concrete examples, default behaviors, and contextualizing parameters (e.g., vibe options, dietary examples). This goes well beyond the schema's basic 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 uses a specific verb ('Turn...into') and clearly states the tool's purpose: generating dinner plans from a list of ingredients. It distinguishes itself from sibling tools by focusing on recipe generation, which is unique among the provided siblings.

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

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

The description provides clear use cases ('what can I cook tonight?', 'use up leftover chicken') but does not explicitly state when not to use the tool or mention alternative tools for similar tasks.

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 return contents (score, findings, analysis, fixes) and rate limits (1/day free). No annotations, so description carries full burden and does it well, though doesn't specify error handling for incomplete audits.

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, contents, prerequisite, rate limit. Front-loaded and concise with no wasted words.

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

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

With no output schema, description lists report components and format (markdown). Covers key aspects but could mention potential errors more explicitly.

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 audit_id, with clear description. Description adds no extra parameter details beyond schema, meeting 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?

Clearly states verb 'Retrieve', resource 'full markdown report for a completed Ghost Audit', and distinguishes from sibling tools like ghost_audit_site and ghost_audit_status.

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

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

Explicitly advises to call ghost_audit_status first, and mentions free tier limitation, providing 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?

No annotations exist, so the description fully carries the burden. It details the 10 stages, score range (0-100), severity levels, returned artifacts (audit_id, stream_url, download_url), live streaming behavior, and completion time (~90 seconds). 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 thorough but well-structured with bullet-like listing of stages and outputs. It is informative without being overly verbose, though it could be slightly more 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?

Given the single parameter, no output schema, and no annotations, the description provides comprehensive context about the tool's behavior, outputs, and constraints. It is fully adequate for an agent to use correctly.

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

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

Schema coverage is 100% with only one parameter 'url' well-described. The description reiterates the URL format (full URL with https://), adding marginal value beyond the schema. Baseline score of 3 is appropriate.

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

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

The description clearly states it runs a '10-stage ghost audit on any website' and lists the returns: SEO gaps, AI discoverability issues, etc. It distinguishes from sibling tools like ghost_audit_status and ghost_audit_report by being the initiation step.

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?

Describes rate limits (1 free audit per day) and mentions that stream starts immediately with full report in ~90 seconds. It implies this tool starts the audit, and siblings handle status/report retrieval, but does not explicitly state 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 discloses the polling nature, return values (status with elapsed time), and typical timing. It does not mention rate limits or side effects, but given the tool's read-only nature and simplicity, the transparency is adequate.

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

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

Four sentences, front-loaded with purpose, no wasted words. All information is relevant and well-structured.

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

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

For a simple status check tool with no output schema, the description comprehensively covers input, output, usage pattern (polling), and expected timing. No gaps or 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% (one parameter with description). The description reinforces that the audit_id must come from ghost_audit_site, which adds minimal extra value beyond the schema. As per guidelines, with high schema coverage, baseline is 3.

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

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

The description clearly states it checks the status of a Ghost Audit, specifies the required input (audit_id), and describes the return values ('complete' or 'running' with elapsed time). It effectively distinguishes itself from sibling tools like ghost_audit_site (which starts the audit) and ghost_audit_report (which likely retrieves the 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?

The description provides explicit polling guidance ('Poll every 15-30 seconds after starting an audit') and typical completion time. It implies that the tool should be used to monitor progress until 'complete', after which another tool retrieves the report. While it doesn't explicitly state when not to use it, the guidance is clear enough.

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

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

No annotations provided, but description discloses that it returns grouped changes with clean descriptions and accepts raw commit input up to ~3000 chars. It implies a read-only generation process without 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?

Extremely concise: two sentences plus usage hints. First sentence states core purpose, second adds output details. No filler or 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?

Given no output schema, description sufficiently explains return format (grouped changes, features/fixes/breaking changes) and covers all expected use cases. Well-rounded for a generator 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 descriptive parameter names and descriptions in the schema. The tool description adds no additional semantic value beyond confirming the purpose of each 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 tool transforms raw git commits/diff into a polished changelog, specifying output formats (GitHub releases, CHANGELOG.md, product update) and return structure (grouped changes). It distinguishes from siblings by being the only changelog-specific tool among many.

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 trigger phrases ('write a changelog', 'release notes for', 'what changed in this diff') and indicates when to use it. Lacks explicit when-not conditions or alternatives, but sibling tools don't overlap with this functionality.

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 supported image types (photos, screenshots, diagrams, etc.), input format (public URL), and rate limits. It does not detail error handling or privacy implications, but core behavioral traits are 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 somewhat lengthy but well-structured: it starts with the primary purpose, lists capabilities, then use cases, and ends with rate info. Every sentence adds value, though it could be slightly more compact without losing information.

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

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

Given the tool's moderate complexity (multiple modes, public URLs, rate limits) and the absence of an output schema, the description provides sufficient context: it explains input, usage scenarios, and a constraint (public URLs). It could mention return format but is largely 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. The description adds value by providing concrete examples for the 'question' parameter and clarifying the auto-detect behavior for 'mode'. This enhances understanding beyond the schema alone.

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: 'Analyze any image with AI vision' and lists specific capabilities (describe, OCR, code review, subject ID, chart reading). It distinguishes from siblings by focusing on image analysis, whereas siblings like image_generate or pdf_extract serve different functions.

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 tells when to use the tool: 'Use when a user shares an image and asks...' with common queries. It also mentions rate limits (10/day free, unlimited with Zambo Pass). However, it does not explicitly state when not to use or point to alternatives, missing some guidance.

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

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

No annotations provided, so description carries full burden. It discloses output format (URL + markdown embed), destkop rendering, free tier, and authentication-free access. No destructive behavior. Good 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?

Description is front-loaded with key action and output. Multiple sentences but each adds value: free, no key, output format, daily limit. Slightly verbose with exclamation marks 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 and moderate complexity (4 params, 1 required), description covers purpose, output format, limitations, and usage hints. Missing error handling or rate limit beyond daily cap, 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 covers all 4 parameters with descriptions (100% coverage). Description adds a usage hint about being descriptive and provides an example, but this is minor extra beyond 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?

Clearly states the tool generates images with AI and returns a direct URL. Emphasizes that Claude lacks native image generation, positioning this as the solution. Distinguishes from other generation tools like video_create and qr_generate.

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 (for any image generation need) and that it's free with no API key. Mentions daily limit and Zambo Pass for unlimited use. Does not explicitly contrast with alternatives but context with siblings makes it 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 behavior: returns 5 leads, within 60 seconds, daily limit per IP, no authentication needed. This is comprehensive 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?

The description is two sentences, highly concise, and front-loaded with the core value proposition. Every word adds value.

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

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

For a simple tool with 2 parameters and no output schema, the description covers all necessary aspects: input requirements, output description (5 leads with contact info), and constraints (time, daily limit, auth). 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%, and both parameters are described with examples. The description adds little beyond the schema, but it confirms the usage: trade type and city. 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: AI lead generation for contractors and local service businesses. It specifies the action (provide trade type and city, get 5 qualified leads) and distinguishes itself from sibling tools which are unrelated.

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

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

The description explicitly says when to use this tool (for lead generation) and provides context (24 trades, any US city, 3 free searches per day). It does not explicitly state when not to use, but it's implied by the focused use case.

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 effectively discloses behavioral traits: generates 5 qualified leads with contact info, runs in under 60 seconds, supports 24 trades and any US city, and has a limit of 3 free searches per day. This covers speed, output quantity, constraints, and usage limits adequately.

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 with three sentences, no redundant information, and front-loaded with the core purpose (Alias for leadsignal — AI lead generation for contractors). 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?

For a simple tool with 2 parameters and no output schema, the description is complete. It covers the tool's function, inputs, outputs (5 qualified leads), speed, constraints (trades, cities), and usage limits (3 free searches/day), leaving no major gaps in 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 clear descriptions and examples for both required parameters (city, trade). The description adds minimal additional meaning beyond the schema, stating the parameters as 'trade and city' and implying their role in generating leads. 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?

Description explicitly states it is an alias for leadsignal and defines the tool's purpose as AI lead generation for contractors, with a specific verb (generate), resource (leads), and outcome (5 qualified leads with contact info). It clearly distinguishes itself from other siblings as a lead generation 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?

The description provides clear usage context: provide trade and city to get leads. However, it does not specify when to use this tool versus alternatives, such as the leadsignal tool itself (which is identical due to being an alias) or other tools. No exclusions or alternative suggestions are given.

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?

Description discloses 30-minute cache behavior for 'snapshot' depth and fresh data for 'deep' depth, plus a daily rate limit of 10 free calls. The tool is clearly read-only and non-destructive. No other behavioral traits are missing given the read-only nature.

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 dense paragraph but efficiently packs purpose, sources, return fields, cache, and rate limit. It is front-loaded with the main purpose. Minor improvement could be breaking into lists.

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 three optional parameters, no output schema, and no annotations, the description explains return fields, caching, rate limits, and data sources. It lacks error behavior or limit exceeded handling but is largely complete for a snapshot 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%, but description adds value by clarifying that 'snapshot' uses cache, 'deep' is always fresh, giving examples for 'focus', and explaining default 'all' for domains. This goes beyond the schema descriptions.

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

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

Description clearly states it provides a 'Real-time market intelligence snapshot across AI, agents, and research' and lists specific aggregated sources and return fields. It is specific and distinguishes itself from sibling tools like 'credithunt' or 'substrate_breakthroughs' by its aggregated nature.

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

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

Usage guidelines are implied through mention of sources (Substrate, CreditHunt, etc.) and caching/rate limits, but there is no explicit statement of when to use this tool vs. alternatives like 'credithunt' or 'substrate_breakthroughs'. 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?

No annotations are provided, so the description carries full burden. It discloses the one-time per email constraint, the requirement for an email, and the returns (success status and upgrade links). Some detail on response structure is missing, but adequate.

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

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

The description is concise with three sentences, each adding value. The first sentence front-loads the primary action, and no filler is present.

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

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

Given the simple parameter set (1) and lack of output schema, the description covers purpose, trigger, constraints, and outcome completely. No significant gaps.

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

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

The sole parameter 'email' has a description in the schema, and the tool description adds context about the upgrade pitch email. With 100% schema coverage, baseline is 3; the extra context raises it to 4.

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

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

The description clearly states the tool grants 10 additional free daily calls when the free tier limit is reached. It is specific with verb 'grant' and resource 'additional free daily calls', distinguishing it from sibling tools.

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

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

The description specifies when to use (user hit free tier limit), requires an email, and notes one extension per email ever. It does not explicitly mention alternatives but implies paid options after extension.

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 mentions 'Free, always' implying no cost or destructive side effects, but does not explicitly state read-only behavior, output format, or any authentication requirements. This is adequate but leaves gaps for an AI agent.

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 covering purpose, usage, and a key attribute (free). Efficient and front-loaded with the most important information. Minor verbosity in the first sentence could be trimmed, but overall good.

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 two optional parameters and no output schema. The description explains its function and when to use it, but does not detail what the returned config blocks look like or how different 'target' values affect output. For a straightforward guide tool, this is moderately 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 description coverage is 100%, so the schema already documents both parameters. The description adds context by mentioning 'config blocks' but does not elaborate on how parameters affect the output. This meets the baseline expectation of not needing to repeat schema content but provides minimal added 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's purpose: 'Get the zambo.dev install guide and ready-to-paste config blocks' for specified platforms. It uses specific verbs and resources, and implicitly distinguishes itself from sibling tools by focusing on installation/configuration rather than other actions.

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

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

The description explicitly tells the agent when to call the tool: 'Call when a user asks what MCP tools to use, or needs an install config for Claude/Cursor/Windsurf.' It lacks explicit guidance on when not to use or mention of alternatives, but the context is clear and sufficient 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?

Describes output (structured daily meals with prep times) but no annotations exist. Could add more on side effects (e.g., no data saved), but sufficient for a generation tool.

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

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

Two sentences, front-loaded with purpose and output, then usage triggers and inputs. Every word earns its place.

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

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

No output schema, but description mentions return content (recipes, macros, shopping list, prep times). Covers inputs and outputs adequately. Minor gap: no mention of error handling or rate limits.

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 6 parameters documented in schema with descriptions. Main description adds value by summarizing key parameters (dietary, budget, cuisine, days) and giving context beyond schema.

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

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

Clearly states it generates personalized meal plans with recipes, macros, and shopping list. No ambiguity and distinct from sibling tools.

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

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

Provides example user phrases like 'meal plan' and 'what should I eat', indicating when to use. Does not mention when not to use, but siblings lack meal-plan tools so alternatives are implicit.

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

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

The description discloses that the tool generates an image with text overlay and returns a direct image URL. No annotations are provided, so the description takes on full burden. It does not cover potential behavioral aspects like content moderation, size limits, or idempotency, but it adequately describes the 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?

The description is concise with two sentences, front-loading the action and result. Every sentence adds value: first explains what it does, second gives usage examples. No unnecessary words.

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

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

The description covers the main purpose, inputs, and output (URL). With no output schema, it explains the return format. It is complete for a simple generation tool, but lacks details on error handling or content policies, which slightly reduces completeness.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds context by explaining how to use the parameters (e.g., 'Describe the visual scene' for concept, 'top/bottom text' for the text fields), but does not provide significant additional semantic detail beyond what the schema already offers.

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 meme image with scene and overlaid caption text, returning a shareable URL. It uses specific verbs like 'Generate' and describes the resource (meme image), distinguishing it from generic image generation 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 explicitly lists user intents that trigger this tool (e.g., 'make a meme', 'generate a meme about X', 'funny captioned image'), making it easy for the agent to decide when to use it. However, it does not mention when not to use or alternative tools like image_generate.

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 fully bears the transparency burden. It discloses the tool produces a ranked recommendation, tracks 10 models with June 2026 pricing, and has a daily usage limit. It does not mention any destructive or side effects, which is appropriate for a recommendation 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 concise: a single sentence defining the main action, followed by a brief list of providers and an example-driven best-for section. Every sentence adds value; no extraneous 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 5 parameters, no output schema, and no annotations, the description covers the main behavioral aspects: output is a ranked recommendation, usage constraints (free tier), and supported models. It could mention if the output includes pricing or token estimates, but overall it is sufficiently complete for an agent to understand tool 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 the baseline is 3. The description adds value by explaining the budget enum values ('low' = under $0.50/1M tokens, etc.) and clarifying the use_case parameter provides a personalized recommendation. This goes beyond the schema descriptions.

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

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

The description clearly states the tool's purpose: 'Get a ranked recommendation of AI models for your specific task, token budget, and cost constraints.' It lists supported providers and example use cases, making it easy to understand. No sibling tool appears similar, so differentiation is inherent.

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 'Best for' examples and notes the free tier limit (30 free/day). It doesn't explicitly say when not to use, but the context is clear since sibling tools do not overlap in function. The usage guidance is adequate but could be more explicit about 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?

No annotations are provided, so the description fully bears the burden of behavioral disclosure. It states the data is cached for 60 seconds, is free and requires no authentication, and explains the source (NadCity). It also mentions auto-provisioning of API keys for Zambo MCP users, adding transparency about rate limits.

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

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

The description is concise with 4-5 sentences covering output, tiers, caching, auth, and use cases. It is front-loaded with the main output. The API key provisioning detail, while useful, adds a slight extra step; overall it is well-structured and not verbose.

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 comprehensively explains all return values: contracts (category, tier, tx count, hourly activity), whales (MON balance, NadHawk score), district breakdown, and tier/score interpretations. It also covers caching and auth, making it fully self-contained for agent 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?

The input schema has zero parameters, so there is nothing to explain. The description compensates by explaining the output structure in detail, which adds value beyond the schema. Baseline is 4 for no parameters.

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

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

The description clearly states the tool returns 'Top contracts and whale wallets on Monad mainnet', specifying exact counts (10 contracts, 8 wallets) with detailed attributes. It distinguishes itself from siblings like 'monad_pulse' by focusing on contract due diligence and whale tracking.

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 explicit use cases: 'contract due diligence, whale tracking, or mapping what's actually active on Monad before deploying or integrating.' It does not provide when-not-to-use or compare to alternatives, but the use cases are 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?

Discloses caching (30s), authentication (free, no auth), and output fields. No annotations exist, so description carries full burden. Missing error handling or rate limits for MCP, but overall 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?

Front-loaded with purpose and returns, then usage and API key note. All sentences add value, though the API key detail is somewhat tangential. Efficient overall.

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

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

With no parameters, no output schema, and no annotations, the description provides complete context: purpose, return fields, caching, auth, and usage guidance. No gaps identified 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?

Input schema has zero parameters (100% coverage). Type 'object' with no properties means no param info needed. Description adds value by listing return fields, fulfilling the baseline expectation.

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 provides live Monad mainnet network stats via NadCity, specifying exact return fields (TPS, block number, etc.). This is specific and distinguishable from siblings like market_pulse or monad_city.

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 using before any on-chain Monad action to check network health, with concrete thresholds for stress (avgBlockTimeMs > 500 or wsConnected false). No explicit when-not-to-use or alternatives, but clear context given.

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

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

No annotations exist, so the description carries full burden. It discloses that no Zambo Pass is needed, which is a positive behavioral hint. However, it does not mention idempotency, side effects (e.g., whether registration overwrites existing data), persistence guarantees, or authentication requirements. For a mutation operation, more transparency is expected.

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 purpose, no filler. Every sentence earns its place: first sentence states action, second specifies key inputs and a condition.

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 registration tool with no output schema, the description covers core purpose and inputs. It does not explain return values, confirmation steps, or error scenarios, but these are less critical given the tool's straightforward nature. Adequate but with room for improvement.

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 context: 'wallet address for payouts' reinforces the schema description. However, there is a minor inconsistency: description says 'partner_id' but schema uses 'agent_id', which could confuse. Overall, the description provides marginal added value over 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 action: 'Register as a Zambo partner.' It includes the required inputs (agent_id and wallet address) and a key condition (no Zambo Pass required). The verb 'register' and resource 'Zambo partner' are specific, and the tool name itself distinguishes it from sibling tools like 'agent_brief' or 'partner_stats'.

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 when to use (when wanting to become a Zambo partner) and states a prerequisite ('No Zambo Pass required'), but it does not explicitly differentiate from alternatives or provide exclusion scenarios. Given the tool's simplicity, the lack of explicit when-not-to-use guidance is acceptable but not exemplary.

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 fully disclose behavior. It only states it 'checks' stats, which is a read operation, but does not mention safety, authentication needs, rate limits, or error responses. This is insufficient for an agent to understand operational 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?

The description is a single, front-loaded sentence that clearly communicates the tool's purpose with no unnecessary words or repetition.

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

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

Given the simple tool with two parameters and no output schema, the description covers the basic purpose but lacks details on expected return values, error handling, or behavior when both parameters are provided or omitted. Adequate but not thorough.

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 'Provide partner_id' but fails to clarify the relationship between partner_id and the actual parameters agent_id/ref_code, nor any additional meaning beyond the schema.

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

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

The description clearly states the tool checks partner stats including total conversions and pending payout balance. It specifies to provide partner_id, which distinguishes it from sibling tools like partner_register. However, there is a minor mismatch: the parameters are agent_id and ref_code, not partner_id.

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

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

The description instructs to provide partner_id, implying when to use, but offers no explicit guidance on when not to use or alternatives among siblings. Usage is implied but not elaborated.

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 works on public URLs and returns extracted text, word count, and summary. However, it does not reveal limitations (e.g., max_chars cap, which is only in schema), behavior on non-public URLs, rate limits, or error handling, leaving some behavioral traits implicit.

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 highly concise: four short sentences that immediately convey purpose, return values, and usage context. Every sentence adds value without redundancy, and key information is front-loaded ('Fetch and extract text content from any public URL').

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-parameter schema with 100% coverage and no output schema, the description is fairly complete. It explains what the tool returns (text, word count, summary) and provides common use cases. Minor gaps include no mention of error handling or authentication requirements, but these 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%, so the baseline is 3. The description adds minimal additional meaning beyond the schema; it mentions 'summarize this document' implying the summarize parameter but does not elaborate on format or constraints. No extra semantic depth is provided.

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

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

The description uses specific verbs ('fetch', 'extract', 'summarize') and clearly identifies the resource ('any public URL', 'PDF documents, web pages, articles, docs'). It also lists concrete use cases ('read this PDF', 'extract from this URL') and return values ('extracted text, word count, and a summary'), making the tool's purpose unambiguous and distinct from sibling tools.

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

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

The description explicitly states when to use the tool by mapping to user intents ('Use when user says...'). However, it does not mention when NOT to use the tool or provide alternatives for similar tools like 'doc_intel', though the guidance is clear enough for correct invocation.

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

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

With no annotations, the description carries full burden. It discloses that the tool returns each model's response with a consistency score and recommendation, and defaults to testing all 4 main models. It does not mention side effects, rate limits, or auth, but given the testing nature, these are likely non-issues. The 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?

The description is exactly two sentences, front-loading the main purpose and then providing usage guidance. Every sentence adds value with no 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 tool's moderate complexity (4 parameters, no output schema, no annotations), the description adequately covers what the tool does, what it returns (side-by-side outputs with scores), and default behavior. It leaves no critical gaps for an agent to understand invocation and expected results.

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

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

Schema description coverage is 100%, so the schema already documents all 4 parameters. The description adds context about default behavior (testing all 4 main models) and the overall outcome, but does not provide additional meaning beyond the schema's parameter descriptions.

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

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

The description clearly states the tool's function: 'Test and compare a prompt across multiple AI models — get outputs side-by-side with quality scores.' It also lists specific user intents like 'test this prompt', 'which model is best for', 'compare how models respond to', and 'prompt engineering', making it highly distinguishable from sibling tools.

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

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

The description provides explicit usage guidance by listing trigger phrases (e.g., 'test this prompt', 'which model is best for') that signal when to use this tool. However, it does not explicitly state when NOT to use it or mention alternatives, which prevents a top score.

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

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

No annotations exist, so the description fully carries this dimension. It details two-phase analysis (pattern scan + Groq semantic), outputs (injection_risk, recommendation, rewritten version), and free tier limits (50/day).

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. First sentence defines purpose, second details phases, outputs, and usage. 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?

Despite lacking an output schema, the description covers purpose, processing phases, output fields, rate limits, and use cases. Sufficient for AI agent selection and 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%, so baseline is 3. The description adds context about the two phases but does not elaborate on each parameter 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?

The description clearly states the tool detects prompt injection, jailbreaks, and policy bypass attempts, with specific verb-object pairs. It distinguishes from siblings by focusing on input validation for LLMs.

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 'Best for' section provides explicit use cases (validate user input, detect jailbreaks, check prompt safety), offering clear context. However, it does not state when not to use or mention 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, so description carries full burden. Discloses return values (cert_id, verify_url, SHA-256 hash), permanence, tamper-proof nature, rate limits (free 5/day, unlimited with pass), and where to verify. Comprehensive behavioral 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?

Front-loaded with core purpose, followed by use cases and agent instructions. At ~100 words it is concise, though the 'Perfect for:' list could be slightly trimmed. Overall well-structured and efficient.

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

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

No output schema, but description covers return values (cert_id, verify_url, hash). Input is simple (3 params), and use cases, rate limits, and agent guidance are covered. Sufficient for an agent to use correctly.

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

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

Schema coverage is 100% so baseline 3. The description adds no new parameter semantics beyond the schema's own descriptions. It mentions 'Optional Zambo Pass email' and 'Human-readable label', but these do not significantly enhance understanding beyond the schema.

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

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

Clearly states the tool cryptographically certifies AI content with a SHA-256 provenance certificate. The verb 'certify' and resource 'AI-generated content' are specific and distinguish it from sibling tools like 'zambot_verify' which likely verifies.

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 lists perfect use cases (certifying outputs, audit trails, proving timestamp/authorship) and agent-specific guidance ('call after any important tool result'). Lacks explicit when-not or alternatives, but the context is clear enough.

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

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

With no annotations, the description bears full responsibility for behavioral disclosure. It explains the two-tier access (teaser vs full), required input, and output types. It does not mention rate limits or data handling, but overall is transparent for a read-only audit 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 front-loaded with the core purpose and outputs, then provides pricing and usage details. It is slightly verbose but each sentence serves a purpose, making it 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 3 parameters, 100% schema coverage, and no output schema, the description adequately explains the tool's functionality and the two-tier system. It covers what the tool returns and how to get full results, though it could mention repo size limitations.

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 significant value by explaining the impact of omitting email (free teaser) and providing context for the optional vibe_context parameter, going 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 it performs an AI code audit on public GitHub repositories, listing specific outputs like Provibe Score, security vulnerabilities, dead code map, and execution plan. This distinguishes it from sibling tools, which have different purposes like fixing or analyzing.

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 the free teaser (without email) versus the full audit (with Zambo Pass email), and mentions pricing. However, it does not explicitly state when not to use the tool or suggest 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 that the output is a direct image URL and that the service is free and without authentication. However, it does not mention potential failure modes (e.g., data too long), rate limits despite claiming 'no limits', or any error handling behavior, which would be helpful for a complete 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 exceptionally concise: two sentences front-load the core purpose and output format, followed by practical examples. 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 the tool's simplicity (two parameters, no nested objects, no output schema), the description is sufficiently complete. It explains what it does, what it returns, and provides examples. It could mention that the QR code is generated as a PNG image or specify the response format, but the absence is minor.

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 provides good descriptions for both parameters (data and size), achieving 100% coverage and baseline score of 3. The description adds examples but does not significantly enhance semantic understanding beyond the schema's documentation.

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 'generate', the resource 'QR code', and the wide range of input types (URL, text, phone, etc.). It differentiates from sibling tools like 'image_generate' by focusing specifically on QR code generation, making its purpose unmistakable.

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

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

The description provides clear usage context with examples (business website, WiFi password) and claims 'free, no auth, no limits'. However, it does not explicitly state when to avoid using this tool or mention alternative tools for different use cases, leaving room for minor ambiguity.

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 burden. It lists outputs (pattern, explanation, code snippet) but does not discuss limitations, side effects, or assumptions. 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?

Three sentences, front-loaded with core function, no wasted words. Each sentence serves a clear 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?

Despite lacking output schema, description explains return values. Covers usage triggers and what to expect. Minor gap: no mention of error handling or regex complexity limits.

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 is justified. Description adds output context but no new parameter semantics beyond schema. No contradiction.

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

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

The description explicitly states the tool generates a regex with explanation and code snippet, and lists specific user intents like 'regex for', 'pattern to match'. It clearly distinguishes from sibling tools (none are regex-focused).

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 usage cues such as 'Use when user says regex for...' and mentions avoiding Stack Overflow. Lacks explicit when-not-to-use or alternative tools, but cues are sufficient.

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

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

No annotations are provided, so the description carries the full burden. It transparently states that the tool returns a rewritten resume with ATS score, keyword gaps filled, and bullet points improved. It also mentions input constraints (max chars) via parameter descriptions, giving a complete behavioral picture.

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

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

The description is three sentences with no fluff. It front-loads the core action and output, then provides usage examples. 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 exists, so the description explains what is returned (rewritten resume with ATS score, keyword gaps, improved bullet points). It covers input constraints and usage triggers. For a generation tool with well-documented parameters, this is 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 description coverage is 100% and each parameter already has a clear description (e.g., style with default and options, resume_text with max chars). The tool description does not add significant new meaning beyond what is in the schema. Baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'Tailor' and clearly identifies the resource (resume to a job description). It lists concrete actions: boost ATS keyword match, strengthen bullet points, highlight right experience. The description explicitly states what is returned, distinguishing it from sibling tools.

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

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

The description provides explicit usage triggers: 'Use when user says improve my resume, tailor resume to this job, will this resume pass ATS, help me apply for.' This gives clear guidance on when to invoke this tool versus others, leaving no ambiguity.

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. The description discloses that it returns a step-by-step playbook with exact words, which is sufficient for a content generation tool. It does not reveal any limitations, prerequisites, or side effects, but the behavior is straightforward.

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 long, front-loading the purpose and then listing use cases. Every word is meaningful; no redundancy or filler.

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

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

Given the tool has 7 parameters (all described) and no output schema, the description adequately explains what the tool produces (a negotiation script). It covers the main use cases and output format, making it complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so the description adds no additional parameter semantics beyond what is already in the schema. Each parameter has a clear description in the schema, making the description supplementary but not essential.

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 complete salary negotiation script with specific components (opening move, rebuttals, BATNA, closing). It distinguishes itself from sibling tools by its unique domain of salary negotiation, which no other sibling addresses.

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 trigger phrases ('salary negotiation', 'how do I ask for a raise', etc.) indicating when to use the tool. It does not mention when not to use it or alternatives, but given the sibling list, this is not a significant gap.

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 it's a lookup (read-only) and free with no auth, but lacks details on rate limits, caching, data freshness, 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?

The description is concise at four sentences, front-loading the primary purpose. Each sentence adds value, though minor redundancy exists (e.g., 'verify identity and trust' could be condensed).

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 adequately explains return values and purpose. It misses error cases or availability, but is largely 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 a clear parameter description. The description adds examples (e.g., 'brennan-zambo') and clarifies the slug format, but mostly reiterates the schema. 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 looks up a 'verified professional trust passport' on Signal, uses specific verbs and resource, and distinguishes from siblings like signal_register by focusing on lookup. It returns specific data types: credentials, skills, roles, verification status, and reputation.

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 to use the tool 'to verify identity and trust before collaboration,' providing clear usage context. It does not mention when not to use or alternatives, but the purpose is well-defined.

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 registration is one-time, free, requires no auth, and returns specific items. It also explains the behavioral impact on rate limits.

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

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

The description is a single paragraph of 5-6 sentences, front-loaded with the main action, and contains 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 self-contained registration tool with 6 parameters and no output schema, the description provides return values, side effects, and usage guidance, making it fully adequate.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds some context (e.g., handle appears in URL) 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?

The description clearly states the tool registers an AI agent on Signal (Zambo agent identity registry) and specifies the action, resource, return items, and benefit. It distinguishes from sibling tools by positioning it as a first-time setup 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?

The description explicitly says to use it 'the first time you connect to Zambo MCP' and explains the rate limit benefit. While it doesn't provide explicit alternatives or exclusions, the context 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?

With no annotations, the description carries full burden. It states the tool produces working SQL with explanations and optimization notes, and handles complex queries. It does not disclose side effects or security considerations, but the tool is non-destructive text generation, so reasonable transparency.

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

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

The description is compact (three sentences), front-loaded with the core purpose, and every sentence adds value. No fluff or repetition of schema definitions.

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 (text-to-SQL) and no output schema, the description sufficiently covers inputs, capabilities, and outputs. It provides enough context for the agent to use it correctly without missing critical details.

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

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

Schema coverage is 100% (all parameters described in schema), so baseline is 3. The description adds value by explaining the purpose of parameters (e.g., 'Helps accuracy enormously' for schema, 'production-ready SQL' for output), and implies usage context for the request parameter.

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

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

The description clearly states it converts plain-English to SQL queries, lists supported SQL constructs (JOINs, aggregations, etc.), and differentiates from sibling tools which are unrelated to SQL 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?

Explicitly provides trigger phrases like 'write a query to' and 'SQL for', guiding the agent on when to invoke this tool. Also implies when not to use (other tool requests), though not explicitly stated.

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