Gitlab Public

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 'picks the right tool, fills the arguments, and returns the result,' indicating autonomous selection and invocation. It also states that no browsing or schema learning is needed, setting expectations about the tool's 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 four sentences that are front-loaded. The first sentence states the core purpose, followed by behavioral details and examples. No extraneous information; every sentence adds value.

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

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

Given the tool's simplicity (one required parameter, no output schema, no annotations), the description is complete enough. It explains what the tool does, how it works, and gives examples. There is no missing critical information for an agent to use this tool effectively.

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

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

Schema coverage is 100% with a single parameter 'question' described as 'Your question or request in natural language.' The description adds context by noting the parameter should be plain English and provides examples, but the schema already covers the parameter adequately, so baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Ask a question in plain English and get an answer from the best available data source.' It specifies the action (ask), resource (best available data source), and differentiates from sibling tools that are more specific (e.g., search_issues, search_projects).

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

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

The description implicitly tells when to use this tool: when you have a question and want the system to pick the right tool. It does not explicitly say when not to use it or list alternatives, but it provides examples that illustrate typical use cases, making usage 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?

The description details internal behavior: market resolution, bet classification, fan-out logic (e.g., crypto+fred+gdelt for BTC), and output (evidence packet + market-vs-model comparison). Annotations (readOnlyHint, openWorldHint) are consistent and augmented by this rich context.

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

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

The description is well-structured and front-loaded with purpose, but somewhat lengthy with phrases like 'core demo product' that are not essential. Could be slightly more concise without losing meaning.

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

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

Despite no output schema, the description thoroughly explains what is returned (evidence packet and comparison), how processing works (fan-out by category), and input handling. It covers all necessary aspects for an agent to use the tool correctly.

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

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

Schema coverage is 100% with descriptions. The description adds value by explaining depth defaults and market input formats (slug, URL, question text) with examples. This clarifies usage beyond what 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 researches Polymarket bets by pulling Pipeworx data, specifying input types (slug, URL, question text) and actions (resolve, classify, fan out, return comparison). It is distinct from siblings like validate_claim or ask_pipeworx, which focus on other tasks.

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

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

Explicit use cases are provided ('should I bet on X?', 'what does the data say...', 'is there edge...'), indicating when to use. While it doesn't explicitly exclude alternatives, the uniqueness of Polymarket betting context makes it clear. Lacks direct comparison to siblings like validate_claim.

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 return type (paired data + URIs) and data sources (SEC EDGAR for companies, FDA for drugs), but does not mention any side effects, authentication requirements, or 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 three sentences long, front-loads the core purpose, and includes all necessary information with no redundant text.

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

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

Given no output schema, the description explains return values (paired data + resource URIs) and context (replacing sequential calls). It could be more detailed about the structure of the returned data, but is sufficient for an agent.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds meaning by explaining what metrics are returned for each type, and provides concrete examples for the values 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 states exactly what the tool does: compares 2-5 entities side by side. It specifies two entity types (company and drug) with distinct metrics, and distinguishes itself from sibling tools by offering batch comparison.

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

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

The description mentions it replaces 8-15 sequential agent calls, indicating it's for efficient multi-entity comparison. However, it does not explicitly state when not to use it or provide alternatives, but the context is clear.

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

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

With no annotations provided, the description carries full burden. It explains the tool searches and returns relevant tools with names and descriptions, but does not detail behaviors like whether the search is fuzzy, case-sensitive, or how results are ranked. It also doesn't mention any side effects or limitations (e.g., if the tool is read-only).

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

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

Three sentences, each serving a purpose: explaining the tool, stating output, and giving usage guidance. Could be slightly more concise by merging first two sentences, but overall efficient.

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

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

Given no output schema, the description explains what is returned ('most relevant tools with names and descriptions'), which is sufficient for a search tool. Parameter details are well-covered by schema. The description does not mention pagination or error handling, but for a simple search tool with only two parameters, this is adequate.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds meaning by explaining the query parameter expects a 'natural language description', which goes beyond the schema's generic description. The limit parameter is not elaborated in the description, but the schema already specifies default and max, so this is acceptable.

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 ('search', 'returns', 'call this FIRST') and clearly identifies the resource ('Pipeworx tool catalog'). It distinguishes the tool from siblings by stating it is for finding tools when 500+ are available, which no other sibling does.

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

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

