WebRun Browser Automation

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

Discloses that it creates a session, runs the task, and auto-terminates, and warns about side effects on third-party websites. Annotations already cover destructive and openWorld hints, but the description adds context about session lifecycle and behavioral differences from workflows.

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 and front-loaded: starts with core action, then lifecycle, then usage guidance and exclusion. Every sentence contributes value, with no filler 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?

Given the tool's complexity (15 params, nested objects, output schema) and rich schema, the description covers the key usage context and lifecycle. It could explicitly state the return format, but that is partially addressed by outputType/outputSchema parameters and sibling tools for status.

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

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

Schema coverage is 100%, so all 15 parameters have detailed descriptions in the schema. The tool description itself does not add additional parameter-specific details beyond the schema, which is the baseline for high coverage.

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 executes browser automation tasks in a real Chrome browser via WebRun, and explicitly differentiates from trigger_workflow. The verb 'execute' plus resource 'browser task' is specific and 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?

Explicitly states it is best for one-off tasks not covered by workflows, and explicitly warns against using it for saved workflows, naming trigger_workflow as the alternative. Also clarifies that phrases like 'run it' about a workflow should route to trigger_workflow.

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

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

The description discloses significant behavioral traits beyond the annotations: the platform copies workflow settings, bakes variables into the prompt, results are delivered to the connected chat and session history, memory is automatically updated, and the schedule timezone also drives the browser session. It also warns about proxy country mismatch causing login issues. These details are not present in the annotations and greatly enhance 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?

The description is long but well-structured, with clear sections for modes and parameter-specific guidance. Every sentence contributes value, and the organization makes the complexity navigable. It is appropriately detailed for a tool this complex, though a slightly more compact format could be imagined.

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 (12 parameters, nested objects, two modes), the description is remarkably complete. It covers the core behavior, user interaction guidelines, prompt construction, proxy nuances, memory rules, and output delivery. The presence of an output schema and comprehensive parameter descriptions further bolster completeness. Nothing essential is missing.

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?

Although schema_description_coverage is 100%, the description adds substantial meaning beyond the schema. For example, it explains how to structure a prompt as a browsing runbook (Goal, Ground rules, Stages, Output), provides rules for memory seeding, clarifies proxy modes and country recommendations, and specifies when variables are required. This goes far beyond what the schema descriptions offer.

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 creates a scheduled agent, a recurring or one-time automation running in a real Chrome browser. It explicitly distinguishes two modes (workflow mode and standalone mode), which differentiates it from sibling tools like create_workflow and list_agents. The verb and resource are specific and 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?

The description provides explicit guidance on when to use each mode: use workflowId to deploy a workflow, or omit it for standalone. It also instructs the agent on how to interact with the user ('Ask the user only what it should do and when it should run'), what to avoid (never ask about environments or technical settings), and even details proxy country recommendations for social/messaging workflows. This is comprehensive and actionable.

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

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

The description adds context beyond annotations by warning that with an initial task the browser may act on third-party websites immediately, and by noting the behavioral difference from workflows. It does not cover session lifecycle or authentication, but the openWorld and destructive flags are complemented by this concrete side-effect warning.

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-loading the core purpose and the critical workflow exclusion. Every sentence earns its place, and there is 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 complex tool with 9 parameters and an output schema, the description covers the essential decision points: what it does, what it returns, its side effects, and when not to use it. It does not detail session management (e.g., using terminate_session), but the rich schema and output schema fill in the rest, making this sufficiently 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 coverage is 100%, so all 9 parameters are described in the input schema, including nested objects like proxy and task. The description does not add parameter-level semantics beyond the schema; it only mentions the sessionId return value, which is an output, not a parameter. A baseline 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 creates a persistent Chrome browser session for multi-step interactive work in a WebRun environment, and explicitly contrasts it with trigger_workflow. The verb 'Create' and specific resource 'persistent session' are precise, and the exclusion of workflows distinguishes it from the most likely sibling.

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 gives an explicit when-not-to-use instruction: 'Do NOT use this to run or test a saved workflow' and names the alternative trigger_workflow, explaining why (workflow carries its own rules, tracking, and memory). This is clear, actionable 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?

