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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context about multi-turn conversations and agent capabilities but lacks details on permissions, rate limits, or response formats. It does not contradict annotations, but for a chat tool with no annotations, more behavioral traits could be described.

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

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

The description is appropriately sized and front-loaded with the core purpose, followed by structured sections (Agent Types, Multi-turn Conversations, Examples). Most sentences earn their place, though some details (like the 'attached_content' parameter) are not explicitly covered in the description, slightly reducing efficiency.

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 (multi-turn chat with multiple agent types) and no output schema, the description is moderately complete. It covers usage scenarios and parameters but lacks information on response behavior, error handling, or integration with sibling tools. With no annotations and no output schema, it should do more to be fully comprehensive.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema by briefly mentioning parameters in examples (e.g., 'message', 'conversation_uuid', 'agent_type') but does not provide additional syntax or format details. 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 tool's purpose as 'Chat with a DROYD AI agent' and specifies it 'Supports multi-turn conversations,' which distinguishes it from sibling tools focused on filtering, getting positions, managing trades, or searching. It provides a specific verb ('Chat') and resource ('DROYD AI agent') with explicit scope.

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 offers clear context for when to use this tool by detailing agent types (e.g., 'research' for crypto analysis, 'trading' for signals) and multi-turn conversation handling. However, it does not explicitly state when not to use it or name alternatives among sibling tools, such as when to use droyd_search_content instead for specific queries.

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 and does well by explaining key behavioral aspects: it clarifies that market cap values are in millions, lists available chains and sort options, and provides concrete examples. However, it doesn't mention rate limits, authentication requirements, or what happens when no results match.

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 perfectly structured with clear sections (Filter Modes, Sort Options, Chains, Note, Examples), uses bold formatting effectively, and every sentence earns its place by providing essential information without redundancy.

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

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

For a complex tool with 21 parameters and no output schema, the description does an excellent job providing context through examples, unit explanations, and available options. The only gap is the lack of information about return format or what happens when filters yield no 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 parameters thoroughly. The description adds some value by explaining the million-unit convention for market cap and providing examples that illustrate parameter combinations, but doesn't add significant semantic meaning beyond what's in the schema.

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

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

The description clearly states the tool's purpose with specific verbs ('Filter and screen') and resources ('crypto projects using market criteria'), distinguishing it from siblings like droyd_search_projects by emphasizing market-based filtering rather than general search.

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 guidance on when to use each filter mode (natural_language vs. direct), includes detailed examples for different scenarios, and lists available sort options and chains, giving comprehensive usage context without needing to reference 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 effectively discloses behavioral traits: it's a read operation (implied by 'retrieve'), returns comprehensive data including strategies, swaps, P&L, and wallet info, and explains the impact of the leg_status parameter on response content. It doesn't mention rate limits or authentication needs, but covers core behavior well.

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

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

The description is well-structured and front-loaded: the first sentence states the purpose, followed by a bulleted list of returns, then usage notes and examples. Every sentence earns its place by adding clarity or practical guidance, 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?

Given the tool's complexity (retrieving multi-faceted trading data) and no output schema, the description does a good job listing return components. However, it could be more complete by specifying data formats or any limitations, but it covers key aspects adequately for the agent to understand what to expect.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the semantics of leg_status beyond the schema: it clarifies that 'all' includes executed/completed legs and provides examples showing how to use it, enhancing understanding without redundancy.

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

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

The description clearly states the verb 'retrieve' and specifies the resources: 'active trading positions and wallet holdings'. It distinguishes from siblings like droyd_get_watchlist (likely for monitoring) and droyd_manage_trade/droyd_open_trade (for trade operations) by focusing on retrieval of current positions and holdings.

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: to get active positions and holdings, with guidance on the leg_status parameter to include history. However, it doesn't explicitly state when not to use it or name alternatives among siblings, such as whether droyd_get_watchlist serves a different purpose.

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 it returns projects with agent evaluations including investment scores and thesis points, which adds behavioral context beyond the input schema. However, it doesn't mention authentication requirements, rate limits, pagination behavior, or error conditions, leaving gaps for a tool with no annotation coverage.

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

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

The description is well-structured with clear sections (purpose, scopes, returns, examples) and uses bullet points effectively. Every sentence adds value, though the examples section is somewhat lengthy but necessary for clarity. It could be slightly more concise in the examples while maintaining usefulness.

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 3 parameters with 100% schema coverage but no annotations and no output schema, the description does a decent job explaining scope and providing examples. However, for a tool that returns complex data (projects with evaluations), more detail on output structure or behavioral aspects would improve completeness, especially without annotations to cover safety or operational traits.

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 value by explaining the meaning of scope options (personal agent, community swarm, both) and providing concrete examples of parameter usage, which enhances understanding beyond the schema's enum and descriptions. This justifies a score above baseline.

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

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

The description clearly states the verb 'Get' and resource 'watchlist projects for the authenticated user', making the purpose specific. It distinguishes this tool from siblings like droyd_get_positions (positions vs watchlist) and droyd_search_projects (search vs get watchlist), establishing clear differentiation.

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

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

The description provides clear context about scope options (agent, swarm, combined) with examples, indicating when to use different parameter combinations. However, it doesn't explicitly mention when NOT to use this tool or compare it to alternatives like droyd_filter_projects or droyd_search_projects for similar 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does well by explaining the different actions (close, buy, sell, update) and their effects. However, it doesn't mention important behavioral aspects like whether these actions are reversible, what permissions are required, rate limits, or what happens to partially executed orders. The examples help but don't cover all behavioral implications.

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

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

