FactGrid

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

No annotations are provided, so the description carries the full burden. It discloses current availability: 'TEMPORARILY OFFLINE for third-party APIs, pending revalidation - it returns no data and bills nothing.' It also describes the output: 'Returns removed endpoints, removed or renamed parameters, type changes, newly required parameters, and a migration note for each.' This is substantial, though it does not mention authentication, rate limits, or error behavior. Still, for a read-only search tool, this is strong 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?

The description is longer than two sentences but every sentence carries critical information: offline notice, alternative tool, core purpose, use cases, exclusions, and return content. It is front-loaded with the most urgent detail (temporarily offline). No fluff 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?

With no output schema and no annotations, the description does a good job at providing a complete picture. It explains what the tool returns, when to use it, and its current non-functional state. It could benefit from detailing the exact response format, but the summary of return categories is sufficient for an agent to make a selection decision.

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

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

Schema description coverage is 100% for all three parameters, providing clear descriptions ('Service name, e.g. "Stripe"', 'Optional: version being upgraded to', 'Optional: version currently targeted'). The description adds usage context but does not add new semantic meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the verb and resource: 'Find what BREAKS between two versions of a third-party API' with examples like Stripe, OpenAI, Supabase. It also distinguishes itself from the sibling tool by specifying that it only covers third-party APIs, not npm/PyPI packages (for which factgrid_package_upgrade_advisory should be used).

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

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

Explicit when-to-use guidance is given: 'Use this when code that calls an external API fails after a version bump, when writing an integration against an API whose version you are unsure of, or before upgrading a dependency that wraps an HTTP API.' It also states when NOT to use it: 'Do NOT use for general programming questions or for APIs you control.' Additionally, it names the alternative for npm/PyPI packages: 'For npm or PyPI packages use factgrid_package_upgrade_advisory instead, which is live.'

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

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

No annotations are provided, so the description carries the full burden. The verb 'look up' implies a read-only behavior, and the description details what information is returned (parameter names, required flags, types). However, it does not disclose error handling, authentication needs, or how the 'specific version' is determined, leaving some behavioral traits unaddressed.

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 compact and well-structured: the core purpose is front-loaded, followed by usage guidance and a negative rule. Every sentence adds value, with no redundancy.

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

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

The description addresses purpose, usage, and negative scope, making it reasonably complete for a 2-parameter lookup tool. However, the 'specific version' claim is not mapped to any parameter, and the optionality of both params raises questions about invocation patterns. These gaps prevent it from being fully comprehensive.

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

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

The input schema already provides descriptions for both parameters (query and service) with examples, achieving 100% coverage. The description adds the notion of 'specific version' but does not explain how to specify it or clarify the relationship between the two parameters. Thus it only marginally enhances schema information.

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

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

The description clearly states the tool's function: 'Look up the exact request and response shape of a third-party API endpoint at a specific version.' It specifies the resource (third-party API endpoint) and the action (look up shape), and distinguishes from sibling tools like factgrid_discover_api by focusing on exact schema details.

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

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

The description explicitly instructs when to use the tool: 'Use this before writing or repairing a call to an external HTTP API, instead of guessing parameter names from memory.' It also provides a clear exclusion: 'Do NOT use for APIs in the local codebase.' This gives concrete guidance and alternatives.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It states that it reuses verified specification details to save tokens, and explicitly handles the edge case that 'Rate limits not declared by the spec are reported as unstated.' This goes beyond the bare action and discloses meaningful behavior, though it does not cover potential side effects or network behavior.

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

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

The description is three sentences with no filler. The first sentence delivers the core purpose, the second explains efficiency benefits, and the third handles an edge case. Every clause earns its place, and it is well 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 simple one-parameter tool with no output schema, the description covers inputs (third-party service), outputs (auth schemes, scopes, rate-limit headers, error code table), edge cases (unstated rate limits), and usage boundaries (not for own codebase). This is complete for the tool's complexity.

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

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

Schema description coverage is 100% for the single 'service' parameter, so the baseline is 3. The description adds value by clarifying that the service must be a third-party API (not one in your codebase), which helps the agent select appropriate values. This extra semantic constraint lifts it above the baseline.

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

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

The description uses the specific verb 'Get' and explicitly enumerates the resource: 'authentication schemes, required scopes, declared rate-limit headers, and complete error code table for a third-party API.' It also distinguishes itself from sibling tools by focusing on auth/rate-limit/error semantics, and clarifies scope with 'Do NOT use for APIs in your own codebase.'

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

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

The description provides a clear when-not: 'Do NOT use for APIs in your own codebase.' It also implies when to use by mentioning the need to avoid burning tokens rediscovering 401/403/429 semantics. However, it does not explicitly name alternative tools or list precise conditions under which to choose this over siblings, so it stops short of a 5.

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

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

