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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral context by stating this is a mandatory pre-step before writing/editing code. It does not describe the response shape or that the main response surfaces reference files, which is only inferable from the schema.

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

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

Two short sentences, front-loaded with the imperative 'ALWAYS call', with no filler. The trailing 'etc.' slightly weakens precision, keeping it from a 5.

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 no output schema, the description should say what the agent receives (guidance text and, per the schema note, a list of reference file paths). It conveys the trigger and mandatory nature well but omits output expectations and gives no help choosing among the ambiguous enum values, leaving real gaps for a tool whose only required parameter is that enum.

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 only 50%: the required 'creationType' enum has 21 values and no schema description, and the description says nothing about how to pick one. The enum contains near-duplicate options ('serverless' vs 'netlify-functions', 'blobs' vs 'netlify-blobs', 'db' vs 'netlify-database') that the description does not disambiguate. The 'reference' parameter is documented in the schema, but the description adds no parameter meaning of its own.

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 makes clear this returns Netlify/serverless coding guidance ('coding rules' per the name) and frames it as a prerequisite step. It is a specific purpose but never explicitly says what is returned (rules text, reference files), leaving the resource implied rather than stated. Sibling tools are all unrelated reader/updater services, so differentiation is less of a concern here.

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?

Strong, explicit trigger conditions: 'ALWAYS call when writing serverless or Netlify code' and 'required step before creating or editing any type of functions, Netlify sdk/library usage'. It gives when-to-use clearly but offers no when-not guidance and does not discuss alternatives (none exist among the siblings, so this is a minor gap).

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 readOnly, idempotent, openWorld and non-destructive, so the bar is lower; the description still adds real behavioral context that annotations cannot express — only the owning account answers for a given id, and non-owning accounts are surfaced under notFoundIn. That multi-account resolution detail is genuinely useful for interpreting results.

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 leading sentence is front-loaded and useful, but the multi-account paragraph repeats the identical clause verbatim for both operations ('only the account that owns the id answers, and accounts without it are listed under notFoundIn'), bloating the definition without adding 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 read-only tool with two parameters and no output schema, the description covers operation selection and account behavior but says nothing about what a deploy record contains or how results are shaped. Adequate but leaves the agent to discover return content on its own.

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 50%; the account property is documented in-schema and the description reinforces its multi-account semantics ('one name, several names separated by commas, or "all"' is schema-side). The nested params (deployId, siteId) carry no prose in either place, so the description only partially compensates.

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

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

Names a specific resource (Netlify deploy read operations) and enumerates the two selectable operations, get-deploy and get-deploy-for-site. A reader can tell this apart from the sibling netlify-deploy-services-updater by the '(read-only)' qualifier, though the two operations' own distinction is left for the schema to reveal.

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 is implied by 'Select and run one of the following Netlify read operations' and the account-scoping paragraph, but there is no explicit statement of when to pick get-deploy versus get-deploy-for-site, nor any exclusion against the updater sibling. The agent must infer operation choice from the required params.

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, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description's contribution is the account-multiplexing constraint (lists/all refused for deploy-site), which is genuinely useful additional context, but it omits how the deploy is performed or what state it changes.

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 text is short but poorly structured: 'one of the following ... operations deploy-site' promises a list that never appears, and the account rule is repeated almost verbatim in the second sentence. The important scoping constraint is not front-loaded and the wording is confusing.

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, open-world write tool with a nested schema and no output schema, the description is far too thin. It gives no confirmation of what a successful deploy produces, no side-effect warnings beyond annotations, and no coverage of the two parameters that drive the operation.

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

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

Schema description coverage is only 50%, so the description is expected to compensate. It restates the account restriction already present in the account parameter's schema text and says nothing about 'deployDirectory' or 'siteId', the parameters that actually matter for a correct deploy invocation.

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 identifies a scoped write operation ('Netlify write operations deploy-site') with a verb (run/select) and resource (deploy-site), and the sibling 'netlify-deploy-services-reader' makes the read/write split inferable. However, the phrasing 'one of the following ... operations deploy-site' is garbled and only lists a single operation, so an agent cannot cleanly tell what is being dispatched or how it differs from the other updaters.

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 only guidance offered is that deploy-site takes a single account and refuses a list or 'all'. There is no statement of when to call this tool versus netlify-deploy-services-reader or the other updater siblings, and no prerequisites (e.g. linking a site) beyond what the schema notes.

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 non-destructive, so safety is covered. The description adds genuinely new behavioral detail: which operations answer for every named account versus only the owning account, and that non-owning accounts surface under notFoundIn. This multi-account semantics is not in the annotations or 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?

