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

The description adds context about the tool being 'AI-powered' and lists interaction types, which helps the agent understand it's an autonomous agent. However, it doesn't disclose potential failure modes, session lifecycle, or that the action might be non-deterministic. Since annotations already indicate not read-only, this is acceptable but not detailed.

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

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

The description is exactly two sentences plus a cost note. It front-loads the core purpose and gives a clear usage condition. No wasted words, and the cost is a useful extra signal for the agent's decision-making.

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

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

For a tool with 3 parameters and no output schema, the description covers the essential context: what it does, when to use it, and even cost. It could mention return behavior or limitations, but it is largely complete for selection purposes.

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 url, max_steps, and instruction. The description adds no parameter-specific details beyond what's in the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Perform an action on a web page using AI-powered browser automation.' It enumerates specific action types (click, type, navigate) and 'interact with a page,' which distinguishes it from sibling tools like browser_extract or browser_validate.

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

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

It provides explicit guidance on when to use: 'Use when you need to click, type, navigate, or otherwise interact with a page.' This gives clear context for use, though it does not explicitly mention alternatives that handle extraction or validation, so it falls short of a 5.

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

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

Annotations already indicate a write operation (readOnly=false). The description adds context by specifying the data is stored in a ZeroDB table and mentions the credit cost per URL. It discloses the main side effect (writing rows) and a cost metric, which is valuable beyond the annotations. Minor gaps remain (e.g., failure behavior), but it is not contradictory.

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

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

The description is two sentences, front-loaded with the core action and purpose, and includes the cost in a compact parenthetical. Every sentence earns its place with no redundant information.

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

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

The tool involves multiple URLs, storage to a table, and has no output schema. The description covers the core workflow, cost, and usage context. It does not describe return values or error semantics, but for a batch extraction-to-table tool this may be less critical. Overall, it is sufficiently complete for a 4-parameter tool with 100% schema coverage.

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 all parameters are documented in the schema. The description restates the URL limit ('up to 10 URLs' matching maxItems) and mentions 'store rows' for table_name, but adds no new semantic detail beyond the schema. Baseline 3 is appropriate.

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

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

The description uses a specific verb 'Extract' with a clear resource ('structured data from up to 10 URLs') and a destination ('store rows in a ZeroDB table'). It differentiates from siblings by emphasizing the batch capability ('up to 10 URLs in a single call') and naming 'multiple pages at once.'

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 an explicit usage condition: 'Use when you need to scrape multiple pages at once.' This gives clear context, though it does not explicitly name alternatives or exclusions. It effectively tells the agent when this tool is appropriate.

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

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

Annotations already disclose that this is a non-read-only, non-destructive, open-world operation. The description adds the 'store in agent memory' behavior and the 100-credit cost, which is useful context. However, it doesn't go deeper into failure handling or idempotency implications, and it doesn't contradict the 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?

The description is two sentences, front-loaded with the action, and includes a concise credit-cost note. It conveys purpose, context, and cost without unnecessary detail, earning a perfect score.

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

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

The tool has a simple interface, comprehensive schema, and supporting annotations. The description covers the essential use case and cost, though it does not mention the async sibling or return behavior. For its complexity, it is adequately complete.

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

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

Schema description coverage is 100% for all four parameters, so the schema carries the burden of documenting url, project_id, memory_type, and extract_goal. The description adds no extra parameter-level information, justifying the baseline score 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 what the tool does: 'Extract content from a web page and store it in agent memory (ZeroDB).' It uses a specific verb and names the resource. It does not explicitly differentiate from sibling tools like browser_extract or browser_enrich_memory_async, so it doesn't achieve a 5.

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 a clear usage context: 'Use when you want an agent to "remember" information from a URL for future recall.' This tells when to use the tool, but it does not mention alternatives or when not to use it, such as when extraction without persistence is needed (browser_extract).

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 adds behavioral context beyond annotations: it reveals the async queueing behavior, immediate task_id return, background URL visit, and a 100-credit cost. This complements the annotations (readOnlyHint=false, openWorldHint=true) without contradicting them, though it doesn't discuss failure modes or task tracking.

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

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

The description is two sentences, front-loads the core action ('Queue an async browser memory enrichment task'), and every clause adds useful information (task_id, background, ZeroMemory, credits). No wasted words.

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

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

Given the async nature and no output schema, the description appropriately highlights the immediate task_id return and background processing. It lacks details on how to track task completion or handle errors, but for a simple queue operation, the core flow is adequately covered. Sibling tools may fill the tracking gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add meaningful detail about parameters beyond referencing URL and ZeroMemory store; it doesn't explain memory_type or extract_goal. It adds minimal value over the schema.

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

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