Explicitly states when to use ('call this FIRST') and implies when not to (after tools are found). Provides context of 500+ tools, guiding the agent to prioritize this tool before others.

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 pipeworx:// citation URIs and replaces 15–30 sequential agent calls, implying efficiency. While it does not explicitly state read-only or safety, the nature of the tool (profile retrieval) implies no destructive side effects. More detail on data freshness or rate limits would improve transparency, but it is adequate.

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

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

The description is three concise sentences: purpose, details of data sources, and efficiency/return format. Every sentence adds value, no wasted words. Front-loaded with the core purpose. Excellent structure.

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

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

Given no output schema, the description explains the return format (pipeworx:// URIs) and the breadth of data. It provides context on efficiency (replaces many calls). However, it does not detail the structure of the profile or how to interpret the URIs. For a profile tool of moderate complexity, this is near-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 type and value. The description adds context: only 'company' is supported, value accepts ticker or CIK, and names are not supported (directing to resolve_entity). This supplements the schema meaningfully, though not extensively.

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: retrieving a full profile of an entity across all relevant Pipeworx packs. It specifies the entity type (company) and lists the data sources included (SEC filings, XBRL, USPTO, USAspending, GDELT, GLEIF). This level of detail distinguishes it from siblings like resolve_entity (which resolves names) and compare_entities (which compares).

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: 'Names not supported — use resolve_entity first if you only have a name.' It also notes that only 'company' is supported, setting expectations. However, it does not cover when to use alternatives like compare_entities or ask_pipeworx, but the context is sufficient for the primary 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 must fully disclose behavior. It states deletion by key but omits whether the operation is reversible, requires confirmation, or has side effects (e.g., cascading deletions). The description is too minimal for a destructive action.

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, concise sentence that is front-loaded with the action verb and resource. 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?

Given the tool's simplicity (one required parameter, no output schema, no annotations), the description is adequate but lacks behavioral details. It minimally covers the essentials but does not fully inform the agent about potential consequences.

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 required parameter 'key' described as 'Memory key to delete'. The description adds no additional meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the action (Delete), the resource (a stored memory), and the means (by key). It directly conveys the tool's function without ambiguity.

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

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

The description implies use when you need to remove a specific memory, but it does not explicitly state when not to use it or compare it to sibling tools like 'remember' or 'recall'. However, the purpose is clear enough to infer basic usage.

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

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

Annotations are empty, so the description must carry full weight. It discloses that the tool is for public projects only and returns specific fields, but does not mention read-only behavior, rate limits, or error conditions. With no annotations, a score of 3 is appropriate for a simple get operation.

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

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

The description is a single sentence that is concise and front-loaded with the main purpose. Every phrase adds value: input formats, return fields, and scope. 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 only one parameter, no output schema, and no annotations, the description is complete enough for the agent to select and invoke correctly. It covers input format, scope (public only), and expected return fields. However, it could be improved by noting that the tool is read-only.

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), so baseline is 3. The description adds the example of URL-encoded path and clarifies accepted formats, which adds some value beyond the schema's description.

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

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

The description clearly states the tool gets a public GitLab project, specifies the two accepted input formats (numeric ID or URL-encoded path), and lists the types of details returned. It uses specific verbs and resources, and the sibling tools do not overlap in functionality.

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

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

The description implies when to use (to fetch full project details by ID or path) but does not provide explicit guidance on when not to use or alternative tools. No exclusions or comparisons to siblings 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?

With no annotations, the description carries full burden. It discloses rate limiting (5 messages per day) and notes it is free, but does not describe what happens after sending (e.g., async acknowledgement, expected response time) or any 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?

Four sentences, front-loaded with purpose, zero wasted words. Every sentence adds essential information (use cases, exclusions, rate limit, cost).

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 simple parameters, the description fully covers what, when, how, and constraints (rate limit, cost). It is sufficient for an agent to understand the tool's role and usage.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value beyond the schema by instructing to be specific and avoid verbatim prompts, and by explaining the 'type' enum categories more contextually.

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 ('Send feedback') and clearly identifies the resource ('Pipeworx team'). It lists explicit use cases (bug reports, feature requests, etc.), distinguishing it from sibling tools like ask_pipeworx or discover_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 clear context for when to use (e.g., bug reports, praise) and even what not to include (end-user prompt verbatim). It mentions rate limiting but does not explicitly contrast with 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?

The description details the tool's behavior: walking child markets, extracting dates/thresholds, sorting, and reporting violations. This adds significant context beyond annotations (readOnlyHint, openWorldHint, destructiveHint) without contradiction.

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 yet comprehensive, explaining the concept, usage, mechanism, and output format in a well-structured paragraph. 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?