Front-loaded with the purpose and operation list, then the multi-account detail. Dense but no wasted sentences; the operation list could have been formatted more scannably but the content 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 two-parameter dispatcher with no output schema, the definition covers account semantics well but never explains what each operation does or returns, leaving an agent unable to confidently pick between get-extensions, get-full-extension-details, and initialize-database.

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 only 50%, and the description compensates by explaining the account argument's effect per operation, which the schema does not detail. It does not, however, add meaning for the extensionSlug/teamId params of get-full-extension-details beyond what the schema already says.

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 clear verb+resource ('run ... Netlify read operations') and enumerates the three selectable operations, while the read-only framing separates it from the sibling netlify-extension-services-updater. It does not explain what each operation actually returns, so the distinction between get-extensions and get-full-extension-details remains opaque.

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?

'Select and run one of the following' implies usage but gives no condition for choosing one operation over another, and no guidance on when this reader is preferred over the sibling updater. The per-operation account behavior is useful context but is about execution mechanics, not when-to-use.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and readOnlyHint=false, so the safety profile is covered structurally. The description adds the multi-account refusal behavior, which is genuinely useful context, but says nothing about scope of the change, required permissions, or reversibility beyond what annotations 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?

It is short (two sentences), which is appropriate for a dispatcher-style tool. But the first sentence runs together without punctuation ('write operations change-extension-installation'), making the structure awkward rather than clean 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 destructive write with a nested schema, no output schema and 50% param coverage, the description covers the account restriction but does not explain the effect of shouldBeInstalled (install vs uninstall) or the operation's outcome. Annotations carry the safety profile, keeping this at a minimally adequate 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?

Schema description coverage is 50%; the account parameter is documented in-schema, and the description reinforces its semantics ('one account only, so a list or all is refused'), adding real meaning. However it leaves extensionSlug, shouldBeInstalled and teamId entirely unexplained, so it only partially compensates 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 names the specific operation (change-extension-installation) but frames it as 'Select and run one of the following Netlify write operations' with only one option listed, and the missing punctuation makes the intent hard to parse. An agent can glean it is a write operation on an extension, but the verb+resource is delivered awkwardly.

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 states the account constraint clearly ('change-extension-installation: one account only, so a list or all is refused'), which is real usage guidance for the account argument. It offers no when-to-use vs sibling routing (e.g. extension-services-reader or other updaters).

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 read-only, idempotent, open-world and non-destructive, so the description's 'read-only' tag adds nothing. The one genuine addition is the multi-account rule (only the owning account answers; other accounts appear under notFoundIn). That is useful beyond the annotations, but it is duplicated five times with identical wording, so it adds no per-operation nuance.

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 same multi-account sentence is copy-pasted for all five operations, which is pure redundancy rather than differentiated content. The operation list sits on one run-on line with no formatting, and the repeated block buries the only useful information after three paragraphs of duplication.

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 five-operation tool the description does list the operations and the account semantics, and the nested schema supplies the parameter detail. However it never explains what each operation returns or how the operations relate (counts vs ranking vs time series vs raw logs), which is the main thing an agent needs when there is no output schema.

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

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

Top-level schema coverage is 50%, but the nested selectSchema is exhaustively documented (timestamps, filters, enums, sorting, pagination defaults). The description restates the account behavior that the account property already describes, and adds nothing about the operation-specific params. Baseline 3 is appropriate given the schema carries the detail.

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

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

The description names a concrete verb ('select and run') plus the exact operation set (get-counts, get-topk, get-timeseries, get-request-logs, get-request-detail) and flags read-only scope, so an agent knows it is the Netlify traffic/log analytics facade. It does not distinguish itself from the other *-services-reader siblings (deploy, team, project), but the operation list makes the resource domain inferable.

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 says 'select one of' the operations but gives no criterion for choosing between get-counts, get-topk and get-timeseries, nor any when-to-use-this-vs-deploy-services-reader guidance. The only usage-adjacent content is which operations accept lists/'all' for accounts, and that is repeated verbatim rather than expanded.

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 and destructiveHint=false, so the safety profile is covered. The description adds genuinely non-annotated behavior: get-project and get-forms-for-project only resolve on the owning account and surface non-matching accounts under notFoundIn, whereas get-projects queries every named account.

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?

Purpose is front-loaded in the first clause, and the per-operation account rules follow compactly. The semicolon-separated clauses are dense but purposeful, with no filler sentences.

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?