The description is well-structured with clear sections (Actions, Examples) and uses bullet points effectively. The opening sentence clearly states the purpose. While comprehensive, some sentences could be more concise, and the examples section is quite lengthy but necessary for this complex tool.

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

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

For a complex trading tool with 7 parameters, no annotations, and no output schema, the description does a decent job but has gaps. It explains the actions well with examples, but doesn't cover error conditions, return values, or system limitations. Given the complexity and financial nature of the operations, more context about what happens after execution would be helpful.

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 significant value beyond the schema by explaining the semantic meaning of each action type with clear examples. It clarifies what 'close', 'buy', 'sell', and 'update' mean in practice, and provides concrete examples of how to use the legs parameter for different leg actions. This goes well beyond what the schema provides.

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

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

The description clearly states the tool's purpose with specific verbs and resources: 'Manage existing trading positions. Close positions, execute additional buys/sells, or modify strategy legs.' It distinguishes this tool from siblings like droyd_open_trade (which opens new trades) and droyd_get_positions (which retrieves positions without modifying them). The description provides a comprehensive overview of all possible 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 provides clear context for when to use this tool: for managing existing trading positions. It implicitly distinguishes from droyd_open_trade (for opening new trades) and droyd_get_positions (for retrieving position information). However, it doesn't explicitly state when NOT to use this tool or provide specific alternatives for edge cases.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively explains key traits: it's a creation tool (opening a position), details trigger interpretations for each leg type (e.g., market_buy is immediate, stop_loss sells at a drop), and includes practical constraints like minimum amountUSD in examples. However, it lacks information on permissions, rate limits, or error handling.

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

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

The description is well-structured and front-loaded with the core purpose, followed by detailed leg type explanations and practical examples. Every sentence earns its place by providing essential context or clarification, with no redundant or verbose 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 the complexity (trading with multiple leg types), no annotations, and no output schema, the description does a strong job by detailing leg behaviors and providing examples. However, it could improve by mentioning potential outputs or error cases, leaving some gaps for a tool of this complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds significant value by explaining the semantics of leg types and triggerPercent with concrete examples (e.g., '0.05 = buy at 5% below current'), clarifying how parameters interact in real-world scenarios 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 clearly states the tool's purpose as 'Open a new trading position with flexible leg configurations,' which is a specific verb ('open') + resource ('trading position') + distinguishing feature ('flexible leg configurations'). It differentiates from sibling tools like droyd_get_positions (which retrieves) and droyd_manage_trade (which modifies existing trades).

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 through examples showing when to use different leg types (e.g., 'Simple buy' vs. 'With stop loss'), but it does not explicitly state when to use this tool versus alternatives like droyd_manage_trade or provide exclusions. The guidance is contextual but not comprehensive.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does well by explaining the two distinct search modes and their characteristics, listing available content types, categories, and ecosystems, and providing example parameter structures. However, it doesn't mention rate limits, authentication requirements, or error conditions that would be helpful 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?

The description is perfectly structured with clear sections (Search Modes, Content Types, Categories, Ecosystems, Examples) and bullet points. Every sentence earns its place by providing essential information about how to use the tool effectively. The examples are particularly valuable for showing parameter combinations.

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 search tool with 10 parameters, 100% schema coverage, and no output schema, the description does an excellent job explaining the tool's functionality. It covers the two search modes thoroughly, lists available filters, and provides practical examples. The main gap is the lack of information about what the output looks like (no output schema), but the description compensates well for this through clear usage guidance.

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

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

With 100% schema description coverage, the baseline is 3. The description adds significant value by explaining the meaning and purpose of search_mode options (recent vs semantic), listing all possible content_types, categories, and ecosystems, and showing through examples how parameters interact. It provides context that helps understand when to use which parameters beyond what the schema provides.

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

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

The description clearly states the tool searches the DROYD knowledge base for crypto content, specifying both the action (search) and resource (crypto content in DROYD knowledge base). It distinguishes itself from sibling tools like droyd_search_projects by focusing on content rather than projects, and from droyd_chat by being a search tool rather than conversational.

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 guidance on when to use each search mode: 'recent' for browsing latest content by type/category/ecosystem, and 'semantic' for AI-powered natural language queries. It includes three concrete examples showing different use cases, making it clear when to choose each mode and how to structure requests.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It describes what the tool does (searching) and different search types, but doesn't mention rate limits, authentication requirements, error conditions, or what happens when no results are found. The description doesn't contradict any annotations since none exist.

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

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

The description is well-structured with clear sections (Search Types, Attributes, Examples) and uses bullet points effectively. It's appropriately sized for the tool's complexity, though the examples section is somewhat lengthy. Most sentences earn their place by providing useful 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 search tool with 7 parameters, 100% schema coverage, and no output schema, the description provides adequate context about what the tool does and how to use it. However, it doesn't describe the return format, result structure, or what happens when searches fail. Given the complexity and lack of output schema, more information about expected results would be helpful.

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

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

With 100% schema description coverage, the schema already documents all 7 parameters thoroughly. The description adds some value by explaining the different search types in more detail and listing available attributes, but doesn't provide additional parameter semantics beyond what's in the schema descriptions. The examples help illustrate parameter usage patterns.

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 as searching for crypto projects using multiple search methods (name, symbol, address, semantic query, project_id). It distinguishes itself from sibling tools like droyd_filter_projects and droyd_search_content by specifying it searches for 'projects' rather than filtering existing ones or searching content.

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 about when to use different search types (e.g., 'project_id - Direct ID lookup (fastest)', 'semantic - AI-powered concept search'), but doesn't explicitly state when NOT to use this tool or mention alternatives like droyd_filter_projects. The examples help illustrate appropriate usage scenarios.

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