ContextPulse

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

Despite no annotations, the description fully discloses behavior: pure read of static metadata, no side effects, no auth, no rate limits, safe to call anytime. This is comprehensive and goes beyond what annotations would typically provide.

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

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

Well-structured with clear sections (USE WHEN, NOT FOR, ALTERNATIVES, BEHAVIOR). Every sentence adds value, no redundancy. Concise yet comprehensive.

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 zero parameters, an output schema exists, and the description fully explains what is returned: a multi-line string with daemon info, data sources, endpoint, and URLs. 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?

No parameters exist (0 params, baseline 4). The description adds value by explaining the output content, but there is no parameter information to add since there are none.

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 summary of ContextPulse, including what it captures, installation, and connection info. It uses specific verbs and resources, and distinguishes itself from sibling tools by explicitly stating what it is not for and listing alternatives.

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 WHEN and NOT FOR sections guide the agent on when to use this tool versus alternatives. It clearly states when to use (to learn about ContextPulse) and when not to (for live data), and names alternative tools.

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

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

Discloses side effect of writing to database, persistence across restarts, and idempotency behavior for identical pairs - all beyond the absent 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?

Every sentence adds value, front-loaded with purpose and return values, structured with clear sections (USE WHEN, NOT FOR, ALTERNATIVES, BEHAVIOR, PARAMETERS).

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

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