No output schema exists, so the description carries return-behavior burden, and it does explain the notFoundIn outcome for two of the three operations. For a read-only tool whose annotations cover safety, this is nearly complete, though it omits pagination or result-shape hints.

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 50%. The description meaningfully explains the 'account' argument's multi-account resolution semantics, but the nested operation params (siteId, teamSlug, formId, projectNameSearchValue) are left to the schema and not clarified here. Adequate but not a full compensation 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 names a specific verb (select and run) and resource (Netlify read operations), then enumerates the three operations: get-project, get-projects, get-forms-for-project. The 'reader' vs 'updater' naming separates it from the sibling netlify-project-services-updater, but the description never explicitly references or contrasts the sibling, keeping it short of 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?

It states the tool is read-only and details the multi-account behavior per operation, which is real usage context. However, there is no explicit guidance on when to pick this tool versus an alternative (e.g., the updater or user-services reader), and no exclusions beyond the read-only framing.

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, readOnlyHint=false, and openWorldHint=true, so the safety profile is covered. The description adds value by disclosing account-scoping behavior per operation ('only it answers', 'a list or all is refused'), but says nothing about permissiveness requirements, reversibility of the six mutations, or side effects, which a destructive dispatcher should ideally cover.

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 operation list is helpfully front-loaded, but the second half is a long run-on paragraph that repeats the identical phrase 'one account only, so a list or all is refused' four times instead of grouping the operations that share the constraint. The repeated boilerplate costs space without adding 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 six-operation dispatcher with a discriminated union schema and no output schema, the description covers only the account dimension and never explains what the individual operations actually do (e.g., what update-visitor-access-controls or update-forms change). Operation names are reasonably self-descriptive and params live in the schema, but the write semantics an agent needs before committing are largely absent.

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 50% and the selectSchema union carries no description at all, so the description must compensate. It does so meaningfully for the account parameter by spelling out exactly which of the six operations tolerate a single name, a comma list, or 'all' — detail the schema's own account description only gestures at.

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: 'Select and run one of the following Netlify write operations', then names all six operations. The word 'write' implicitly separates it from the netlify-project-services-reader sibling, though it never names that sibling or distinguishes itself from netlify-deploy-services-updater, which also performs writes.

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 guidance given is almost entirely about the account argument for each operation (which operations accept lists/all vs. a single account), which is real routing advice but scoped to one parameter. There is no explicit statement of when to pick this tool over the reader sibling or the deploy updater, so tool-level selection is left 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 cover readOnly/idempotent/openWorld, so the safety profile is set. The description adds genuinely new context: for get-team and get-team-env-vars only the owning account responds and non-owning accounts surface under notFoundIn, a return-behavior detail not available in 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?

Purpose is front-loaded in the first line, and the multi-account paragraph, while slightly repetitive between get-team and get-team-env-vars, earns its place by disclosing routing behavior.

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 selector tool with no output schema, the description covers operation selection and the notable multi-account result routing (notFoundIn). The main gap is that the per-operation params (teamId, envVarKey) are left unexplained.

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 only 50%, so the description needs to compensate. It does explain the multi-account semantics of the 'account' argument well, but says nothing about teamId or envVarKey and their meaning, so coverage remains incomplete.

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 specific operations (get-teams, get-team, get-team-env-vars) and frames the tool as a Netlify team-services reader, so the verb+resource is clear. It does not explicitly distinguish itself from sibling readers like netlify-project-services-reader, but the 'team' scope makes the domain evident.

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 selection guidance among its own sub-operations and describes multi-account behavior, which helps an agent choose. However, it never states when to use this reader versus the other netlify-*-services-reader siblings, leaving cross-tool selection 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 readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful multi-account behavior ('get-user: every named account answers') but does not describe authentication, rate limits, or return behavior beyond what annotations 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 short, but the structure is awkward: it says 'one of the following' operations while listing only get-user, and the multi-account sentence is hard to parse. It is not verbose, but it is not cleanly front-loaded or well-formed.

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 reader tool with no output schema and 50% schema description coverage, the description is incomplete. It does not explain what get-user returns, and it does not differentiate this user-services reader from sibling service readers, leaving selection 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 50%, and the account parameter already has a rich schema description. The description adds meaning about how get-user interacts with multiple named accounts, but it does not explain the nested selectSchema fields such as aiAgentName, llmModelName, or params.

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 cluster: 'Select and run one of the following Netlify read operations (read-only) get-user.' This makes clear it executes the get-user read operation, but it does not distinguish this from sibling readers such as team-services-reader or project-services-reader.

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 sibling read tools. The only usage-adjacent note is about multi-account behavior for the account argument, which does not help an agent choose between this and other Netlify service readers.

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