Jsonify

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

Annotations already declare the safety profile as read-only, idempotent, non-destructive, and closed-world. The description adds some context about shared database page limits and structured-result byte budgets, but those constraints remain vague and are not actionable.

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?

It is a single front-loaded sentence with no wasted text. The phrasing around 'rich table page' and 'structured-result byte budgets' is compact but somewhat jargon-heavy.

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?

Although an output schema exists and annotations cover the safety profile, a nine-parameter browsing tool needs more guidance on parameter meaning and alternatives. The description leaves too much to inference 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?

Schema description coverage is 0% across nine parameters, so the description carries the full burden. It vaguely mentions pagination, search, and sorting, but does not explain dataset_id, workspace_id, table, version, page_size, or sort_dir 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?

The description states a specific verb and resource: reading one rich table page with search and sorting. It is clear enough to distinguish row browsing from broader dataset tooling, but it does not explicitly contrast itself with siblings like query_dataset or export_dataset.

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 paginated, searchable nature implies when to use it for browsing rows, but there is no explicit guidance on when to choose this over query_dataset, get_dataset_view, or export_dataset. The usage context is implied rather than stated.

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?

Goes well beyond the annotations (destructiveHint=true, idempotentHint=true) by explaining that unfinished candidate work may be discarded, that retrying does not resume the input, that completed changes are not undone, and that access to the conversation is required. This is exactly the behavioral context an agent needs before a destructive, idempotent call.

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 dense sentences, each carrying distinct load: action and trigger first, consequences second, prerequisites and idempotency last. No filler or 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?

For a destructive, idempotent mutation with an output schema already documenting return values, the description covers consequences, reversibility and auth prerequisites well. The remaining gap is parameter documentation, which is entirely absent for a four-parameter 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?

Schema description coverage is 0% across four parameters, including a non-obvious 'preparation_token' with a 70-character minimum, and the description explains none of them. The phrase 'the specified ... work input' only faintly hints at input_id; session_id, workspace_id and preparation_token are left entirely to inference.

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?

States a specific verb (interrupt/cancel) and a precisely scoped resource: the specified queued or running work input. The scope qualifier ('queued or running') distinguishes it from siblings like request_work or start_preparation without ambiguity.

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

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

Gives an explicit trigger ('when the user asks to stop it') and clear exclusions ('does not undo completed changes or stop unrelated production runs'). It stops short of naming an alternative sibling tool for adjacent needs, so it is strong but not fully routing-aware.

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 non-read-only, idempotent, non-destructive, closed-world, but the description adds real substance beyond them: an entire snapshot is copied without fresh collection or row charges, 100 free rows remain, schedules start disabled, and reuse of the idempotency key returns the same workspace. The one gap is that 'directory publication authorizes copying linked datasets in the source workspace' is stated without explaining what happens if the source is not published.

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 core action and its destination land in the first sentence, with eligibility, idempotency and return values following in a logical order. It is dense and longer than typical, with a few clauses (e.g. the future run_pipeline estimate flow) that are useful but sit at the tail rather than being essential to invocation.

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 two-required-parameter mutation with an output schema present, the description covers every decision point an agent needs: auth prerequisite, eligibility, idempotent retry behavior, what is and is not copied, and the immediate follow-up tools. Return value internals are handled by the output schema, so nothing material 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 coverage is 0%, so the description must carry the load — and it does: dataset_id is clarified as the source dataset's public ID and idempotency_key as a new UUID whose reuse on retry yields the same workspace. It stops short of documenting the 128-char cap on dataset_id or the strict 36-char hex-dash pattern on the key beyond the UUID phrasing.

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?

Opens with a specific verb+resource+destination: copy a public dataset and its runnable collection pipeline into a new free workspace in the connected org. It distinguishes itself from adjacent workspace-lifecycle siblings by explicitly stating no setup, build_workspace or accept_workspace step is needed, so an agent can separate it from accept_workspace/build_workspace without opening schemas.

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?