With minimal annotations (only readOnlyHint=false, etc.), the description carries the full behavioral burden and does so thoroughly. It discloses that the workflow does not execute on a schedule until deployed via create_agent, that memory tracking is wired by the platform (never write memory steps into the prompt), and that the prompt must be written as a browsing runbook following a specific structure. It also explains the readiness bar and that custom proxy passwords are encrypted and never returned. No contradiction with annotations.

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

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

Though lengthy, the description is dense and every section earns its place. It is front-loaded with the core purpose and readiness bar, then systematically addresses requirements, prompt authoring, memory, environment, variables, scheduling, and testing. The organization is logical and skimmable, with clear imperative guidance (e.g., 'omit environmentId and never ask the user to choose one') that prevents ambiguity.

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 38 parameters and nested objects, the description is remarkably complete. It covers all critical decision points: readiness assessment, required fields, prompt structure, memoryContract requirements, environment handling, variable usage, schedule limitations, and the correct way to test (trigger_workflow). The presence of an output schema means return values are already defined elsewhere, so the description need not explain them. Nothing an agent needs to call this tool correctly is missing.

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 substantial meaning beyond the schema, which already has 100% coverage. It explains the purpose and proper usage of memoryContract (groundRules, memoryInstruction, itemIdentity) and when it is required, details how to structure promptTemplate (Goal / Ground rules / Stages / Output), clarifies when to use {{variables}} only for explicit reusable templates, and explains that environmentId is usually omitted. It also elaborates on proxy country selection for social workflows, which the schema mentions but the description gives actionable guidance on.

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 opens with a clear, specific statement: 'Create a new saved workflow.' It further differentiates from siblings by explicitly stating that to run or TEST the workflow, use trigger_workflow ONLY — never browser_task or create_session, and that scheduling does not run until deployed via create_agent. This precisely scopes the tool's 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 gives explicit when-to-use and when-not-to-use guidance: it instructs to first collect missing business facts if the task is not ready, states that environmentId should be omitted and never asked for, and requires memoryContract for tasks handling each item once. It also directs that the workflow is created in the connection's environment automatically and that schedule is only a setting — the workflow does not run until deployed. This is comprehensive and unambiguous.

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 include readOnlyHint=true and idempotentHint=true, which the description reinforces with 'Read-only: reports on the task without affecting it.' The description adds behavioral nuance by mentioning 'poll for completion' and 'detect guardrails,' which are not in the annotations. It does not contradict the annotations and adds useful context beyond what structured fields 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?

The description is two sentences with no filler. It front-loads the core purpose and then adds the primary use cases and read-only nature. Every sentence contributes value, and it is appropriately sized for a simple polling tool.

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

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

Given the presence of an output schema (which documents return values), the low complexity, and straightforward parameters, the description is complete. It covers the purpose, usage context, and read-only nature. An agent has everything needed to decide when to call this tool and what to expect.

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

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

The input schema covers 100% of the parameters with descriptions for both taskId and sessionId. The tool description does not add any parameter-specific details beyond the schema, so the baseline score of 3 applies. It neither enhances nor detracts from the schema's clarity.

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

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

The description states a specific verb ('Check'), a clear resource ('status of a task'), and adds context ('previously started in a browser session'). It also signals the two main uses (poll for completion, detect guardrails), which clearly distinguishes it from action-oriented siblings like pause_session_task or stop_session_task. The purpose is unmistakable.

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 the tool: 'Use to poll for completion or detect guardrails.' It does not explicitly name alternatives or say when not to use it, but given the sibling list, no other tool serves this status-checking function. The guidance is clear enough for an agent to select this tool over mutating actions.

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 and idempotentHint. The description adds useful behavioral context by noting 'Read-only; proxy credentials are masked' and mentioning 'pending logins,' which go beyond the annotations. No contradictions 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?

The description is a single, coherent sentence front-loaded with the tool's purpose, followed by a short identification note and a safety note. Each phrase adds value with no redundancy or 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 read-only tool with an output schema and good annotations, the description enumerates the key data fields and identification parameters. It lacks an explicit statement that at least one identifier is required, but this is implied by 'Identify by workflowId or exact title,' making it almost 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 descriptions already cover 100% of parameters, including that each is an alternative to the other. The description merely reinforces this with 'Identify by workflowId or exact title,' adding no new semantic detail beyond the schema, so baseline 3 is appropriate.

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

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

The description states the tool retrieves full detail of exactly one workflow, listing specific contents (prompt template, variables, trigger, settings, etc.). This clearly distinguishes it from sibling tools like list_workflows by focusing on a single workflow.

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

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