No annotations are present, so the description carries full responsibility. It adds an honesty caveat: 'Accuracy is best-effort — always confirm against the manufacturer datasheet before manufacturing,' and discloses the scope of output. This is good but lacks details about error behavior, response format, or potential limitations beyond accuracy.

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

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

The description is three sentences, front-loaded with the primary purpose, followed by use cases, and ends with a critical safety caveat. Every sentence adds value with no fluff 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?

The tool has no output schema, so the description should compensate by explaining what the result looks like. It lists the types of facts returned (pin assignments, voltage range, etc.) and adds a confirmation warning. It is complete for a simple lookup tool, though it could benefit from mentioning how results are structured (e.g., multiple options per query).

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

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

Schema description coverage is 100%, with both 'partNumber' and 'query' clearly documented (exact part number vs. free-text search). The description does not add meaningful parameter semantics beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Look up verified electronics component facts' and enumerates specific fact types (pin assignments, voltage range, package type, alternatives). This distinguishes it from siblings which focus on API lifecycle management (breaking changes, auth, 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 provides usage contexts: 'Use when wiring or reviewing a hardware design, selecting a substitute part, or checking a pin assignment before committing to a PCB layout.' However, it does not mention when not to use it or explicitly name alternative tools, so it falls short of a 5.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It reveals that the tool cannot complete payments, that a human must open the link, that credit appears within seconds, and that no card details reach the service. This is excellent transparency.

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

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

The description is concise (four sentences) and front-loaded with the primary action. The critical warning is emphasized with caps, and no sentence is redundant or wasteful.

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 no output schema, the description implies the return value ('Return the link to your operator') and explains the post-payment behavior ('Credit appears on the key within seconds'). This is sufficient for an agent to select and use the tool correctly.

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

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

Schema coverage for amountUsd is 100%, including range and common blocks. The tool description itself does not add any parameter-level nuance beyond the schema, which is acceptable given the schema is already self-explanatory. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function with a specific verb ('create'), resource ('secure Stripe checkout link'), and purpose ('to add prepaid credit to the calling API key'). It is distinct from all sibling tools, none of which handle payments or top-ups.

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

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

Explicit usage triggers are provided: 'Use this when a query has returned HTTP 402... or the balance is running low.' It also includes a clear limitation ('YOU CANNOT COMPLETE THE PAYMENT YOURSELF') and actionable guidance to return the link to the operator.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains that the tool returns 'spec-declared sunset dates and replacements' and explicitly notes that 'unstated fields are explicitly marked as unstated,' which is a useful transparency detail about output completeness. It implies a read-only scan without side effects, though it does not explicitly state auth requirements or whether it makes network calls. The exclusion of internal APIs adds boundary context.

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 compact—three sentences, each serving a distinct purpose: stating the core function, giving a usage trigger, and providing an output/behavior detail plus an exclusion. No filler words or redundant information. It is front-loaded with the primary purpose in the first sentence.

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

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

Given the simple parameter set (two optional strings/arrays) and no output schema, the description provides sufficient context: what it finds, when to use it, what it returns, and a boundary condition. It could elaborate on the return structure (e.g., whether output is a list of objects or a report) or whether both filters are combinable, but the current level is adequate for a low-complexity 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?

The input schema already provides descriptive coverage for both parameters (service and endpoints) with examples, achieving 100% schema coverage. The description does not add new parameter semantics beyond mentioning 'endpoints or parameters' as targets. Since the baseline for high schema coverage is 3, this is adequate; no additional syntax or constraints are needed.

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

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

The description opens with a specific verb and object: 'Find WHICH endpoints or parameters of a third-party API are deprecated, sunset dates, and replacement operations.' This clearly distinguishes the tool from siblings like factgrid_api_breaking_changes or factgrid_api_schema by focusing on deprecation scanning. The additional scope restriction ('Do NOT use for APIs in your own codebase') further differentiates it from internal API 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?

The description explicitly states when to use the tool: 'Use this before upgrading an API integration or auditing code for deprecated API calls.' It also provides a clear exclusion: 'Do NOT use for APIs in your own codebase.' While it doesn't name alternative sibling tools, the context makes the intended use case unambiguous and the exclusion implies an alternative exists for internal APIs.

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

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

With no annotations, the description carries the full transparency burden. It explains the result format: 'Returns matching services ranked by how many of their endpoints relate to the capability, with example endpoints', and clarifies that the actual callable shape comes from a follow-up tool, preventing misconceptions about the tool's scope. It does not explicitly state read-only behavior, but the 'discover' verb and return description imply a safe lookup.

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

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

The description is three sentences: purpose, use case, and exclusion/follow-up. It is front-loaded with the core function, every sentence earns its place, and it wastes no words.

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

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

Given the low complexity (one parameter) and no output schema, the description fully covers the tool's purpose, when to use it, what to expect, and how to proceed. It also clearly instructs to use a different tool when the API is already known, making it self-contained and complete.

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

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