Gives eligibility ('eligible public dataset'), a prerequisite ('requires authenticated organisation access'), explicit exclusions ('saved site logins are unsupported') and named alternatives that are not needed. It also tells the agent exactly when to retry (reuse dataset_id and idempotency_key) and what downstream tools follow (query_dataset, browse_dataset_rows, export_dataset).

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 confirm a non-read-only, non-idempotent operation, and the description adds genuinely useful context beyond that: the export is queued asynchronously, status is polled with job_id, and downloading requires a Jsonify browser sign-in (auth constraint). This goes meaningfully beyond the annotation set.

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 tight sentences with the primary action front-loaded and the auth caveat following. No wasted words, though it could have spent a clause on the format/version parameters instead of staying this terse.

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 output schema exists, so return values needn't be described, and the async/auth behavior is covered. However, with 6 parameters at 0% schema coverage and no mention of format or version, the definition is not complete enough for an agent to call it confidently in all modes.

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% across 6 parameters, so the description must carry the load, yet it only clarifies job_id and vaguely gestures at the table. Format (csv/xlsx/json enum), version, dataset_id, and workspace_id receive no semantic explanation, leaving most parameters undocumented.

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?

States a specific verb+resource ('Queue an export of the full selected immutable table') and clarifies the dual read-back mode via job_id. This distinguishes it from read-oriented siblings like query_dataset and browse_dataset_rows, though it never names those siblings explicitly.

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 implies two usage modes (queue an export vs. read status with job_id) but gives no explicit guidance on when to prefer this over query_dataset or browse_dataset_rows, and no prerequisites beyond the browser sign-in note for downloads.

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, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered. The description contributes one genuinely useful behavioural detail — a 50-workspace cap with cursor paging — but says nothing about what happens past that cap or whether more results 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 short sentences with the primary payload first and pagination second; nothing is padded. The word 'access' is slightly vague, but the text is otherwise efficient.

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

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

An output schema exists, so return structure needn't be explained, and the description covers the key operational fact an agent needs (limit of 50, paginate via cursor). Minor gap: no mention of whether truncated results are signalled, but for a simple read-only context call this is close to sufficient.

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

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

Schema coverage is 0% for the single 'cursor' parameter, so the description carries the burden. 'Page with cursor' does explain the parameter's purpose as pagination, which is more than the bare schema gives, but it doesn't state where the cursor comes from (presumably a prior response) or how to detect the last page.

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 gives a concrete verb-and-resource set: it returns the authenticated organisation, its access, and up to 50 workspaces. That is specific enough for an agent to distinguish it from siblings like get_workspace_usage or list_datasets, though it doesn't explicitly contrast itself with any of them.

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?

There is no statement of when to call this versus alternatives, no prerequisites, and no exclusions. The agent must infer from the description alone that this is the context/bootstrap call for discovering the org and its workspaces.

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, idempotent, and non-destructive, so the safety profile is covered. The description does add genuine beyond-schema traits: only *public* events are returned, and "closing the host does not stop work" signals asynchronous continuation. However, both are cryptic and the unexplained "Jason" reference muddies rather than clarifies.

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?

It is short and front-loads the core action, but several sentences do not earn their place as written: "Relay Jason's questions and answers" is unanchored and "Closing the host does not stop work" needs a subject to be useful. Brevity here comes partly from under-specification rather than disciplined editing.

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?

An output schema exists, so return-value explanation is not required, but four of six input parameters are undocumented and the relationship to list_conversations and take-up of the preparation_token are never addressed. For a tool with real pagination and optional workspace/token scoping, this leaves meaningful 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 description coverage is 0% across six parameters, so the description carries the full burden and largely fails. It explains only cursor semantics and leaves input_id, session_id, workspace_id, preparation_token, and the limit cap (500) completely undefined in both schema and 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 verb+resource ("Read public events") is specific, but "for this exact input" is vague jargon and the description never connects the tool to conversations, despite the name and the sibling list_conversations. An agent must infer that "events" are the conversation turns of a specific input_id.

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 gives solid pagination guidance ("Omit cursor on the first read, then pass the returned next_cursor to read only newer events"), which is a real when-to-use rule. But it offers no differentiation from list_conversations or get_context, and the instruction "Relay Jason's questions and answers" is uninterpretable without external context.

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, idempotent and non-destructive, so the safety bar is low. The description still adds real context: values come from existing datasets, saved filters and dashboards are untouched, and results can be narrowed by current selections. No mention of result caps or pagination.

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

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