The description implies usage by providing identification methods ('Identify by workflowId or exact title') and lists what data is returned, giving clear context for when to use it. However, it does not explicitly compare to alternatives or state when not to use this tool, 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?

The description adds meaningful behavioral context by stating that the response is handed to the live agent, which continues acting on it. This explains the downstream effect beyond what annotations supply. Annotations already indicate mutating/non-read-only behavior, so the description does not need to repeat that.

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 with no filler. It front-loads the core action ('Respond to a guardrail trigger'), then gives the trigger context and the key behavioral detail about the live agent.

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

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

The description is complete for a tool with a rich schema and annotations. It covers purpose, trigger context, and the handoff behavior; the schema covers parameters and output, while annotations cover safety and mutability. Nothing essential is missing.

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 explains all four parameters in detail. The description does not add parameter-level semantics, but given the full schema coverage, 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 uses a specific verb and resource: 'Respond to a guardrail trigger when the browser agent needs human input.' It clearly identifies the tool's role and differentiates it from sibling tools because none of the sibling names mention guardrail triggers, and the human-input context is explicit.

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 clearly states when to use the tool: when the browser agent needs human input such as credentials, clarification, or approval. It does not explicitly name alternatives or when not to use it, but the guardrail-trigger context is specific enough to guide 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 annotations already declare readOnlyHint and idempotentHint, and the description adds 'Read-only' to confirm. It also explains what data the tool returns (schedule, status, run times, deployment type) and the scope behavior, which goes beyond the s chema. No contradictions found.

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 primary function, then adding the key scope nuance and a read-only note. Every sentence contributes 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?

For a simple read-only tool with one optional parameter and an output schema, the description covers all essential aspects: what is listed, what fields are returned, how scope works, and the safety profile. It is fully sufficient for an agent 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 schema provides a complete description of the scope parameter with 100% coverage. The description essentially restates the same scope information without adding new semantic details. Thus, 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 lists the account's scheduled agents (cron deployments) and enumerates the exact information returned (schedule, status, next/last run, standalone/deployed from workflow). It distinguishes itself from sibling tools like list_workflows and list_environments by focusing on agents.

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 clarifies when to use this tool by explaining the scope parameter: it is scoped to the bound environment unless scope 'all' is passed. This gives clear context for how to invoke it, though it does not explicitly name 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?

Annotations already declare readOnlyHint and idempotentHint, and the description reinforces with 'Read-only'. It adds useful behavioral context about automatic environment usage for workflows/agents and the tool's role in returning environment IDs, going beyond what annotations convey.

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

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

Two sentences with front-loaded action and purpose; the note about workflows/agents is succinct and valuable.

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 is present so return values are covered; no parameters; description provides sufficient usage context and alternatives. It fully addresses 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 exist, so schema coverage is complete. Description does not need to explain parameters, and the baseline for zero-param tools is met.

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 uses specific verb 'List' with resource 'available browser environments' and clarifies it provides environment IDs for persistent sessions. It clearly distinguishes from sibling tools by noting workflows/agents use the connection's environment automatically.

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 the tool is needed (persistent sessions via browser_task or create_session) and when it isn't (workflows/agents), including instruction not to ask users to choose an environment. This provides clear alternative 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?

Beyond the annotations, the description adds that only 'active' sessions are returned and scopes to 'this account'. It also repeats 'Read-only' which matches readOnlyHint, adding no contradiction but duplicating annotation info.

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?

A single, information-dense sentence that covers purpose, scope, and safety with 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?

The tool is simple with no params, and an output schema exists. The description fully covers the tool's purpose and scope; nothing more is needed for an agent to invoke it 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 tool has zero parameters, so the schema is fully covered. The description adds no parameter information, but none is needed; baseline 4 is appropriate for no-param tools.

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 ('List') and identifies the exact resource ('active browser sessions') with scope ('for this account'). It clearly distinguishes this tool from siblings like list_environments and session lifecycle tools.

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

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

Clear context is provided: use this to list all active sessions. However, no explicit exclusions or alternatives are named, though the sibling tool names imply its role.

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 and idempotentHint, and the description adds useful behavioral context: it documents what fields are included in the output (title, schedule, variables, run stats) and clarifies the environment-scoping behavior. It does not contradict the annotations; it reinforces 'Read-only' consistency.

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 short sentences deliver a complete description without unnecessary words. The tool's purpose, output content, and scope nuance are packed efficiently, and every sentence earns its place.

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

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