The description clearly states the tool queues an async browser memory enrichment task, returns a task_id immediately, and stores content in ZeroMemory in the background. The 'async' and 'background' wording distinguishes it from the likely synchronous sibling browser_enrich_memory.

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 non-blocking enrichment by mentioning immediate task_id return and background execution. However, it does not explicitly state when to use this over sibling tools like browser_enrich_memory or browser_extract, but the async nature is a clear contextual signal.

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 declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is known. The description adds the behavioral detail that it returns structured JSON, but it does not mention potential limitations such as dynamic content or authentication requirements. Given the annotations, this is adequate but not exceptional.

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

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

The description is two concise sentences, front-loading the purpose and usage. The credit note '(75 credits)' is minor but does not detract. No fluff or redundancy.

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

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

For a simple 2-parameter tool with rich annotations, the description covers purpose, usage, and output format. However, it does not mention that this tool handles a single URL per call (given the existence of browser_batch_extract) or address dynamic content, which would enhance completeness. Still, the core information is present.

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

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

Schema coverage is 100%: both parameters have descriptions. The description's mention of 'specific information' aligns with extract_goal but adds no additional meaning beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool extracts structured data from a web page using specific verbs like 'extract', 'scrape', and 'parse'. It also specifies the output as structured JSON. However, it does not distinguish this tool from sibling tools like browser_extract_to_table or browser_batch_extract, so it lacks sibling 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 explicitly says to use the tool when needing to scrape, parse, or retrieve specific information from a URL, providing clear usage context. It does not mention alternatives or when not to use it, but the given context is sufficient for basic 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?

Annotations already indicate readOnlyHint=false and idempotentHint=false, so the description adds the cost factor '(100 credits)' and emphasizes that data is stored directly. However, it does not disclose whether the table must pre-exist, whether rows are appended or replaced, or any potential side effects beyond storing. The cost disclosure adds some value, but more behavioral detail would improve 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 two concise sentences plus a parenthetical cost note, with no redundant information. It front-loads the core action and then states the intended use case, making it easy to parse quickly.

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

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

The tool has four required parameters and no output schema, and the description covers its purpose and use case succinctly. It does not explain the return value or error scenarios, but for a simple persistence tool, the given information is largely sufficient. The inclusion of cost and persist-for-later-analysis adds useful 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?

The input schema covers all four parameters with descriptions, and the tool description does not add extra meaning beyond what the schema already provides. Since schema coverage is 100%, the baseline of 3 is appropriate; the description's mention of 'extract structured data' aligns with the parameters but does not elaborate further.

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

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

The description clearly states the tool extracts structured data from a web page and stores it in a ZeroDB NoSQL table, distinguishing it from sibling tools like browser_extract that likely only extract without persisting. The verb 'extract' and resource 'web page' plus the specific outcome 'store it directly in a ZeroDB NoSQL table' provide a precise 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?

The description explicitly says 'Use when you need to scrape data and persist it for later querying or analysis,' providing a clear context for when to invoke this tool. It does not mention alternatives or when not to use it, but the use case is specific enough to differentiate from siblings like browser_extract.

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 declare readOnly=false, openWorld=true, idempotent=false, destructive=false. The description adds the resource cost (200 credits) and emphasizes complexity, but does not disclose further behavioral traits like error handling or side effects. With annotations covering core safety, a 3 is appropriate.

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

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

The description is extremely concise: two sentences plus a parenthetical cost note. It front-loads the purpose, then usage guidance, alternative, and cost. Every element is essential and non-redundant.

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, the description provides complete context: purpose, use case, differentiation from siblings, and resource cost. No output schema exists, and the description adequately covers what an agent needs to select and invoke the tool correctly.

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

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

The input schema provides 100% coverage for all three parameters (url, max_steps, task_description). The description does not add any parameter-level information beyond schema, so it meets the baseline without enhancement.

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

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

The description clearly states the tool's function: 'Run a multi-step browser automation task.' It differentiates from sibling 'browser_act' by explicitly saying 'More capable than browser_act for complex flows,' providing a specific verb+resource+scope.

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

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

The description explicitly instructs when to use it: 'Use when you need to perform a complex, multi-step workflow on a web page.' It gives an example and names an alternative (browser_act) for simpler tasks, making the usage context and exclusion 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 already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds purpose and examples but does not disclose behavioral details like what happens when validation fails or the return format. This is adequate but not rich.

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

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

The description is two concise sentences with no fluff. It includes the credit cost and relevant usage context, earning its place for each word.

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, complete parameter documentation, and strong annotations, the description is mostly sufficient. However, the absence of an output schema means the description should ideally indicate the result type (e.g., boolean pass/fail), which it does not, so a small gap remains.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds examples of assertions but does not provide additional parameter-level nuance beyond what the schema states, meeting 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 uses a specific verb 'validate' and resource 'web page', and provides concrete examples like 'assert that specific content exists, a form was submitted'. This clearly distinguishes it from sibling tools like browser_act or browser_extract.

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

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

The description explicitly states when to use it: 'Use when you need to assert that specific content exists, a form was submitted, or a page reached an expected state.' However, it does not mention when not to use it or name alternative tools, so it falls just short of a 5.

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