Three sentences, no filler. Purpose comes first, the dependency hint second, the safety reassurance last — a sensible front-loading order.

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?

An output schema exists, so return values need no explanation, and the description supplies the prerequisite (filter_id from get_dashboard_view) plus the mutation profile. Only the search parameter and any result-size behavior are unaddressed.

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%, so the description must compensate, and it does for most parameters: filter_id ('one registered filter'), dashboard_id/workspace_id ('existing workspace dashboard'), and filters ('optionally constrained by current filter selections'). The search parameter is never explained, and the expected shape of the filters object is left implicit.

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?

States a specific verb and resource: read available choices for one registered filter on an existing dashboard. Scoping words like 'choices', 'one registered filter' and 'existing workspace dashboard' distinguish it cleanly from query_dashboard and get_dashboard_view.

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 the agent to obtain filter_id from get_dashboard_view, which establishes the call ordering. It does not state when to prefer query_dashboard instead, so it stops short of full alternative routing.

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, idempotent, non-destructive, closed-world, so the safety bar is lower. The description still adds real context beyond them: the return includes a *temporary* read-only render URL, and the negative scope confirms no mutation of source data. It does not cover the render URL's lifetime or auth requirements in detail, keeping it short of 5.

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 tight sentences, front-loaded with the core read operation, then routing, then exclusions. Every sentence adds distinct value with no repetition of structured fields.

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 an output schema present, the description needn't detail return values, and it still summarizes contents well; annotations cover safety. The one real gap is that neither parameter is explained, which matters for a tool requiring two opaque IDs.

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% for both required parameters; dashboard_id and workspace_id carry no documentation anywhere. The description only implies workspace scoping via 'workspace dashboard' and offers no syntax, format, or lookup guidance to compensate for the coverage gap on a 2-parameter tool.

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?

States a specific verb (Read) and resource (workspace dashboard layout, queries, filters, dataset refs) with precise scope, and explicitly distinguishes itself from sibling tools query_dashboard and get_dashboard_filter_options. An agent can identify the tool without opening the schema.

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?