For a simple list tool with one optional parameter and an existing output schema, the description covers the core purpose, the returned fields, the scope semantics, and its read-only nature. Nothing important is missing for the assumed complexity level.

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

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

The schema already fully documents the only parameter 'scope' with an enum and explanation (100% coverage). The description adds semantic nuance about the default behavior when a connection is bound to an environment, which enriches the schema description and helps the agent choose the correct value.

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

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

The description clearly states the verb 'List' and the resource 'the user's saved workflows', with an added definition of workflows as 'prompt-templated browser automations'. It further specifies what is shown (title, schedule, variables, run stats), which distinguishes it from sibling tools like get_workflow (single workflow) or trigger_workflow (execute/run).

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

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

The description provides clear context on when to use the tool by explaining the environment scoping and the scope parameter values ('environment' default vs 'all'). It does not explicitly name alternative tools or state when not to use it, but the context is sufficient for a simple read-only reporter.

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 convey destructiveHint and readOnlyHint, so the bar is lower. The description adds useful behavioral context: the agent stops firing until resumed, and the tool is for active agents. It could further disclose edge cases (e.g., already paused agents), but the added behavior description earns credit beyond 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 tight sentences, front-loaded with the core action, and every piece of information (pause, stops firing, resume, agentId source) earns its place. 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?

For a simple one-parameter tool with an output schema and clear annotations, the description covers the essentials: purpose, effect, and how to obtain the required ID. It doesn't describe error conditions (e.g., invalid or already-paused agents), but these are not critical for a standard pause operation and the output schema likely covers result details.

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% as the single parameter agentId is fully described in the schema, including its format and source. The description's note to 'Get agentId from list_agents' adds little beyond the schema, which already mentions list_agents. Baseline 3 is appropriate.

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

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

The description clearly states the action: 'Pause an active scheduled agent' with a specific verb and resource, and distinguishes it from siblings like resume_agent and pause_session_task by specifying 'scheduled agent' and the behavior 'stops firing until resumed.'

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 gives clear context (use on active scheduled agents) and even tells where to get the agentId from list_agents. It does not explicitly mention alternatives or exclusions, but the phrase 'until resumed' implicitly points to resume_agent as the complementary operation.

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

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

The description discloses that the task must be 'currently running' and that it can be 'resume[d] later', adding reversible-behavior context beyond the annotations' readOnly, idempotent, and destructive hints. It does not elaborate on side effects or failure modes, but the annotations already cover basic safety 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?

The description is two sentences, front-loaded with the action, and contains no filler words. Every word earns its place.

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

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

This is a simple one-parameter tool with an output schema present (so no need to explain return values). The description covers the core behavior, the resume path, and the session scoping. It could mention permanent alternatives like stop/terminate, but given the sibling list, the context is reasonably 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?

The input schema provides 100% coverage for sessionId with a description ('Session ID'), so the baseline is 3. The tool description adds no extra meaning about the parameter or how to obtain it, but it is not required given the schema coverage.

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

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

The description clearly states the action ('Pause'), the resource ('task currently running in a browser session'), and differentiates from siblings by naming the complementary tool 'resume_session_task' for resuming later. This makes the tool's purpose 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?

The description says to resume later with resume_session_task, which implies when to use this tool and points to an alternative. It does not explicitly state when not to use it (e.g., for permanent stopping with stop_session_task), so it misses the full when/when-not 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 annotations already declare destructiveHint=true, the description adds valuable behavioral context: it recomputes next run, reactivates, restarts with a full pass for completed agents, and refuses if expiration has passed. This goes well beyond the structured annotations and helps the agent anticipate side effects and failure conditions.

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

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

The description is three sentences, front-loaded with the primary action, and every sentence adds distinct information: main action, special-case behavior, and failure condition. 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?

With a single parameter, an output schema, and clear behavioral descriptions covering normal, special-case, and refusal scenarios, the description is complete for the tool's complexity. The inclusion of the expiry edge case and fresh-pass behavior leaves no major 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 100% for the single parameter agentId, and the schema already provides a description ('24-hex agent id (from list_agents)'). The tool description does not add new parameter-level semantics, so the 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 names a specific verb ('Resume') and resource ('scheduled agent'), explains the core behavior ('recomputes its next run and reactivates it'), and distinguishes from sibling tools like resume_session_task by specifying 'scheduled agent' rather than session task. The additional detail about completed work-list agents further clarifies the specific use case.

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 clearly implies when to use the tool (for paused scheduled agents) and describes a special case (completed work-list agents). It also provides a precondition for use (expiry not passed) and a workaround ('extend it on the dashboard first'). However, it does not explicitly compare against alternatives like resume_session_task, though the 'scheduled agent' wording provides implicit differentiation.

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

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