Schema coverage is 100% with a clear description for the 'capability' parameter. The description adds valuable examples ('send an SMS', 'verify a phone number', 'create an invoice') that illustrate the expected input format, going beyond the schema's generic description.

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

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

The description opens with a specific verb+resource: 'Find WHICH third-party API can do something', clearly distinguishing it from sibling tools like factgrid_integration_brief and factgrid_api_schema. It also gives concrete examples of capabilities, making the scope unambiguous.

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

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

The description states exactly when to use it: 'Use this when you know the capability you need but not which provider offers it'. It explicitly names the alternative: 'Do NOT use when you already know which API you are calling — go straight to factgrid_integration_brief' and instructs to follow up with factgrid_integration_brief after discovery.

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

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

With no annotations, the description carries the full burden. It states that every field is 'read from the publisher's specification' and that unspecified rate limits or auth schemes are 'reported as unstated, never guessed', providing a clear behavioral policy. However, it does not explicitly mention side effects or failure modes, though 'read from' implies a non-mutating operation.

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 four sentences, each serving a distinct purpose: what it returns, when to use it, how it relates to a sibling tool, and a boundary condition. It is front-loaded with the core function and contains no filler or redundancy.

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

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

Given the simple two-parameter schema and absence of an output schema, the description is remarkably complete. It covers the tool's purpose, usage timing, alternative selection, output contents (base URL, auth scheme, parameters, request body, response codes), and sourcing accuracy policy. An agent has sufficient information to decide when and how to invoke it.

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

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

The input schema provides 100% coverage for both parameters: 'service' has examples and a description, and 'endpoint' is explained with an example. The description adds no extra parameter-level detail beyond what the schema already documents, so it does not exceed the baseline.

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 'Get everything needed to write ONE working call to a third-party API', clearly stating the tool's specific function. It also distinguishes itself from the sibling factgrid_api_schema by noting it 'returns the callable shape rather than a list of endpoints'.

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

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

The description explicitly tells the user when to use it: 'Use this BEFORE writing or repairing a call to an external HTTP API'. It also names the alternative and when to prefer it ('Prefer this over factgrid_api_schema when you intend to actually make the call') and provides an exclusion: 'Do NOT use for APIs in your own codebase.'

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

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

With no annotations provided, the description carries the full burden and excels: it discloses output format (findings with exact metadata field and before/after values), data source (registry metadata only), and limitations (no changelogs/source, behavioral changes out of scope). This is unusually transparent and goes beyond typical descriptions.

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, logically structured paragraph: purpose → output types → verification → limitations. Every sentence adds value, though the final phrase 'and it says so' is slightly redundant. It is dense but not bloated, earning a 4 rather than 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?

For a tool with no output schema and no annotations, the description adequately explains what the agent will receive (findings with before/after values) and what is excluded. It does not describe pagination, error handling, or rate limits, but for this scope, the information is sufficient. A 4 is appropriate.

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

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

The input schema already covers all four parameters with clear descriptions (registry enum, from/to versions, package name). The description adds contextual framing ('two published versions', 'npm or PyPI') but no additional syntactic or technical details beyond the schema, so it remains at the baseline for high schema coverage.

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

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

The description opens with a specific verb+resource+scope: 'Before upgrading an npm or PyPI dependency, find out what breaks.' It then enumerates exact breaking change types (yanked releases, exports map removal, CJS-to-ESM switches, etc.), making the tool's purpose unmistakable and clearly distinct from siblings like factgrid_api_breaking_changes.

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

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

It provides a clear usage context ('before upgrading an npm or PyPI dependency') and explicitly notes a limitation ('does not read changelogs or source, so behavioural changes are out of scope'), which serves as a when-not. However, it does not explicitly name an alternative tool for behavioral changes, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses key behavior: HTTP POST callbacks to webhookUrl when the API spec is published or auto-ingested. However, it omits details about subscription persistence, cancellation, authentication, or rate limits, which are important for a subscription tool.

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

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

Exactly two sentences: the first states the purpose, the second provides parameter guidance and an exclusion. Every word earns its place with no redundant content or unnecessary detail.

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

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

Given the simplicity (2 params, no output schema), the description covers purpose, usage, and scope effectively. It could mention what happens after subscribing or the response format, but these are not critical for basic 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 coverage is 100%, so the baseline is 3. The description adds value by explaining when the webhook fires ('when the API spec is published or auto-ingested') and restricting serviceName to third-party APIs, going beyond the schema's example-driven descriptions.

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

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

The description clearly states the tool subscribes to specification changes or auto-ingest updates for third-party APIs, using the specific verb 'Subscribe' and the resource (specification changes). It also distinguishes itself from sibling tools by explicitly scoping to third-party APIs and excluding own codebase.

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

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

Provides clear context on when to use (receive callbacks on spec publication/auto-ingest) and explicitly states a non-use case ('Do NOT use for APIs in your own codebase'). However, it does not name alternative tools from the sibling list, slightly reducing guidance.

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