tle

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

With no annotations, the description carries full burden and does well: it discloses that Pipeworx 'picks the right tool, fills the arguments, and returns the result,' explaining the automated selection and execution process. However, it lacks details on rate limits, error handling, or data source limitations, leaving some behavioral aspects unspecified.

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

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

The description is front-loaded with the core functionality, followed by practical examples. Every sentence earns its place by clarifying usage and providing concrete instances, with no redundant or vague phrasing. It efficiently communicates key information in a compact format.

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 (automated tool selection) and lack of annotations/output schema, the description is mostly complete: it explains the process and provides examples. However, it doesn't detail output format or potential limitations (e.g., data source availability), leaving minor gaps for a tool with no structured output documentation.

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

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

Schema description coverage is 100%, with the parameter 'question' documented as 'Your question or request in natural language.' The description adds minimal value beyond this, only reinforcing natural language use through examples. Baseline 3 is appropriate since the schema adequately covers the single 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 the tool's purpose: 'Ask a question in plain English and get an answer from the best available data source.' It specifies the verb ('ask'), resource ('answer from data source'), and distinguishes from siblings by emphasizing natural language processing versus manual tool selection. The examples reinforce this distinction.

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 guidance is provided: use this tool for natural language queries instead of browsing tools or learning schemas, with clear examples ('What is the US trade deficit...', 'Look up adverse events...'). It directly contrasts with sibling tools like 'discover_tools' or 'search_satellites' by stating 'No need to browse tools or learn schemas.'

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 indicate read-only, open-world, non-destructive behavior. The description adds valuable behavioral context: it resolves, classifies, fans out to appropriate packs based on bet type, and returns an evidence packet with comparison. This goes beyond annotations without contradicting them.

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

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

The description is a single 5-sentence paragraph that is front-loaded with purpose, then details, then usage. It is not overly verbose and each sentence contributes, 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?

Despite no output schema, the description adequately explains the return value (evidence packet and market-vs-model comparison). For a tool with 2 parameters, it is complete enough. It describes the fan-out logic and classification, which is 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?

The input schema has 100% description coverage, but the description adds meaning by explaining that 'market' can be a slug, URL, or question text, and that 'depth' defaults to thorough. This aids 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 that the tool researches Polymarket bets by pulling relevant Pipeworx data. It specifies the input types (slug, URL, question text) and the output (evidence packet and comparison). This distinguishes it from sibling tools like ask_pipeworx which are more general.

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: 'should I bet on X?', 'what does the data say?', 'is there edge?'. It does not explicitly state when not to use it, but the use cases are well-defined. It mentions that agents using this convert better, implying it should be preferred over manually discovering packs.

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

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

No annotations provided; description carries full burden. It discloses data sources (SEC EDGAR) and return content (paired data + URIs), but does not mention side effects, auth requirements, rate limits, or error behavior. Adequate but not comprehensive.

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

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

Four sentences, each informative. Front-loaded with core purpose, followed by type-specific details, return type, and efficiency note. No wasted words.

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

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

Given no output schema, description explains return type (paired data + URIs) but lacks detailed structure. For a simple comparison tool with two parameters, this is reasonably complete, though output format could be clearer.

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

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

Schema coverage is 100%, baseline 3. Description adds value by explaining what fields are compared for each entity type and giving examples (e.g., tickers/CIKs for company, drug names for drug), enhancing parameter understanding beyond raw schema.

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

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

Description clearly states the tool compares 2-5 entities side by side, specifies two entity types (company and drug) with detailed fields, and mentions it replaces 8-15 sequential 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?