Annotations are provided (readOnlyHint=false, destructiveHint=true, idempotentHint=true, openWorldHint=true), so the safety profile is known. The description adds the precondition that the task must be previously paused, which is a meaningful constraint not in the annotations. However, it does not disclose other behavioral aspects like what happens on resume (e.g., continuation point, side effects) beyond 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 a single concise sentence, front-loaded with the action. It contains no fluff or redundant information, earning its place with the key detail that the task is previously paused.

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 parameter, output schema exists), the description is reasonably complete. However, it lacks usage context and does not explain the implications of the destructiveHint annotation. The 'previously paused' precondition is helpful, but the description does not describe the lifecycle or relationship to sibling session tools, leaving some contextual 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 100% for the single parameter 'sessionId', which is described as 'Session ID'. The description does not add any additional meaning or format details beyond the schema. Baseline of 3 applies because the schema handles the parameter documentation 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 the action ('resume') and the resource ('previously paused task in a browser session'). It distinguishes this from siblings like pause_session_task, stop_session_task, and terminate_session by specifying that it acts on a paused task. The verb and resource are specific and 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention that it should be used after pause_session_task, nor does it exclude cases like already-running tasks. Without this context, an agent may not know the appropriate usage 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?

The description adds value beyond annotations by specifying the return format ('as an inline image'), which the schema does not explain. The 'Read-only' statement aligns with the readOnlyHint, and no contradictions exist.

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

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

Two sentences, front-loaded with the core action, and zero filler. Every word earns its place, and even the redundant 'Read-only' is short and reinforces the annotation.

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

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

The description is complete for a simple tool: it states the action, the context requirement, and the return format. With an output schema present, the tool doesn't need to spell out the full response structure. Minor details like full-page vs. viewport capture are not essential.

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

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

Schema coverage is 100%, so baseline is 3. The description adds contextual meaning to sessionId by specifying it must be an active session, which goes beyond the simple 'Session ID' schema 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 states a specific action ('Capture a screenshot'), a specific resource ('current browser page'), and a condition ('in an active session'). This clearly distinguishes it from sibling tools like list_sessions or browser_task, which have different purposes.

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 phrase 'in an active session' clearly indicates that a pre-existing, active session is required, implying a prerequisite of creating a session first. There are no competing screenshot tools, so no exclusions are needed, but it doesn't explicitly outline when not to use it.

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?

It adds concrete behavioral disclosure beyond the annotations: 'The real Chrome browser may navigate, fill forms, and submit data on third-party websites as the task requires.' This warns the agent about real-world side effects and aligns with openWorldHint and destructiveHint.

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 purposeful sentences: the first states the operation and prerequisite, the second warns about real-world behavior. 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?

For a tool with 12 parameters, full schema coverage, an output schema, and safety annotations, the description provides enough context for selection and invocation. It could mention asynchronous behavior, but the sibling get_task_status and output schema reduce that 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 parameter descriptions already carry the meaning. The text adds no new parameter details beyond the session prerequisite, so the baseline 3 applies.

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

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

The description states a clear action ('send a new task') and target ('existing browser session'), and references create_session as the prerequisite. It does not explicitly differentiate from sibling tools like browser_task, but 'new task to an existing session' is reasonably specific.

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 clearly implies when to use it: after create_session, to add a task to that session. It gives the prerequisite context but does not name alternatives or exclusions such as using browser_task for standalone tasks.

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 destructiveHint and idempotentHint, lowering the burden on the description. The description adds valuable context beyond annotations by specifying that the session stays alive, which is a key behavioral trait differentiating it from more destructive operations.

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

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

The description is a single, concise sentence that immediately states the action and its outcome. No wasted words or 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?

Given the tool's simplicity, one parameter, strong annotations, and presence of an output schema, the description sufficiently covers what the tool does. It doesn't explain return values, but the output schema exists, so that's not required. Minor gap: no mention of behavior if no task is running, but overall adequate.

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

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