Covers all aspects for a simple two-parameter tool: purpose, when to use, parameters, side effects, idempotency, and return values (output schema exists but description already 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?

With 0% schema coverage, description fully explains both parameters: term is required and non-empty, pronunciation is optional with format hints and inference fallback.

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 adds a custom term to ContextPulse's voice vocabulary so Whisper recognizes it, distinguishing it from siblings like remove_from_vocabulary and get_vocabulary.

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

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

Explicitly tells when to use (for mis-transcribing proper nouns/technical terms), when not to use (bulk loads, use CLI), and provides alternatives (remove_from_vocabulary, get_vocabulary).

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

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

No annotations provided, so description fully informs: 'pure read', 'snapshot captured at call time', 'very low cost'. Some detail on potential workspace changes could be added, but current info is strong.

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 clear sections (purpose, usage, behavior). Every sentence serves a purpose. Extremely concise yet 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?

Fully captures the tool's purpose, usage conditions, and behavior. With no parameters and an output schema, the description is complete for an AI agent to decide when to invoke.

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

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

No parameters exist, so baseline is 4. The description does not add parameter info, but it describes the return value (structured snapshot), which adds value beyond the empty input schema.

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

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

The description uses a specific verb 'describe' and clearly identifies the resource 'current desktop workspace state: active app, open windows, monitors'. It distinguishes itself from siblings like get_screenshot (visual content) and get_screen_text (text content).

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

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

Explicitly provides a 'USE WHEN' section (quick 'where am I') and a 'NOT FOR' section that names alternatives (get_screenshot, get_screen_text). This gives clear context and exclusions.

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

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

Discloses vector search method, sub-second speed, and condition when no results are returned (embeddings not built). With no annotations, description carries full burden and provides useful behavioral context, though could detail output format further.

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

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

Well-structured with clear sections. Every sentence adds value. Front-loaded with purpose, followed by usage, behavior, and parameter details. No wasted words.

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

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

For a multi-source semantic search tool with two parameters and an output schema, the description covers purpose, usage, behavioral nuances, and parameter details comprehensively. Output schema exists, so return value details are not required.

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

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

Adds crucial meaning beyond schema: query is free-text, required, non-empty; limit range 1-50, default 10. Schema coverage 0% so description fully compensates with clear parameter semantics.

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

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

Clearly states it finds semantically related screen, voice, and clipboard entries. Provides a unified list with ranking and source-type tags. Distinguishes from single-source siblings.

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

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

Explicitly specifies USE WHEN for open-ended recall across multiple data types and NOT FOR single-source search, naming alternatives (search_history, search_voice, search_clipboard).

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 pure read behavior, signal combination, and fallback to 'unknown' when confidence is low. With no annotations, the description fully covers behavioral expectations.

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

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

Concise, well-structured description with purposeful sections (what, returns, when to use, when not, behavior). Every sentence contributes value without redundancy.

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

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

Given zero parameters and presence of output schema, the description fully covers all necessary context: detection methods, confidence, and unknown case. 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?

No parameters exist, and schema coverage is 100% trivially. Baseline score of 4 applies as description adds no parameter details but none are needed.

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

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

The description clearly states the tool detects the user's current project from working directory, active window, and recent activity, specifying the return values (project ID, detection method, confidence) and distinguishing it from the sibling 'identify_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?

Explicitly states when to use ('starting a session', user asking 'where am I') and when not to use ('classifying arbitrary text' with sibling alternative 'identify_project'), providing clear context for agent decision.

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

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

Despite no annotations, the description covers behavior: aggregates from buffer + activity log, no side effects, and accuracy depends on buffer coverage with a suggestion to check get_buffer_status. This provides sufficient transparency.

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

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

The description is well-structured with a concise summary followed by clearly labeled sections (USE WHEN, NOT FOR, BEHAVIOR, PARAMETERS). 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 the tool has 1 parameter and an output schema, the description explains the return type (structured summary with per-app time, keywords, focus sessions, idle gaps) and dependencies (buffer coverage). It provides everything needed for correct invocation.

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

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

The single parameter 'hours' is fully described: lookback window, range 1-24, default 1. Since schema coverage is 0%, the description compensates by adding semantic meaning beyond the schema's type and default.

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 summarizes user activity over N hours, with specific verb 'summarize' and resource 'activity'. It explicitly distinguishes from sibling tools get_app_usage and get_recent_touch_events, providing purpose differentiation.

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

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

The description includes a 'USE WHEN' block with concrete user queries like 'what have I been doing' and a 'NOT FOR' block with alternatives, giving explicit guidance on appropriate 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?

Describes as 'pure read from foreground-window log. No side effects.' and specifies granularity (per-second). No annotations exist, so this is sufficient, though could mention data retention or access 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?

Extremely concise: three short sections with no fluff. Each sentence serves a purpose (overview, use case, behavior, parameter). Perfectly 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 the tool's simplicity (1 param, output schema exists), the description covers purpose, usage, behavior, and parameter completely. 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?

The parameter 'hours' is described with range (1-24) and default (1), adding value beyond the schema. Schema coverage is 0%, so description compensates well, though could clarify unit (hour).

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 'Return per-application time-on-task over the last N hours' with verb, resource, and scope. It also distinguishes from sibling tools like get_activity_summary, making it unambiguous.

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

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

Explicit 'USE WHEN' and 'NOT FOR' sections provide clear context and name an alternative tool (get_activity_summary), guiding the agent on appropriate 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?

Explicitly states 'BEHAVIOR: pure read of buffer metadata. No side effects.' With no annotations provided, this fully discloses the read-only nature and lack of 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?

Exceptionally concise yet comprehensive. Front-loaded with the main purpose, followed by structured sections for return values, usage guidelines, and behavior. 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 zero parameters and an existing output schema, the description fully covers purpose, usage, behavior, and return values. Provides complete context for the agent to select and invoke correctly.

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

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

No parameters exist in the schema, so baseline is 4. The description does not need to add parameter semantics but confirms the tool takes no arguments.

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 'Report' and the resource 'rolling capture buffer's size, age range, retention policy, and disk usage'. It distinguishes itself from sibling tools like get_recent and search_history by indicating they are for contents.

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

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

Provides explicit 'USE WHEN' for troubleshooting and before requesting historical context, and 'NOT FOR' for contents of the buffer with specific alternative tool names.

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 pure read behavior and auto-exclusion of sensitive content (passwords, OAuth tokens), compensating for absent 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?

Succinctly structured with sections for usage, behavior, and parameters; 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?

Completely covers all necessary information for a simple single-parameter tool with an output schema; describes output contents adequately.

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

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

Description adds full context for parameter 'n': range 1-100, default 10, newest-first order. Input schema only provides default, so description adds significant 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 it returns recent clipboard entries, specifies returned fields (timestamp, content/content-type, source app), and distinguishes from sibling tool search_clipboard.

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 (user references copying) and when not (text search), including the alternative tool name (search_clipboard).

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

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

With no annotations, description fully discloses behavior: 'pure read', returns closest buffer entry within +/-30 seconds, raises if no entry exists. This covers safety and error conditions adequately.

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

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

Well-structured with labeled sections (USE WHEN, NOT FOR, etc.) and no redundant sentences. Slightly verbose but each sentence adds value. Could be tightened slightly without losing clarity.

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

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

Given one parameter, no annotations, and an output schema (implied), description covers all essential: return content (screen state, OCR, active window, clipboard), timing constraint, error case. Sufficient for agent to invoke correctly.

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

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

Single parameter minutes_ago with schema coverage 0% is fully described: 'how many minutes back to look. Range 0-1440 (24h). Required.' Adds meaning beyond schema type and required status.

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 'Return screen + activity context from a specific point in the recent past' with specific verb and resource. Distinguishes from siblings like get_recent and search_history by emphasizing temporal point retrieval versus chronological list or text-search.

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

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

Explicitly provides 'USE WHEN' scenarios (user references something from earlier), 'NOT FOR' cases (live state, text-search), and 'ALTERNATIVES' (get_recent, search_history) with clear conditions.

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?

States 'BEHAVIOR: pure read. No side effects.' and lists return fields (original transcript, corrected text, confidence delta, timestamp, manual/auto). No annotations provided, so description fully covers behavioral traits.

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

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

Concise, well-structured with clear sections: purpose, return fields, usage guidelines, behavior, parameter details. 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?

Complete for a one-parameter tool with an output schema. Covers purpose, usage, behavior, parameter, and return data. No 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?

Input schema has 0% coverage but description adds 'limit: max results, ordered newest-first. Range 1-100. Default 20.' Provides range, ordering, and default value beyond schema.

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

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

Clearly states 'Return recent voice transcription corrections' with specific verb and resource. Distinguishes from siblings by specifying use cases and not for vocabulary management.

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

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

Explicitly provides 'USE WHEN' (training vocabulary, analyzing errors, debugging) and 'NOT FOR' with alternatives (add_to_vocabulary / remove_from_vocabulary).

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?

Declares 'pure read; no side effects' and notes the result is dynamic (may change if displays change). This compensates for the lack of 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 and well-structured with clear sections for usage, alternatives, and behavior. Every sentence adds value without redundancy.

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

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

Given zero parameters and existence of an output schema, the description fully covers purpose, usage, behavior, and return fields. No 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?

Tool has no parameters; input schema is empty with 100% coverage. Baseline is 4 per guidelines. Description does not need to add param info but indirectly adds value by explaining output.

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 lists connected displays with specific metadata (resolution, scaling, active monitor). It distinguishes itself from sibling tools like get_screenshot by focusing on metadata vs. capture.

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

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

Provides explicit 'USE WHEN' scenarios (e.g., before get_screenshot to target a monitor) and 'NOT FOR' (capturing pixels), plus names get_screenshot as alternative.

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 behavior as 'pure read' and explains return value (markdown string, empty string if no context). Without annotations, this is clear but could be more detailed (e.g., no side effects, idempotent).

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?

Very concise with structured sections (USE WHEN, NOT FOR, BEHAVIOR, PARAMETERS). No wasted words, front-loaded with main 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?

Given output schema exists, description covers usage, return value, parameter guidance, and exclusion. No gaps for this simple read 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?

Adds meaning beyond schema by specifying parameter format: 'project slug as returned by list_projects or get_active_project.' Schema coverage is 0%, so this is crucial and well done.

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 returns the full PROJECT_CONTEXT.md content for a specific project, using verb 'returns' and specifying the resource and scope. Distinguishes from sibling get_activity_summary.

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

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

Explicitly provides 'USE WHEN' and 'NOT FOR' conditions, recommending an alternative tool (get_activity_summary) for live activity.

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

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

Despite no annotations, description fully discloses behavior: pure read from local buffer, no side effects, and defaults for retention (~24h). Equips agent with safety and impact understanding.

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

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

Well-structured with clear sections (purpose, return, usage, behavior, parameters). Every sentence is informative and no redundancy.

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

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

Given the tool's simplicity and existence of output schema, the description covers all necessary aspects: what it returns, when to use, how to configure, and behavior. No critical 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?

Input schema has no descriptions (coverage 0%), but the description adds range (1-100) and default (10) for parameter 'n', fully compensating for schema gap.

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 returns the most recent N screenshots from the rolling capture buffer, with a specific verb and resource. It distinguishes from siblings by naming alternatives like get_screenshot and search_history.

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

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

Provides explicit USE WHEN, NOT FOR, and ALTERNATIVES sections. Clearly guides the agent on when to use (past buffer) vs not (live state), and points to specific sibling tools.

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

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

No annotations provided, but description fully discloses behavior: pure read operation, privacy guarantee (no key contents, no clipboard targets, no scroll positions inside sensitive apps). Adds significant context beyond the schema.

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

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

Well-structured with clear sections: function, return format, usage guidance, behavior, parameters. Every sentence adds value, no redundancy. Efficient and front-loaded.

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

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

Given the simple single-parameter tool and presence of output schema, the description is complete. It explains the return data sufficiently and addresses privacy concerns, leaving no gaps for the 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?

Parameter 'n' has no schema description (0% coverage), but the description adds meaning: 'number of events. Range 1-500. Default 50.' This compensates fully, providing constraints and defaults not in schema.

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

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

Clearly states the tool returns the most recent N keyboard and mouse activity events, with specific details on the returned data (timestamp, type, aggregate counts, active app). Distinguishes from siblings like get_touch_stats and get_activity_summary by focusing on event-level 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?

Explicitly states when to use (analyzing input patterns, idle detection, activity timing) and when not to use (keylogging). Provides a clear privacy guarantee, helping the agent avoid misuse.

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 and explicitly states 'BEHAVIOR: pure read from the voice transcript log. No side effects.' This discloses the key behavioral trait clearly and accurately.

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

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

The description is highly concise with no wasted words, and organized into clear sections (USE WHEN, NOT FOR, ALTERNATIVES, BEHAVIOR, PARAMETERS). 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, the description covers all necessary aspects: purpose, usage context, behavior, parameter details, and return fields (timestamp, transcript, confidence, duration). It is complete and well-rounded.

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 0%, so description must compensate. It explains parameter n as 'how many segments to return. Range 1-100. Default 10.', adding meaning beyond the schema's type and default.

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 the most recent N voice transcription segments, specifying the resource (voice transcription segments) and scope (most recent N). It distinguishes from siblings like search_voice and find_related_context by explicitly naming them as alternatives.

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

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

The description provides explicit USE WHEN and NOT FOR conditions, and lists alternatives (search_voice, find_related_context). This gives clear guidance on when to invoke this tool vs 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 fully discloses behavioral traits: synchronous capture, timing (50-200 ms), side effect (written to rolling buffer), and access constraints (no auth/rate limits, local 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?

Well-structured with clear section headers (USE WHEN, NOT FOR, ALTERNATIVES, BEHAVIOR, PARAMETERS). Every sentence adds value, no redundancy, and front-loaded with key 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?

For a simple tool with one parameter and an output schema, the description covers all relevant aspects: purpose, usage, behavior, parameter, and return type (base64 PNG + metadata). No 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?

Schema coverage is 0%, but description adds rich semantics: explains monitor_index as 0-based from get_monitor_summary, notes default behavior (capture cursor's monitor), and guides on usage (omit or pass None).

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

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

Description clearly states the verb 'Capture a screenshot' and specific resource 'active monitor' with details on resolution and output format. It distinguishes from sibling tools like get_screen_text by noting different use cases.

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

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

Explicitly lists when to use (pixel-level visual context) and when not (text extraction), names alternatives (get_screen_text, get_recent, get_context_at), and provides cost/benefit reasoning ('~5x cheaper in tokens').

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 behavior in detail: captures+OCR in one call, timing (200-800 ms), token efficiency, and indexing into OCR history. No annotations exist, so description fully covers behavioral aspects.

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

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

Well-organized with sections (USE WHEN, NOT FOR, ALTERNATIVES, BEHAVIOR), front-loaded, and every sentence adds value. No wasted words.

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

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

Given no parameters and an output schema exists, the description is complete: it explains purpose, usage context, behavior, and alternatives. No 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?

No parameters in schema (100% coverage). With zero params, description need not add param info. The description adds context about what the tool does without relying on schema details.

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 runs OCR on the current screen and returns extracted text grouped by region. It distinguishes itself from sibling tools like get_screenshot and search_history by specifying its purpose.

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

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

Explicitly provides USE WHEN and NOT FOR conditions, and lists alternatives (get_screenshot, search_history), giving clear guidance on when to use this tool.

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

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

Declares 'pure read' behavior and explains session boundary defined by daemon start, reset on restart. No annotations provided, but description fully covers behavioral traits.

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

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

Two sections with three sentences plus two usage lines. Front-loaded with purpose, every sentence adds value. No wasted words.

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

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

With 0 params, no annotations, and output schema present, description explains return values (aggregate counts, timestamp) and session boundary. Fully adequate 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?

No parameters required; input schema is empty with 100% coverage. Baseline 4 applies as description adds purpose context beyond schema, but no parameter details needed.

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

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

Description explicitly states verb 'Summarize' and resource 'current ContextPulse session', listing apps, captures, voice. It distinguishes from sibling get_activity_summary by noting it's a single-call rollup for the entire session.

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?

Contains explicit 'USE WHEN' and 'NOT FOR' sections, specifying ideal use at session end and directing to get_activity_summary for arbitrary windows. Provides clear context for tool selection.

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

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

The description states it is a 'pure read' and provides a privacy guarantee, which is sufficient for a non-destructive tool. It does not cover authentication or rate limits, but that is acceptable given the tool's simplicity.

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

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

The description is concise and well-structured with clear sections (main description, returns, USE WHEN, BEHAVIOR, PARAMETERS). Every sentence adds 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 tool's low complexity, the description covers the return values, parameter details, and behavioral aspects. The presence of an output schema further reduces the need to detail return format.

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

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

The only parameter 'hours' is explained with its meaning ('lookback window'), range (1-24), and default (1), adding significant value beyond the bare schema (which had no 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 that the tool returns aggregate keyboard and mouse activity stats over a period, listing specific metrics. While it references a sibling tool for privacy, it does not explicitly distinguish when to use this tool versus get_recent_touch_events.

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 'USE WHEN' section explicitly lists use cases (activity reports, idle detection, fatigue tracking). However, it does not mention when not to use the tool or suggest alternatives.

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

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

No annotations provided, so description carries full burden. States 'pure read of the vocabulary database. No side effects.' which clearly discloses behavioral traits. Also describes return format (one entry per term with fields).

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

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

Extremely concise: first sentence states purpose, second details return, third provides usage guidelines, fourth states behavior. No wasted words. Well-structured with clear sections.

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 zero parameters, no annotations, and presence of an output schema (though not visible), the description fully covers what the agent needs: purpose, return format, usage conditions, and behavior. Complete for a simple list tool.

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

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

Tool has zero parameters, so baseline score is 4 per guidelines. Description does not need to add parameter info, but it does describe the return fields, which adds 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?

Clearly states it lists every term in the user's voice vocabulary with specific details (pronunciations, add-date). Distinguishes itself from siblings like add_to_vocabulary and remove_from_vocabulary by being the read-only counterpart. Additionally, explicitly says 'NOT FOR: searching transcript history — use search_voice.'

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

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

Provides explicit USE WHEN scenarios ('auditing what's been taught, or before adding a term to check for duplicates') and a clear NOT FOR case with an alternative tool reference ('use search_voice'). This gives strong guidance on when 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?

Without annotations, description fully covers behavioral traits: pure read operation, returns zero-valued metrics if no activity, and no 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?

Structured with clear sections, bullet points, and front-loaded summary; 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 output schema exists, description covers return metrics, behavior, and usage completely for a stats 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?

Adds significant meaning beyond schema: specifies lookback window, range (1-720), and default (24) for the 'hours' parameter.

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

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

Clearly states it returns dictation quality stats (WPM, confidence average, correction rate) over a window, and distinguishes itself from siblings like get_recent_voice and search_voice.

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

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

Provides explicit 'USE WHEN' and 'NOT FOR' conditions, naming alternative tools for per-segment data.

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

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

No annotations provided, but description fully covers behavior: declares 'pure read', describes algorithm (TF-IDF + project-keyword scoring), and states no 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?

Well structured with separate sections for output, usage conditions, behavior, and parameters. No extraneous text; 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 output schema exists, description still covers return values. Parameter guidance and behavioral context are fully addressed. Complex classification use case is well specified.

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

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

Schema has 0% description coverage, but description compensates fully: states parameter is required, non-empty, and gives length recommendation (50+ characters for reliability). Adds substantial 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?

Clearly states it scores text against project corpus and returns best-match project with top ID, confidence, and runners-up. Explicitly differentiates from sibling get_active_project by stating NOT FOR detecting current 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?

Provides explicit USE WHEN (routing user's text to right project context) and NOT FOR (detecting current project) with named alternative (get_active_project). Gives clear decision logic.

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

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

No annotations provided, but description explicitly states 'pure read of the project registry. No side effects.' This fully discloses the read-only, non-destructive nature.

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

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

Concise and well-structured with separate sections for purpose, return fields, usage, and behavior. Every sentence adds value with no waste.

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 zero parameters and an output schema, the description fully explains purpose, return fields, usage context, and behavioral characteristics. It is complete for its 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 zero parameters, so description adds no parameter information. Baseline for 0 params is 4, and the description appropriately avoids unnecessary param details.

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

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

Clearly states it lists every project with specified fields (name, slug, overview). Distinguishes from sibling get_project_context by noting it does not provide full content.

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

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

Explicitly provides USE WHEN (project picker, before get_project_context) and NOT FOR (full content, use get_project_context). Directs to a specific sibling tool.

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

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

Discloses destructive side effect, irrecoverability, and idempotence. With no annotations, the description fully covers behavioral traits needed for safe invocation.

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

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

Well-organized into sections with clear headings (USAGE, BEHAVIOR, PARAMETERS). Every sentence adds value; no wasted words.

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

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

Covers purpose, usage, behavior, parameter semantics, and return values (confirmation of deleted key and existence check). For a single-param tool, this is fully complete.

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

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

For the single parameter 'key', the description adds context: 'exact key as passed to memory_store', 'Case-sensitive', and 'Required'. With 0% schema description coverage, this fully compensates.

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 starts with 'Delete a memory entry by exact key', which clearly specifies the action and target. This distinguishes it from sibling tools like memory_store (store) or memory_list (list).

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 'USE WHEN: a stored value is wrong or no longer needed' and 'NOT FOR: clearing all memory', with guidance to loop over memory_list. Provides clear when-to-use and 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?

Declares 'pure read. Sub-millisecond.' which describes behavioral traits. Since no annotations provided, description carries full burden and does so effectively, indicating no 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?

Structured with sections: main purpose, return format, usage guidance, behavior, and parameters. Each sentence is concise and informative. 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 one parameter and existence of output schema, description still provides return format details (key, tag, byte_size, last_updated) and sorting. Covers all necessary context 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?

Explains the single parameter 'tag' with clear semantics: filter by exact tag, omit to list all. Adds meaning beyond the schema which only provides type and nullability.

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 'List' and resource 'stored memory keys'. Distinguishes from siblings by specifying that memory_recall and memory_search are for retrieving values, not this tool. Also notes it returns metadata only.

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 WHEN' and 'NOT FOR' sections with named alternative tools. Provides clear guidance on auditing and bulk-deletion scenarios, and what not to use it for.

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 'pure read' and 'sub-millisecond' performance, notes no timestamp update, and explains the return value behavior (string or 'not found' indicator). No annotations exist, so description fully covers behavioral traits.

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

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

Structured into clear sections (main, USE WHEN, NOT FOR, BEHAVIOR, PARAMETERS) with no extraneous text. Every sentence serves a distinct purpose, front-loaded with core action.

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

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

For a simple key-based recall tool, the description covers purpose, usage, behavior, parameters, and return behavior. With no output schema details needed, it is fully self-contained given the tool's simplicity.

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

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

Despite 0% schema coverage, description includes a dedicated PARAMETERS section explaining 'key' as exact, case-sensitive, required—adding semantics beyond the schema's type/required fields.

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 'Recall the value stored at an exact key'—a specific verb+resource. It distinguishes from siblings by mentioning memory_search and memory_semantic_search for non-exact lookups.

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

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

Provides explicit 'USE WHEN' (after memory_store) and 'NOT FOR' (fuzzy/substring/semantic lookup) with direct sibling names, giving clear when-to-use and when-not-to-use guidance.

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

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

Even though no annotations are provided, the description compensates by disclosing that the tool is a pure read operation, uses SQLite FTS, and has sub-100ms performance. This gives the agent full transparency into 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 well-structured with clear sections, front-loaded with the main purpose, and every sentence adds valuable information without redundancy. It is concise yet comprehensive.

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 and the presence of an output schema, the description is complete: it explains the return format, ranking, and performance characteristics. No additional information is needed for correct invocation.

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

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

The description adds significant meaning beyond the input schema: it explains that query is a substring or FTS expression, must be non-empty, and limit has a range of 1-100 with a default of 20. This helps the agent use parameters correctly.

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

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

The description clearly states it performs full-text substring search over stored memory values and returns ranked entries with key, value, tag, and score. It distinguishes itself from sibling tools by specifying it is for substring search, not exact-key or semantic search.

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

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

The description explicitly tells when to use this tool (when exact key is unknown but substring of value or tag is known) and when not to use it (for exact-key lookup or true semantic similarity), providing alternative tools memory_recall and memory_semantic_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?

Despite no annotations, the description fully discloses behavior: pure read, local embeddings, first-call latency (1-2s), and condition of no results if index not built, with a pointer to memory_stats for build state.

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 yet comprehensive: single paragraph with clear sections for purpose, returns, usage guidance, behavior, and parameters. 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 complexity and the presence of an output schema, the description covers all essential aspects: purpose, usage scenarios, behavioral traits, parameter details, and guidance on related tools. Complete and well-rounded.

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 meaning beyond the schema by explaining query as free-text required non-empty, and limit as max results range 1-50 with default 10. Schema coverage is 0%, so description compensates adequately.

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

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

The description clearly states 'Vector-similarity search over stored memory entries using local embeddings' and specifies returned data (ranked matches, similarity scores, key/value/tag). It differentiates from siblings like memory_recall and memory_search.

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

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

Explicitly provides 'USE WHEN' and 'NOT FOR' sections with named alternatives, including guidance on when not to use (exact-key or substring lookup) and performance comparison (slower than memory_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?

Declares it is a pure read of metadata with no side effects, which is essential given no annotations are present.

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

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

Three concise sentences: purpose, details, use cases, behavior. No unnecessary words, front-loaded with key 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?

Fully covers purpose, usage triggers, behavior, and output summary for a zero-parameter tool with output schema.

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

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

No parameters exist, so schema coverage is 100% by default. Description adds value by listing output fields, compensating for lack of parameter detail.

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

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

Clearly states it returns statistics about the local memory database, specifying entry count, size, tags, embedding state. Distinct from sibling tools like memory_list or memory_semantic_search.

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

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

Explicit 'USE WHEN' clause identifies specific scenarios: troubleshooting missing results from memory_semantic_search or sizing data footprint.

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

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

No annotations provided, but description discloses side effect (overwrite), persistence (survives daemon restart), idempotency, and no auth/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?

Well-structured with sections (USE WHEN, NOT FOR, ALTERNATIVES, BEHAVIOR, PARAMETERS). Every sentence adds value; no fluff.

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

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

With output schema present, description appropriately notes return value (confirmation with key and new/overwrite indication). Covers all necessary aspects for a store operation.

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 lacks descriptions (0% coverage), but description adds crucial details: key max 256 chars ASCII, value max ~1 MB, tag optional grouping label queryable via memory_list(tag=...).

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 'Persist a string value under a key' and distinguishes from siblings like memory_search, memory_semantic_search, and route_to_journal.

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 WHEN' and 'NOT FOR' sections with named alternatives (memory_search, memory_semantic_search, route_to_journal) and guidance on ephemeral vs persistent storage.

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

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

Despite no annotations, the description discloses destructive nature (permanent delete, not recoverable), idempotency (no-op if term doesn't exist), and side effects. Missing details on authorization or rate limits, but sufficient for a simple destructive tool.

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

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

Well-structured with clear sections (USE WHEN, NOT FOR, BEHAVIOR, PARAMETERS). Every sentence adds value, front-loading the purpose. No fluff, compact yet comprehensive.

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 param, destructive action, output schema exists), the description covers all necessary aspects: purpose, usage conditions, behavioral traits, parameter specifics, and return value. Siblings like add_to_vocabulary are implicitly contrasted via the 'not for' guidance.

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

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

With 0% schema description coverage, the description adds key details: parameter is required, case-sensitive, exact spelling needed, and suggests confirming via get_vocabulary first. This goes far beyond the schema's bare 'term' string.

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 'Remove a term from the voice vocabulary', specifying the verb (remove) and resource (term from voice vocabulary). It differentiates from sibling tools like add_to_vocabulary and get_vocabulary by focusing on removal.

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

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

Provides explicit 'USE WHEN' (causing wrong corrections or irrelevant) and 'NOT FOR' (temporarily disabling) guidance, clearly directing when to use this tool and when not to, though no alternative tool is named.

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 side effect (writes to SQLite database), idempotency condition (same content+project pair), and auto-detection behavior. No annotations provided, so description fully compensates.

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

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

Well-structured with labeled sections, but slightly verbose. Every sentence adds value, but 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?

Comprehensive for the tool's complexity: covers usage, behavior, parameters, and references output schema. No gaps for an agent to invoke correctly.

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

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

Adds meaning beyond schema: describes text as 'Required, non-empty' and project_id as 'explicit project slug... Omit to auto-detect.' Schema coverage is 0%, so this is essential.

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

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

Clearly states the tool routes text to a project's journal database, specifies return values (project, journal entry ID, storage location), and distinguishes from siblings via 'ALTERNATIVES' mentioning identify_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?

Provides explicit 'USE WHEN', 'NOT FOR', and 'ALTERNATIVES' sections, giving clear guidance on when to use this tool vs alternatives like identify_project.

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?

Without annotations, the description declares the tool as 'pure read' and mentions that sensitive entries are excluded from the index, referencing get_clipboard_history for details. While this covers key behavioral traits, additional info on performance or pagination would enhance transparency.

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

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

The description is concise with clear section headers (USE WHEN, NOT FOR, BEHAVIOR, PARAMETERS). Every sentence adds value and the total length is appropriate for the tool's complexity.

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

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

Given the output schema exists (though not shown), the description specifies return fields (timestamp, snippet, source application) and covers the key constraint (text-only, sensitive exclusion). For a search tool, this is complete and actionable.

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 0% description coverage, so the description adds critical meaning: query can be a 'substring or FTS expression', is required and non-empty; limit specifies 'max results', range '1-100', and default 20. This goes well beyond the 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?

The description clearly states the tool performs 'Full-text search over the clipboard history' and lists the returned fields (timestamp, snippet, source application). This verb+resource combination distinguishes it from siblings like get_clipboard_history and search_history.

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

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

Provides explicit 'USE WHEN' and 'NOT FOR' sections with examples (e.g., 'find that thing I copied about X', 'did I copy the bug ID'), and clarifies that only text entries are indexed, effectively guiding the agent on appropriate use cases.

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

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

With no annotations, the description fully covers behavior: 'pure read; sub-100 ms for typical buffers. Search is case-insensitive and runs against OCR text only — visual elements without text won't match.' 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 well-structured with sections, each sentence adds value, and it's not overly verbose—efficient and front-loaded.

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

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

Given the tool's complexity and the presence of an output schema, the description covers return fields, ordering, and behavioral constraints, making it fully complete for an AI agent.

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

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

Despite 0% schema coverage, the description adds a dedicated PARAMETERS section explaining each parameter in detail: query as 'substring or simple SQLite FTS expression. Required, non-empty.' and limit with range and default.

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 'Full-text search the OCR history of past screen captures,' specifying the action (search), resource (OCR history), and scope (past screen captures). It also distinguishes from siblings by explicitly naming alternatives.

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

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

The description includes explicit 'USE WHEN' and 'NOT FOR' sections, providing clear guidance on when to use this tool and naming alternative tools for different use cases.

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

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

Despite no annotations, the description fully discloses behavior: pure read operation, substring + FTS search, sub-second response for typical buffers, and asynchronous indexing limitation.

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

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

Extremely concise with clear sections (USE WHEN, NOT FOR, BEHAVIOR, PARAMETERS). Every sentence adds value without redundancy.

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

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

Output schema exists, and description adequately describes return format (matching segments with timestamp, snippet, reference). Covers all needed context: purpose, usage, behavior, parameters.

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

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

With 0% schema description coverage, the description fully compensates by explaining both parameters: query as substring/FTS expression, required non-empty; limit as max results with range and default.

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 full-text search over voice transcription history, with specific verb and resource. Distinguishes from sibling tools like search_clipboard and search_history by focusing on voice 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?

Explicitly provides USE WHEN and NOT FOR conditions, and mentions the limitation regarding very recent audio not being indexed, guiding when to use this tool vs. live transcription or other search tools.

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