States the tool replaces 8-15 sequential agent calls, implying efficiency for batch comparisons. However, it does not explicitly state when not to use or mention alternative tools, 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 provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it's a search operation (implied read-only), returns ranked results ('most relevant tools'), and provides output format ('names and descriptions'). However, it doesn't mention potential limitations like rate limits, authentication requirements, or error conditions.

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 concise with two sentences that each earn their place: the first explains what the tool does, the second provides critical usage guidance. It's front-loaded with the core functionality and wastes no words while being highly informative.

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 2 parameters, 100% schema coverage, and no output schema, the description provides strong context about when and why to use it. The main gap is the lack of output format details beyond 'names and descriptions' - without an output schema, more detail about the return structure would be helpful. However, the usage guidance is exceptionally strong.

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 thoroughly. The description doesn't add any meaningful parameter semantics beyond what's in the schema - it mentions 'describing what you need' which aligns with the query parameter but doesn't provide additional context. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('Search the Pipeworx tool catalog') and resource ('tool catalog'), and explicitly distinguishes it from siblings by emphasizing it should be called FIRST when dealing with 500+ tools. It provides concrete examples of what the tool does (returns relevant tools with names and descriptions).

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 this tool ('Call this FIRST when you have 500+ tools available and need to find the right ones for your task'), including a specific threshold (500+ tools) and context (finding tools for a task). It clearly positions this as an entry point tool for discovery among many options.

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 the data sources and output format (pipeworx:// URIs) but does not mention idempotency, error behavior, or authorization requirements. Adequate but could be more explicit about safety.

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?

Five concise sentences: purpose, content listing, output format, efficiency claim, exclusion note. Every sentence adds value with no redundancy.

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

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

Given two simple parameters and no output schema, the description covers purpose, content, and usage boundaries. Omits error handling and return structure details, but for a composite tool, it is sufficient for agent understanding.

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

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

Schema coverage is 100%, but description adds meaningful context: clarifies type enum limitations (company only) and advises ticker/CIK format for value, directing name-only users to resolve_entity. Augments schema with practical guidance.

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 a full profile of an entity across multiple packs, listing specific data sources (SEC filings, XBRL, patents, news, LEI). It differentiates from siblings by noting it replaces 10–15 sequential calls and directs federal contract queries to usa_recipient_profile.

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: when a comprehensive entity profile is needed. Provides specific exclusions: for federal contracts, use usa_recipient_profile; and via the value parameter description, advises using resolve_entity first if only a name is available.

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 indicates a destructive operation ('Delete') but doesn't specify whether deletion is permanent, reversible, requires specific permissions, or has side effects. For a mutation tool with zero annotation coverage, this is a significant gap in behavioral context.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately understandable 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?

For a destructive tool with no annotations and no output schema, the description is incomplete. It doesn't address behavioral aspects like permanence, error conditions, or response format, nor does it provide usage guidance relative to siblings. The high schema coverage doesn't compensate for these gaps in context.

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

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

Schema description coverage is 100%, with the single parameter 'key' documented as 'Memory key to delete'. The description adds no additional meaning beyond this schema information, such as key format examples or constraints. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the specific action ('Delete') and resource ('a stored memory by key'), distinguishing it from sibling tools like 'recall' (likely retrieve) and 'remember' (likely store). It uses precise verb+resource terminology that leaves no ambiguity about the tool's function.

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 like 'recall' or 'remember', nor does it mention prerequisites (e.g., needing an existing memory key) or exclusions. It states what the tool does but offers no contextual usage instructions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes what the tool returns ('satellite name, epoch date, and both TLE lines'), which adds value beyond the input schema. However, it lacks details on error handling, rate limits, or data sources, leaving gaps in behavioral context 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 a single, efficient sentence that front-loads the purpose and key details. Every word earns its place, with no redundant or unnecessary information, making it highly concise 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?

Given the tool's low complexity (1 required parameter, no nested objects) and no output schema, the description is mostly complete. It specifies the return values, which compensates for the lack of output schema. However, it could improve by mentioning error cases or data availability, slightly reducing completeness for a tool with no annotations.

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

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

The input schema has 100% description coverage, with the 'norad_id' parameter well-documented in the schema. The description does not add any additional meaning or syntax details beyond what the schema provides, such as examples or constraints. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the specific action ('Fetch'), resource ('Two-Line Element (TLE) set for a specific satellite'), and scope ('by its NORAD catalog ID'). It distinguishes from sibling tools like 'list_recent' and 'search_satellites' by focusing on retrieving detailed TLE data for a single satellite rather than listing or searching multiple satellites.

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

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

The description implies usage by specifying 'by its NORAD catalog ID,' suggesting this tool is for when you have a specific satellite ID. However, it does not explicitly state when to use this tool versus alternatives like 'list_recent' or 'search_satellites,' nor does it provide exclusions or prerequisites for 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?

No annotations are provided, so the description carries the full burden. It mentions sorting and a default limit, but doesn't disclose key behavioral traits such as pagination, rate limits, authentication needs, error handling, or what 'recent' means (e.g., time range). This leaves significant gaps for an agent to understand operational constraints.

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, efficient sentence that front-loads the core purpose ('List the most recently launched or updated satellites') and adds essential detail ('sorted by epoch date descending') without waste. 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?

Given no annotations, no output schema, and a simple input schema, the description is incomplete. It lacks details on return format (e.g., what data fields are included), error cases, and behavioral constraints like rate limits or authentication. For a tool with zero annotation coverage, this leaves the agent under-informed.

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 fully documents the 'limit' parameter. The description adds no additional parameter semantics beyond implying recency filtering, which isn't parameterized. Baseline 3 is appropriate as the schema handles 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 action ('List') and resource ('most recently launched or updated satellites'), with specific sorting criteria ('sorted by epoch date descending'). It distinguishes from 'search_satellites' by focusing on recency rather than general search, though it doesn't explicitly differentiate from 'get_tle' (which likely retrieves specific orbital data).

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 retrieving recent satellites, but doesn't explicitly state when to use this tool versus alternatives like 'search_satellites' or 'get_tle'. No guidance on prerequisites, exclusions, or specific scenarios 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?

The description discloses a behavioral constraint: rate-limited to 5 messages per identifier per day. It also says 'Free'. However, it does not describe what happens when the limit is exceeded, whether feedback is anonymous, or any other behavioral details. With no annotations, more transparency would be beneficial.

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, no fluff. Front-loaded with purpose and usage. 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 low complexity, no output schema, and good input schema, the description covers purpose, usage, parameter guidance, and rate limit. It could mention what happens after submission (confirmation or error), but overall is complete enough for a feedback 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?

Input schema has 100% description coverage. The description adds extra guidance for the message parameter ('Describe what you tried... do not include the end-user's prompt verbatim'), which adds value beyond the schema. The context parameter is well-described in both. Minor extra value.

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

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

The description clearly states the verb 'send feedback' and the resource 'Pipeworx team'. It lists specific use cases (bug reports, feature requests, missing data, praise) and is distinct from all sibling tools, none of which are feedback-related.

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 and specific guidance on what to include ('Describe what you tried...') and what not to include ('do not include the end-user's prompt verbatim'). It also mentions the rate limit. It lacks explicit exclusions (e.g., not for general questions), but the context makes it sufficiently 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?

Annotations indicate readOnlyHint=true, openWorldHint=true, destructiveHint=false. The description adds rich behavioral context: walks child markets, groups across events, returns ranked opportunities with reasoning. No contradiction with annotations.

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

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

Concise single paragraph with clear structure: purpose statement, two modes with explanations, rationale for cross-event mode, and return value. Every sentence adds value; no unnecessary 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 complexity of two modes and cross-event analysis, the description fully explains the tool's behavior, parameter usage, and output. No output schema needed; the description adequately covers return values. Annotations complement 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. The description adds significant meaning: explains the two modes, maps parameters to modes, provides concrete examples, and clarifies when each parameter should be used.

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 finds arbitrage opportunities on Polymarket by checking monotonicity violations. It distinguishes two modes (event and topic) with specific examples, and the verb 'find' and resource are precise. This differentiates it from siblings like polymarket_edges.

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 explains when to use each mode: event mode for a single event slug, topic mode for a seed question to catch cross-event cases. Provides rationale for cross-event mode, helping the AI decide which mode to invoke.

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 read-only, open-world, non-destructive behavior. The description adds rich behavioral details: scanning top markets, grouping by asset, caching price history, computing model probabilities, ranking by edge. No contradictions; complements annotations 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 detailed yet efficiently structured, front-loading the core action and providing algorithmic steps. It is slightly longer than strictly necessary but remains clear 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?

Despite lacking an output schema, the description explicitly states returns: 'top N ranked by edge magnitude with suggested trade direction.' It covers the algorithm, constraints, and intended use, making it complete for the tool's 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?

Input schema has 100% description coverage for all three parameters (limit, window, min_edge_pp), so the baseline is 3. The description does not add specific parameter-level details beyond the schema but explains the algorithm context, which indirectly aids understanding.

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

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

The description clearly states the tool's purpose: scanning high-volume Polymarket markets to find where Pipeworx data disagrees with market price, specifically for crypto-price bets. It distinguishes itself from sibling tools like polymarket_arbitrage and bet_research by detailing its unique algorithmic approach.

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 indicates usage for the 'what should I bet on today' question and mentions discovering opportunities without manual browsing. It provides context but doesn't explicitly state when not to use or compare with alternatives, though the sibling tool list implies differentiation.

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 it retrieves stored memories and works across sessions, but doesn't mention behavioral traits like error handling (e.g., what happens if key doesn't exist), performance (e.g., speed or limits), or side effects (e.g., if retrieval logs activity). It adds some context but lacks depth 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 appropriately sized and front-loaded: two concise sentences that directly state the purpose and usage without waste. The first sentence covers the core functionality, and the second provides essential guidance, making it efficient 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?

Given the tool's moderate complexity (retrieval/list operation), no annotations, and no output schema, the description is adequate but has gaps. It explains what the tool does and how to use the parameter, but doesn't cover return values, error cases, or session persistence details. It meets minimum viability but lacks completeness for a tool with no structured output information.

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 description coverage is 100%, with the schema documenting the key parameter. The description adds value by explaining the semantics: 'omit to list all keys' clarifies the optional behavior, and it ties the parameter to retrieving context saved earlier. With one parameter and high schema coverage, this exceeds the baseline of 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 the tool's purpose: 'Retrieve a previously stored memory by key, or list all stored memories (omit key).' It specifies the verb ('retrieve'/'list') and resource ('memory'), but doesn't explicitly distinguish it from sibling tools like 'remember' or 'forget' beyond mentioning it retrieves context saved earlier.

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 it: 'Use this to retrieve context you saved earlier in the session or in previous sessions.' It explains the key parameter behavior (omit to list all keys), but doesn't explicitly state when not to use it or name alternatives among siblings like 'list_recent' or 'search_satellites'.

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 transparency burden. It discloses that for type='company' the tool fans out to multiple sources in parallel, accepts ISO or relative dates, and returns structured data with URIs. This provides sufficient behavioral insight for an 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?

The description is three sentences long, with no redundant words. It front-loads the main action, then details the behavior, parameter specifics, and return structure. Every sentence provides essential information.

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

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

Given 3 parameters with 100% schema coverage and no output schema, the description thoroughly covers inputs, behavior, and return structure. It explains the fan-out logic, date formats, and output shape, making the tool self-contained and usable 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 baseline is 3. The description adds value by explaining the 'since' parameter format with examples ('2026-04-01', '7d', '30d') and clarifies that 'value' can be a ticker or CIK. This goes beyond the schema's terse 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: 'What's new about an entity since a given point in time.' It specifies the action (brief/monitor) and resource (entity changes), and distinguishes from sibling tools like 'entity_profile' and 'list_recent' by focusing on time-bounded change detection.

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

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

The description explicitly mentions use cases: 'brief me on what happened with X' or 'change-monitoring workflows.' It does not explicitly state when not to use or list alternatives, but the use case guidance is clear and actionable.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: the persistence differences between authenticated vs. anonymous sessions ('Authenticated users get persistent memory; anonymous sessions last 24 hours'), which is crucial context not inferable from the schema alone. It doesn't cover rate limits or error conditions, but provides substantial behavioral insight.

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 concise with two sentences that each earn their place. The first sentence states the core functionality, and the second adds crucial behavioral context about persistence. No wasted words, and the most important information is front-loaded.

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

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

For a 2-parameter tool with no annotations and no output schema, the description provides good context about persistence behavior and usage scenarios. However, it doesn't mention what happens on success/failure, whether there are size limits for values, or how keys are namespaced. Given the simplicity of the tool, the description is mostly complete but has minor 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 schema description coverage is 100%, so the schema already fully documents both parameters. The description doesn't add any parameter-specific information beyond what's in the schema descriptions. It mentions the types of data that can be stored, but this relates to the tool's purpose rather than parameter semantics. Baseline 3 is appropriate when 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 with specific verb ('Store') and resource ('key-value pair in your session memory'), and distinguishes it from siblings by specifying it's for saving data (vs. recall, forget, etc.). It explicitly mentions what types of data can be stored ('intermediate findings, user preferences, or context across tool 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?

The description provides clear context for when to use this tool ('save intermediate findings, user preferences, or context across tool calls'), but doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools (like recall for retrieval or forget for deletion). The guidance is helpful but lacks explicit exclusions.

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

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

No annotations provided, so description carries full burden. Discloses accepted inputs (ticker, CIK, name), return fields (ticker, CIK, company name, URIs), and version constraints. Lacks details on error handling, authentication, or side effects. Adequate but not comprehensive.

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

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

Three concise sentences, front-loaded with the primary purpose, and every sentence adds essential information (version, inputs, outputs, efficiency benefit). No wasted words.

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

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

Adequately covers purpose, input parameters (both described with examples), and return structure (ticker, CIK, company name, pipeworx:// URIs) despite no output schema. Missing error handling or performance notes, but sufficient for a straightforward 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?

Input schema coverage is 100%, but the description adds value beyond schema by explaining type='company' as v1 and providing concrete examples for value (AAPL, 0000320193, Apple). This enriches understanding beyond the schema definitions.

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

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

Clearly states the tool resolves an entity to canonical IDs across Pipeworx data sources in a single call. Specifies verb (resolve), resource (entity to canonical IDs), and distinguishes from siblings by noting it replaces multiple lookup calls. Includes version and accepted input formats.

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

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

Provides clear context for when to use: to resolve an entity to canonical IDs efficiently, replacing 2-3 lookup calls. Does not explicitly state when not to use or list alternatives, but the description implies it is the appropriate choice for entity resolution among the 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the return of 'NORAD IDs and TLE data', which adds some context, but lacks details on permissions, rate limits, error handling, or whether this is a read-only operation. For a search tool, this leaves significant gaps in understanding its 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 appropriately sized and front-loaded, with two clear sentences that state the purpose and output. There's no wasted text, and it efficiently conveys the core functionality, though it could be slightly more structured by including usage hints.

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 (2 parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the basic purpose and output but misses behavioral details and usage guidelines. Without annotations or output schema, it should do more to explain the tool's full context, such as response format or 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?

The description adds minimal meaning beyond the input schema, which has 100% coverage. It implies the 'query' parameter is for name or keyword searches, but the schema already describes this. No additional syntax or format details are provided, so it meets the baseline for high schema coverage without compensating with extra insights.

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: 'Search for satellites by name or keyword' specifies the verb (search) and resource (satellites), and 'Returns matching satellites with their NORAD IDs and TLE data' indicates the output. However, it doesn't explicitly differentiate from sibling tools like 'get_tle' or 'list_recent', which might offer alternative ways to access satellite data.

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 like 'get_tle' or 'list_recent'. It mentions the search functionality but doesn't specify scenarios where this is preferred over other tools, such as for fuzzy matching or when exact identifiers are unknown.

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 burden. It details the internal process (NL parsing, entity resolution, data lookup, comparison) and outputs (verdict, extracted form, actual value with citation, percent delta). This is transparent, though it does not cover failure modes or limits beyond the stated scope.

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 efficient: three sentences that state the purpose, scope, returns, and efficiency gain. Every sentence adds value, and the key information is front-loaded in the first sentence.

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 or annotations, the description covers essential aspects: supported claim types, underlying sources, return values, and process. It lacks details on error handling or prerequisites but is nearly complete 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?

Schema coverage is 100% with a description for the sole parameter 'claim'. The tool description adds value by providing concrete examples of valid claims (e.g., 'Apple's FY2024 revenue was $400 billion'), enhancing understanding beyond the schema's generic 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 fact-checks natural-language claims against authoritative sources, specifically company-financial claims. It explicitly mentions the supported claim types and outputs, distinguishing it from sibling tools by noting it replaces multiple sequential agent 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?

The description specifies the tool is for fact-checking financial claims in v1, with examples of acceptable claims. It implies when to use (for such claims) but does not explicitly state when not to use or provide direct alternatives, though the sibling context exists.

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