Schema coverage is 100% with 'sessionId' documented as 'Session ID'. The description adds only the context that the session is a browser session, which is slightly more specific but not substantially beyond the schema. Baseline 3 is appropriate as the schema carries the parameter meaning.

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 ('Cancel') and clearly identifies the resource (the task running in a browser session). It distinguishes itself from sibling tools like pause_session_task and terminate_session by explicitly stating that the session is kept alive, making its purpose 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?

The description provides a clear context for use (when you want to cancel the current task without ending the session). It implicitly contrasts with terminate_session by noting the session remains alive, but it does not explicitly list alternative tools or state when not 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?

Annotations already declare destructiveHint=true and idempotentHint=true, but the description adds meaningful context by stating the session and any running task cannot be resumed, and that resources are freed. This goes beyond the structured metadata and helps the agent understand the full impact of the action.

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

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

The description is concise and front-loaded, using two sentences to state the action and its consequence. Every word earns its place, with no unnecessary detail or repetition of the title.

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 is simple with one parameter and an output schema, so the description covers the essential information: what it does and a critical behavioral caveat. It does not explain return values (unnecessary given the output schema) or prerequisites, but for this complexity level, it is sufficiently 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?

The input schema fully describes the only parameter (sessionId) with 100% coverage, so the description need not add more. The description does not elaborate on the parameter, but the schema is already clear, making the baseline 3 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 with a specific verb ('End a browser session') and resource, and adds the key detail that it frees resources. It distinguishes itself from similar sibling tools like pause_session_task or stop_session_task by emphasizing the finality and non-resumability of the 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?

The description implies when to use the tool (to end a session permanently) and even notes that the session cannot be resumed, which is a clear contextual hint. However, it does not explicitly mention alternatives or provide when-not-to-use guidance, leaving some ambiguity compared to sibling tools that might pause or stop tasks.

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?

Beyond the annotations, the description discloses concrete real-world side effects: "Drives a real Chrome browser: the run may navigate, fill forms, and submit data on third-party websites." It also clarifies that the run carries workflow rules, tracking, and memory, adding meaningful behavioral context that annotations alone do not 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?

The description is front-loaded with the core purpose, then layers usage guidance, behavioral disclosure, parameter direction, and return-value handling in a logical order. All sentences earn their place; there is no filler.

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 a destructiveHint and openWorldHint, the description covers purpose, when to use it, what happens during execution, how to pass variables, and how to obtain results. Nothing essential is missing when combined with the rich 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?

Schema description coverage is 100%, so the input schema already documents all four parameters in detail. The description mostly repeats the variables semantics already present in the schema, adding no significant new parameter-level information beyond emphasizing variable defaults.

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 a specific verb and resource: "Run a workflow now in its deployed environment." It explicitly distinguishes itself from browser_task/create_session as the only correct way to run or test a saved workflow, naming sibling alternatives directly.

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 when-to-use guidance: "When the user says 'run it', 'run it once', 'test it' or 'try it' about a workflow, this is the tool they mean." It also names alternatives not to use (browser_task/create_session) and describes the post-call flow via get_task_status.

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 is transparent about side effects: object/array fields are replaced whole, null clears optional fields, proxy passwords are encrypted at rest and never returned, and the schedule is record-only until deployed as a scheduled agent. This goes well beyond the annotation's destructiveHint.

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 long but well-structured, using paragraphs, bullet lists, and inline examples to pack a lot of information without redundancy. It earns every sentence for a tool with 39 parameters and nested contracts.

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?

It is fully self-contained for a complex update operation: it explains what changes, how partial updates work, the exceptions, and the precise meaning of each field. Nothing needed to call it correctly is missing.

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?

Every one of the 39 parameters is described with semantics beyond the schema type, including constraints, examples, and guidance (e.g. memory's 'seed ONLY with durable facts', promptTemplate's runbook structure, proxy's country rule). The description adds meaning the schema alone does not convey.

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 opens with the clear verb-object pair 'Update an existing workflow' and immediately explains the partial-update model (supply workflowId plus only the fields to change). This makes the purpose unmistakable.

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 concrete usage guidance: supply only changed fields, pass null to clear optional fields, notes that schedule is record-only and that renaming via title keeps the slug stable. It also explains the memoryContract exception and the proxy country requirement, so an agent knows how and when to use it.

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