The description is complete for a read-only tool with one parameter. It explains the output format (list of entries with 'market_a', 'market_b', 'gap_pp', 'suggested_trade'). No output schema is needed given the clarity.

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

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

The single parameter 'event' has 100% schema coverage, and the description adds meaning by specifying it expects a Polymarket event slug or URL and explaining how it is used (to identify the event).

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 finds arbitrage opportunities by checking monotonicity violations within a Polymarket event. It explains the concept with concrete examples, distinguishing it from sibling tools like polymarket_edges or bet_research.

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 tool (to find arbitrage) and how to invoke it (pass event slug or URL). It does not explicitly mention when not to use it or suggest alternatives, but the context is clear for a niche tool.

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

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

Annotations already indicate readOnlyHint=true, openWorldHint=true, destructiveHint=false. The description adds significant behavioral context: it explains the V1 covers crypto-price bets using a lognormal model from FRED + live coinpaprika price, describes the process (scans, groups, fetches, computes, ranks), and notes the tool is non-destructive. 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 a single, well-structured paragraph. It is front-loaded with the main action, then provides details on methodology and output. Every sentence adds value without unnecessary elaboration.

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 clearly states the return format: 'top N ranked by edge magnitude with suggested trade direction.' It also specifies the scope (V1 covers crypto-price bets) and acknowledges limitations. This is complete 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?

Schema coverage is 100%, so baseline is 3. The description adds value by stating default values for limit (10), window (1wk), and min_edge_pp (0.5), and explains window as 'Polymarket volume window'. 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 it scans high-volume Polymarket markets, finds where Pipeworx data disagrees with market price, and returns top N ranked by edge magnitude with suggested trade direction. It specifically distinguishes itself from sibling tools like polymarket_arbitrage and bet_research.

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 'Built for the "what should I bet on today" question — agents/users discover opportunities without paging through hundreds of markets by hand.' This provides clear guidance on when to use the tool, though it does not explicitly state when not to use it 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 must cover behavioral traits. It states the tool retrieves or lists memories, which is transparent. However, it doesn't mention side effects (none expected) or performance implications, but given the simplicity, this is adequate.

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

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

Two sentences, front-loaded with action and optional behavior. Efficient and clear, no filler. Could be slightly more concise by merging sentences, but it's 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 tool with one optional parameter and no output schema, the description is complete. It explains both modes of operation and the purpose. No need for more detail.

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 clarity: 'omit to list all keys' explains the behavior when key is absent. However, the schema already describes the key parameter, so the description adds limited additional 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 retrieves a memory by key or lists all memories when key is omitted. It distinguishes from siblings like 'remember' (store) and 'forget' (delete).

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 mentions when to use: to retrieve context saved earlier. Does not mention when not to use or alternatives, but the context is clear and the tool's role is well-defined 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?

Describes fan-out to multiple sources in parallel, accepted date formats, return structure (changes, count, URIs), and the current limitation of only 'company' type. No annotations exist, so description carries the burden effectively.

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 well-structured sentences, each adding essential information. No redundancy or unnecessary detail. Front-loaded with 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 no output schema, description details return fields. Covers parameter formats, limitations, and use cases. Comprehensive 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 coverage is 100%, so baseline is 3. Description adds value by explaining that 'since' accepts ISO or relative dates, 'value' can be ticker or CIK, and 'type' is restricted to 'company'. 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 states 'What's new about an entity since a given point in time' and lists specific data sources (SEC EDGAR, GDELT, USPTO). It clearly distinguishes from sibling tools like 'entity_profile' by focusing on change monitoring.

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

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

Explicitly recommends use for 'brief me on what happened with X' or change-monitoring workflows. Does not mention when to avoid or alternatives, but the context is clear.

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

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

The description discloses key behavioral traits: memory persistence differences between authenticated and anonymous users. Since no annotations are provided, the description carries the full burden, and it does well by clarifying that anonymous sessions expire in 24 hours. However, it doesn't mention potential side effects like overwriting existing keys, but this is implicit in a key-value store.

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, each adding value: purpose, usage examples, and persistence context. No wasted words, front-loaded with the 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 the tool's simplicity (2 string params, no output schema), the description is complete. It covers what the tool does, when to use it, and behavioral nuances (persistence). No gaps remain.

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 both parameters well. The description adds context like example values and typical uses ('findings, addresses, preferences, notes'), which is helpful but not essential. 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 'Store a key-value pair in your session memory', specifying the verb (store) and resource (key-value pair in session memory). It distinguishes from siblings like 'recall' (retrieve) and 'forget' (remove), which are different operations on similar resources.

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: 'to save intermediate findings, user preferences, or context across tool calls.' It also distinguishes use cases by persistence: 'Authenticated users get persistent memory; anonymous sessions last 24 hours.' This helps decide when to use this vs. other memory tools.

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

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