Names two concrete alternatives with the condition that selects each ('Use query_dashboard for chart results and get_dashboard_filter_options for filter choices'), and adds an explicit when-not ('Does not create or modify the dashboard or source data'). Routing is fully determined.

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, idempotent and non-destructive, so the safety profile is covered. The description adds the meaningful constraint that results are capped at 100 columns and that a version is returned. It omits any auth/permission notes, so with annotations doing most work a 3 is fair.

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 tight sentence with the core action front-loaded and no filler. Every clause carries information (scope, cap, 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?

An output schema exists, so return values need not be explained. However, with 0% parameter documentation and no explicit guidance on the nullable table/version/workspace_id arguments, the definition is only minimally complete for a tool whose main job is to be called with the right identifying arguments.

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 all four parameters (table, version, dataset_id, workspace_id) rely on the description. It only loosely gestures at 'table' and 'version' and says nothing about dataset_id, workspace_id, or the nullable defaults, which is a substantial gap for a 4-param tool.

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?

States a specific verb (read) and resource (one table's schema and version), with a useful scope qualifier of up to 100 columns. It is distinguishable from list_datasets, browse_dataset_rows and query_dataset, though it doesn't name those siblings explicitly.

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 'for subsequent row queries' implies this is a precursor to query_dataset/browse_dataset_rows, giving some context. However it never explicitly states when to use this instead of those tools, nor any prerequisites or exclusions, leaving usage largely to inference.

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, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds non-obvious behavior: the 20-revision cap, the paging mechanism via next_before/before, and the no-export constraint. Return format specifics are left to the output 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?

Three tight sentences with no waste. The core read scope is front-loaded, followed by paging guidance and the sibling reference, then the boundary statement.

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?

An output schema exists, so return values need not be explained, and the description links the before parameter to the next_before output field to make paging actionable. Complete for a read-only browse tool, with only minor gaps around required identifiers.

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 the description must carry the param burden, and it does for the non-obvious ones: version defaults to the active version, before drives reverse paging off next_before, and table selects the schema to show. It does not spell out dataset_id/workspace_id semantics, but those are self-evident from context.

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?

States a specific verb and resource (read an existing dataset) and enumerates exactly what is returned: description, row counts, table schema, and up to 20 revisions. An agent can distinguish it from browse_dataset_rows and export_dataset without opening any schema.

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 routes the agent: omit version for the active version, use before for paging older revisions, and use browse_dataset_rows to read actual records. It also states the negative boundary (does not modify or export), which selects it away from export_dataset.

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, idempotentHint=true, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered structurally. The description adds no behavioral context beyond that — nothing about workspace scoping, behavior on an unknown or inaccessible pipeline_id, or any cross-workspace access rules.

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?

It is a single front-loaded sentence with the verb first, which is good structure. But the long comma-list of data fields is dense and largely duplicated by the output schema, so much of the sentence does not earn 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?

An output schema exists, so explaining return values is unnecessary — yet that is nearly all the description does. The genuinely needed information (workspace_id semantics, relationship to get_pipeline_view and run_pipeline, failure behavior) is missing for a tool in a crowded pipeline-related sibling group.

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 the schema itself says nothing about pipeline_id or the optional workspace_id. The description only obliquely implies pipeline selection via 'the selected pipeline' and is completely silent on what workspace_id does or when it should be supplied, so it fails to compensate for the coverage 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?

The description gives a verb ('Read') and resource ('the selected pipeline's active version...'), so the basic operation is discernible. However, the bulk of the sentence enumerates returned data fields rather than stating the purpose, and it never distinguishes this from siblings like get_pipeline_view or list_pipelines, which an agent could easily confuse with it.

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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as list_pipelines (to discover pipelines) or get_pipeline_view (which sounds nearly identical). The word 'selected' hints that an ID must already be known but does not say so.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds one genuine behavioral fact beyond them – output previews are "bounded" – but gives no sense of the bound, pagination, or latency.

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 sentence, front-loaded with the verb and resource, listing exactly what is returned. Nothing is wasted.

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?

An output schema exists, so return values need no prose, and annotations cover the safety profile. However, with two required parameters documented at 0% coverage and no usage guidance, an agent still lacks enough to call it confidently.

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% for both parameters, so the schema carries no meaning at all. The description's "selected pipeline" loosely implies pipeline_id but says nothing about workspace_id or the expected ID format, leaving half the required inputs unexplained.

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?

States a specific verb ("Load") and names the exact payload: description, latest production run, and bounded output previews. It is clearly a richer read than a plain metadata fetch, but it never names get_pipeline or get_run, so the boundary with those siblings must be inferred.

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 nothing about when to choose this over get_pipeline, get_run, or open_pipelines, nor any prerequisite such as a completed production run. "Selected pipeline" is the only hint that a pipeline must already be chosen.

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/idempotent/non-destructive, so the safety profile is covered. The description adds real behavioral context beyond that: the 20-row result cap and the explicit exclusion of full logs and rows, which sets an agent's expectation about output volume.

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 short sentences, zero filler, with the resource and scope front-loaded. Every clause adds information an agent can use.

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?

An output schema exists, so return values need not be re-explained, and annotations cover the safety profile. The remaining gap is the ambiguous optional workspace_id, which the description never addresses.

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% across two parameters, so the description must carry parameter meaning and it does not. It says nothing about run_id or the optional workspace_id, including whether workspace scoping is required or how it is resolved.

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?

States a specific verb and resource ('Read the selected run's recorded status') plus the scope of what is returned ('up to 20 output row counts'). It is clear what the tool does, though it doesn't explicitly contrast itself with sibling read tools like get_pipeline or browse_dataset_rows.

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 clause 'No full logs or rows' implicitly steers the agent away from expecting detail and hints that fuller-read siblings exist, but it never names an alternative or states a when-to-use condition. Usage is implied rather than specified.

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, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds the substance of the read (usage, collection cap, pricing), which is useful context, but nothing about permissions, freshness of usage data, or 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?

A single front-loaded sentence with no filler; the resource and the returned fields are stated up front. 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?

An output schema exists, so return values need not be spelled out, and annotations carry the safety profile. The description is sufficient to invoke the tool correctly, with only the bare workspace_id semantics left unstated.

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?

One required parameter with 0% schema description coverage, so the description must compensate. 'The selected workspace's' loosely implies workspace_id selects the target, but it adds no format, sourcing, or default guidance beyond the obvious. Adequate but thin.

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?

States a specific verb (Read) and resource (workspace's current usage, collection cap and pricing), so the agent knows exactly what it returns. It is implicitly distinguishable from the write-oriented sibling update_workspace_row_limit, but the description never names a sibling or scope boundary explicitly.

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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as update_workspace_row_limit or accept_workspace. Usage is only implied by the verb 'Read'.

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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description adds value by disclosing the 50-result cap and that histories are not loaded. These are meaningful behavioral traits beyond the annotations, though return shape and pagination behavior are left to the output 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?

A single front-loaded sentence with zero filler; the cap and the no-history constraint are packed into one clause 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?

An output schema exists, so return values need not be explained, and the 50-cap is useful context. However, with two undocumented parameters at 0% coverage and no routing to get_conversation, the definition is not complete enough for a listing tool with filtering and pagination inputs.

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% and neither 'cursor' nor 'workspace_id' is addressed anywhere in the description. The 'up to 50' cap hints at pagination but the cursor's role is never explained, and the workspace scoping parameter is entirely undocumented, leaving both parameters without 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?

States a specific verb (find), resource (Jsonify conversations), a concrete cap (up to 50), and the intended use (explicit continuation). The phrase 'does not load histories' implicitly distinguishes it from the get_conversation sibling, but never names that alternative, so differentiation is only partial.

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?

'For explicit continuation' and 'does not load histories' give an implied context for use, but there is no explicit when-not guidance and no named alternative (get_conversation) to route the agent. The 50-item cap is stated but not framed as pagination or a signal to use the cursor.

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, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuinely new behavioral detail: a hard 50-item cap and that active versions are returned. However, it is silent on the cursor-based pagination that plainly exists in the schema, which is the main behavioral trait an agent needs 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?

Two short sentences with zero waste; the result shape and cap are front-loaded and the alternative follows immediately. Nothing could be cut without losing 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?

An output schema exists, so return values need not be explained, and the safety profile is handled by annotations. Still missing for correct invocation: how to page with `cursor` and what `workspace_id` scopes the listing to, both critical with zero schema coverage on a 2-param 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?

Schema description coverage is 0%, so the description must compensate and does not. Neither `cursor` nor `workspace_id` is mentioned; "up to 50" hints at paging but never says how to continue, and workspace scoping is left entirely implicit.

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?

States a specific verb and resource ("Find up to 50 datasets and their active versions") and adds the item cap, which tells an agent the scope of the result. It does not fully differentiate from close siblings like list_pipelines or browse_dataset_rows, but the second sentence anchors it against get_dataset.

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 routes to get_dataset "for a selected schema," giving a clear alternative and the condition that selects it. It stops short of covering other plausible alternatives (browse_dataset_rows, query_dataset) or when a listing is inappropriate.

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 establish that this is a safe, read-only, idempotent operation. The description adds useful behavior beyond annotations: it returns summaries only, returns at most 50 items, and avoids loading per-item details. It does not explain cursor pagination behavior or workspace scoping, leaving some behavioral context undisclosed.

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 compact sentence with no wasted words, and the key scoping facts are front-loaded. It efficiently conveys the most important operational constraints.

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?

An output schema exists, so return value structure does not need explanation. Still, for a paginated list tool with optional 'cursor' and 'workspace_id' parameters, the description omits how pagination works and how workspace filtering is applied. It is minimally adequate but leaves important invocation context incomplete.

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 the description should compensate for the two undocumented parameters. It does not explain 'cursor' or 'workspace_id' at all, beyond the general statement about finding up to 50 pipelines. The parameter names are somewhat self-explanatory, but the description adds no meaningful 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?

The description gives a specific verb and resource ('Find ... pipelines') and clarifies the scope: summaries only, capped at 50, with no per-item detail loading. This distinguishes it from detail-oriented siblings such as get_pipeline without requiring the agent to inspect their schemas.

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 clearly implies a listing/summary use case and rules out per-item detail loading, which helps separate it from get_pipeline. However, it does not explicitly name get_pipeline as the alternative for detail, so the guidance is clear but not fully prescriptive.

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 establish that this is a read-only, idempotent, non-destructive, closed-world operation. The description adds useful context that results are a single bounded page of summaries, but it omits pagination behavior, how cursor parameters work, and whether all sections are returned together.

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 short sentences with no filler and leads with the core operation. Its brevity does contribute to the ambiguity, but it is structurally 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?

For a tool with five input parameters, an enum-backed section selector, pagination cursors, and multiple sibling listing tools, the description is far too sparse. The output schema reduces the need to explain returns, but the input semantics and sibling routing remain largely unaddressed.

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 the description must compensate for five undocumented parameters. It only hints at workspace and pipeline summaries and bounded paging, leaving cursor, search, section, workspace_id, and workspace_cursor unexplained.

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 says to "Open Jsonify" and return "One bounded page of workspace and pipeline summaries," which gives a vague sense of the operation and result. However, it does not clearly distinguish this from siblings such as list_pipelines, get_pipeline, or get_pipeline_view, and the mention of only workspace/pipeline summaries conflicts with the schema's broader section enum.

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?

There is no guidance on when to use this tool versus list_pipelines, get_pipeline, or other siblings. The phrase "Open Jsonify" implies an app-opening context, but no conditions, alternatives, or exclusions are stated.

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, idempotent, non-destructive, so the safety profile is covered. The description's one addition of substance is 'No caller-supplied SQL', which usefully signals that only registered queries can run — but it says nothing about auth requirements, what happens with a stale query_id, or result size behavior.

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

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

Two front-loaded sentences with no filler, and the key constraint is stated up front. It is efficient, though extreme brevity is arguably part of why the gaps elsewhere exist.

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?

An output schema exists, so return values need not be explained, but the description still leaves an agent unable to construct a valid call: nothing explains the params/filters object shapes or how a query_id is obtained. For a 5-parameter tool with 0% schema coverage, that is a material shortfall.

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% across five parameters, and the two genuinely ambiguous ones (params, filters) are untyped free-form objects with additionalProperties=true and no explanation of their accepted shape. The description never mentions params, filters, dashboard_id, or workspace_id, so it does not compensate for the coverage 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?

States a specific verb+resource ('run one registered chart query') and adds a scoping constraint ('No caller-supplied SQL') that separates it from the arbitrary-SQL sibling query_dataset. It stops short of naming that sibling, so differentiation still requires inference.

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?

No when-to-use guidance, no prerequisites, and no mention of the obvious alternatives (query_dataset, get_dashboard_view, get_dashboard_filter_options) that an agent must choose between. The agent is left to infer that this only works for pre-registered dashboard charts.

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 cover read-only, idempotent, non-destructive, closed-world behavior, so the bar is lower; the description still adds real value by disclosing snapshot semantics ('pages stay pinned to one version') and the failure mode for oversized result sets. It does not explain how a version is obtained or what happens with an expired cursor.

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

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

Four short sentences, front-loaded with the core action and no filler. The 'Oversized results require fewer rows/columns' sentence is terse to the point of being cryptic about the actual remedy.

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?

An output schema exists, so return values need not be described, and pagination/versioning is at least acknowledged. For a 10-parameter tool with zero schema descriptions, however, an agent still lacks enough guidance to set sort, limit, cursor, table, or workspace_id correctly.

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

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

Schema description coverage is 0% across 10 parameters, so the description carries the full burden, yet it only alludes to columns, filters (equality), and version pinning. Sort/descending, cursor pagination, limit bounds, table vs dataset_id selection, and workspace_id are left entirely unexplained.

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?

States a concrete verb+resource ('Read exact typed rows from one dataset table') and scopes it with optional equality filters and column selection. It implicitly separates itself from browse/exploratory reads and SQL tools ('No SQL'), but never names the sibling browse_dataset_rows, so the differentiation is inferred rather than stated.

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?

Usage context is implied ('optional equality filters', 'No SQL or credentials', 'Oversized results require fewer rows/columns'), which tells the agent this is a bounded, filter-based read. It never says when to choose this over browse_dataset_rows or query_dashboard, nor when the version/cursor parameters are required.

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 destructive/openWorld/idempotent, and the description adds substantial context beyond them: deletion only on explicit user request, other changes versioned, test runs free while production/scheduled runs consume a capped monthly row allowance, and external sends only to user-configured destinations. The retry guidance ('Reuse the exact key and arguments') reinforces the idempotentHint.

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 purpose is reasonably front-loaded, but the paragraph is long and repeats concepts ('build new pipelines' vs 'build, change, or diagnose data pipelines') and repeats the agent name 'Jason' many times. Several sentences could be tightened without losing meaning.

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

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

For a complex 8-parameter agentic dispatch tool with an output schema (so return values need not be described), the description covers usage conditions, side effects, billing, and follow-up well. Its main gap is the four undocumented optional parameters, which slightly limits completeness.

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 the description must carry the load. It explains workspaceless (when true vs false) and workspace_id usage, and implies idempotency_key semantics, but leaves dataset_id, session_id, pipeline_id, and preparation_token entirely unexplained. It partially compensates for the coverage gap but not fully.

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 the resource ('build new pipelines', 'build, change, or diagnose data pipelines, or continue an existing conversation') and distinguishes itself from build_workspace ('Creating a pipeline is not creating a workspace'). It reads as a work-dispatch tool, though the core purpose is buried under extensive behavioral prose, so it is clear but not crisp.

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 gives explicit when-to-use conditions for workspaceless=false vs workspaceless=true, states the fallback ('If no workspace is known, ask the user to select one'), and routes the agent to the follow-up tool ('follow the input with get_conversation'). This is precisely the when/when-not/alternative guidance the dimension rewards.

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?

Goes well beyond annotations: discloses the confirmation-gated two-phase behavior, that reads sources but never posts, that pre-configured notifications may fire, idempotency binding, and retry semantics with the same key. Contradiction-free against idempotentHint/openWorldHint.

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?

Front-loads the core action, then sequences the flow logically. Dense but every clause carries operational meaning; slightly long but justified by the multi-step protocol.

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 the full confirmation workflow, side effects (notifications, no posting), retry behavior, and revision-binding edge case. Output schema exists so return values needn't be explained, and the description fills all remaining 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%, so the description must carry the burden and it does: it explains row_limit as the cap, confirmation as the returned token from the estimate step, idempotency_key must be reused on retry, and that approval binds the revision. Adds meaning the bare schema lacks.

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?

States a specific verb+resource ('Run an existing activated pipeline') and scopes it with the row cap. Explicitly distinguishes from siblings by naming get_run for inspection and stating it 'does not author code or change schedules.'

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?

Gives explicit two-step protocol: first call returns estimate only, second call with confirmation starts the run, then inspect with get_run. Names the sibling to use afterward and the prerequisites (user approval, fresh estimate if revision changes).

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 flag destructive, open-world, idempotent and non-read-only behavior, and the description adds substantial context beyond them: per-mode effects, the fact that published details may be copied to public GitHub and prior copies can persist, the unlisted default for new pipelines, and the auth requirement (normal org/workspace access, not platform admin). This is exactly the irreversibility and side-effect disclosure an agent needs for a destructive toggle.

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 core purpose is front-loaded in the first clause, followed by mode semantics, side effects, and scope exclusions in a logical order. It is on the long side (seven sentences), but nearly every sentence adds decision-relevant information rather than restating the name.

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 an output schema present and rich annotations, the description still covers everything an agent needs: mode behavior, defaults, public-copy side effects, permission requirements, and explicit exclusions. Nothing material is missing for a three-parameter destructive toggle.

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%, so the description must carry parameter meaning. It fully explains the semantically important parameter, enumerating what 'on', 'off' and 'inherit' mean, but says nothing about pipeline_id or workspace_id beyond their self-evident names. Partial compensation for the coverage gap justifies a mid score.

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 specific verb and resource ('Set whether a pipeline participates in Factory's Public Directory') and immediately scopes the action with 'only when the user requests it'. No sibling tool (get_pipeline, open_pipelines, run_pipeline) touches directory visibility, so the agent can distinguish it without opening the schema.

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 gives a clear usage condition ('only when the user requests it') and spells out what each visibility mode does, plus a list of things it does NOT do (admin curation, build-conversation sharing, data collection, schedules). It stops short of naming an alternative sibling tool or a when-not-to-use scenario beyond the user-request constraint.

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?

Goes well beyond the annotations (readOnlyHint=false, idempotent=false, destructive=false) by disclosing token semantics (random possession proof, unsigned, not a password/API key/OAuth token), 24-hour unclaimed expiry, post-creation requirement of the workspace owner, that no collection or workspace is created, and a security warning not to expose the token.

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?

Front-loads purpose and return values in the first two sentences before layering security and lifecycle detail. Dense and slightly run-on with several clauses packed into single sentences, but essentially every clause carries operational 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?

Despite an output schema existing, the description still supplies lifecycle, security and follow-up-call context an agent needs to act correctly. For a zero-parameter, auth-sensitive bootstrap tool, nothing material 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 tool takes zero parameters, so the baseline of 4 applies and the schema has nothing to document. The description correctly spends no space on parameters and instead explains what to do with the returned values.

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?

States a specific verb+resource (start a preparation) and immediately names the two artifacts it produces, preparation_token and session_id, plus the auth modes it accepts. The opaque product term ('Jason preparation') and the fact that it never contrasts itself with any sibling keep it just below 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?

Gives clear context for invocation: OAuth vs anonymous WorkOS agent token, the note that anonymous tokens allow preparation only, and that the returned token is needed for request_work(workspaceless=true), get_conversation and cancel_work. It stops short of stating when NOT to use this tool versus an alternative entry point.

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 write/idempotent/destructive, but the description adds context the annotations cannot convey: that the operation may pause collection and, importantly, that it does not change payment methods or create charges and that existing billing rules apply. This is useful, non-obvious behavioral disclosure.

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

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

Four short sentences, front-loaded with the action and its trigger, then the side effect and the billing clarifications. No filler, though the telegraphic style leaves some terms ('the cap') slightly underspecified.

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?

An output schema exists, so return values need no explanation, and annotations cover the safety profile. The description covers billing and collection side effects but omits parameter meaning and any sibling routing, leaving gaps for a 2-parameter mutation 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?

Schema description coverage is 0% for both required parameters, and the description does not name or explain workspace_id or monthly_row_limit. 'The cap' loosely maps to monthly_row_limit but workspace_id is entirely undocumented, so the description fails to compensate for the coverage 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?

The description states a specific action ('Save the cap') and, combined with the name/title, makes clear this sets a workspace's monthly row limit. However, 'the cap' is indirect and there is no explicit differentiation from the many sibling workspace 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?

'Save the cap after the user confirms in the usage panel' gives a clear trigger condition (post-confirmation in the usage panel), which is genuine usage guidance. It offers no when-not conditions and does not name any alternative tool, so it remains implied rather than explicit.

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