Discloses accepted inputs (ticker, CIK, name), outputs (ticker, CIK, name, URIs), and that it's v1 for company only. No annotations provided, so description carries burden; lacks error handling info but adequately covers 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?

Two sentences with no redundancy. First sentence states primary purpose, second adds key details. 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?

For a simple 2-param tool with no output schema and no annotations, description covers purpose, inputs, and outputs adequately. Could mention error handling, but overall sufficient.

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

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

Schema description coverage is 100%, but description adds concrete examples (e.g., 'AAPL', '0000320193', 'Apple') and clarifies v1 support, enhancing parameter understanding beyond 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?

Clearly states verb 'resolve' and resource 'entity to canonical IDs', with specific details on supported type and input formats. Differentiates from siblings by noting it replaces 2-3 lookup calls.

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 it replaces 2-3 lookup calls, implying use when needing canonical IDs. No explicit when-not or alternatives, but context is clear.

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

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

With no annotations, the description carries the full burden. It clearly states the scope ('across all public GitLab projects') and lists return fields. However, it does not mention pagination, ordering, or rate limits, which are relevant for search operations.

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

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

Two concise sentences: first states purpose and scope, second lists return fields. No fluff, front-loaded.

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

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

Given no output schema and moderate complexity (search with limit), the description is nearly complete. Missing only minor behavioral details like default ordering.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add parameter details beyond the schema, but the schema already describes both 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?

Clearly states the action ('Search issues'), the target ('across all public GitLab projects'), and the specific fields returned ('title, state, author, labels, project ID, and URL'). This verb+resource+scope combination fully distinguishes it from sibling tools like search_projects.

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

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

Implies usage for searching issues but provides no explicit guidance on when to use this tool versus alternatives (e.g., search_projects). No 'when not to use' or specific 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 description carries full burden. It states ordering by star count and returns specific fields, but lacks disclosure about pagination, rate limits, or whether results are limited to public projects only.

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

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

Single sentence with clear action, scope, and output fields. 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?

Given no output schema, description compensates by listing return fields. Tool is simple with only 2 parameters, so description is adequate. Minor gap: no mention of public-only nature or sorting order beyond 'star count'.

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 does not add additional semantics beyond what schema provides for parameters, except implied use of query for keyword search.

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 searches public GitLab projects by keyword, ordered by star count. It also lists the returned fields, distinguishing it from siblings like search_issues and get_project.

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 implies usage for keyword-based project search, but does not explicitly say when to use this versus alternatives like get_project for single project retrieval or search_issues for issue search.

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

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

With no annotations, the description fully discloses behavior: it uses SEC EDGAR and XBRL, returns a verdict and structured data, and is read-only by implication. It lacks explicit mention of side effects or rate limits, but the nature of a fact-checking tool makes such disclosures less critical. The detail on output structure adds 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?

Three sentences deliver all essential information: purpose, scope, output details, and efficiency. No extraneous words. The first sentence immediately conveys the core function, and subsequent sentences add value without 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 single parameter and lack of output schema, the description adequately explains the output (verdict, structured form, citation, delta). It covers the data source and replaces sequential calls. Missing details on error handling or edge cases, but overall sufficient for 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?

The schema describes the single parameter 'claim' with an example. The description adds meaning by specifying the supported claim types (company-financial) and the fact that it processes natural language. This enriches the schema's basic definition, though the schema already covers 100% of parameters.

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

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

The description clearly states 'Fact-check a natural-language claim against authoritative sources,' specifying the verb (fact-check) and resource (claim). It distinguishes from siblings like 'resolve_entity' and 'compare_entities' by focusing on validation against SEC EDGAR and XBRL. The explicit domain (company-financial claims for US public companies) leaves 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 defines the domain ('v1 supports company-financial claims... public US companies') and the efficiency benefit ('Replaces 4–6 sequential agent calls'), guiding appropriate use. However, it does not explicitly state when not to use it or direct to alternative tools among siblings, slightly reducing clarity.

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