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

Annotations already indicate the tool is not read-only and not destructive. The description adds value by stating the auth requirement (NEMESIS_API_KEY) and the consequence ('so it is ready to enforce'), which goes beyond the annotations. However, it doesn't disclose whether the action is reversible or if it replaces previous approvals, though destructiveHint=false covers overall safety.

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

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

The description is two sentences, with the primary action front-loaded. Every sentence carries essential information: what it does, when to run it, and a prerequisite. No extraneous content.

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 tool with one parameter and no output schema, the description covers the action, timing, and auth. It could mention expected return or edge cases (e.g., no learned behaviors), but these are minor gaps. The workflow context and parameter provenance make it reasonably complete.

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

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

Schema description coverage is 100% for the single parameter appId, which already explains it comes from nemesis_create_app or nemesis_list_apps. The description adds no further parameter-specific meaning, so the baseline of 3 applies.

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

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

The description clearly states the tool's function: 'Approve all learned behaviors for an app so it is ready to enforce.' It uses a specific verb (approve) and identifies the resource (learned behaviors for an app), and distinguishes itself from sibling tools by placing it in the create → learn → approve → enforce loop.

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

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

The description provides explicit when-to-use guidance: 'Run after the app has seen traffic or after nemesis_run_learn.' It also gives a prerequisite (requires NEMESIS_API_KEY) and frames the tool within a workflow, making it clear when this should be invoked relative to other tools.

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

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

The description adds behavioral context beyond the annotations: it returns an install token (nsk_), requires the NEMESIS_API_KEY env var, and positions the action as the first step in a protection workflow. Annotations already declare readOnlyHint=false, consistent with 'create'. No contradiction found, and the additional details (auth, output) are useful.

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 action, and includes only necessary information: what it does, the output, workflow context, and a requirement. No redundant phrasing.

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 create tool with no output schema, the description covers the essential aspects: the operation, the return token, the next step, and the environment prerequisite. It doesn't address failure modes or idempotency, but given the two-parameter schema and annotations, it is sufficiently complete for an agent 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?

Schema coverage is 100% with both parameters (name and kind) already described in the schema. The description's mention of 'app/API/LLM' loosely aligns with the kind enum but adds no new parameter semantics. Therefore, it meets the baseline but doesn't exceed it.

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+resource: 'Create a Nemesis Shield app in the developer's account and return its install token (nsk_)'. This clearly distinguishes the tool from siblings like nemesis_list_apps (listing) and nemesis_protect (protecting), and explicitly mentions the return value.

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 workflow context: 'This is the first step to protect an app/API/LLM: create it, then add the one-line SDK.' It also specifies a prerequisite (NEMESIS_API_KEY env var). It doesn't explicitly name alternative tools, but the guidance is sufficient for selecting this over siblings.

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

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

The description discloses a required dependency: 'Requires NEMESIS_API_KEY', which is beyond the annotations. It also explains the behavior of pre-loading rules based on sector/event, adding context. Annotations provide readOnly/destructive hints but do not cover auth or the functional logic, so the description adds meaningful value.

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 well-structured: main purpose first, then usage guidance, then enumerated options. The lists of sectors and events are necessary and not padded. It could be slightly shorter, but every sentence earns its place and the examples make it more accessible.

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 3 parameters and no output schema, so the description needs to cover purpose, parameters, and prerequisites. It does so, including API key and the catalog tip. It does not specify return values, but for a creation tool with no output schema, this is not a major gap. Overall, it is complete enough for an agent to invoke 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 is 100% with basic parameter descriptions. The description significantly enhances this by enumerating all valid sectors and events (which the schema only calls 'key') and explaining how they affect the generated rules. For example, it clarifies 'fintech+transfer gets AML/money-mule rules'. This adds value beyond the schema.

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

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

The description uses a specific verb and resource: 'Create an Omniguard business-logic firewall for money & accounts'. It clearly explains what the tool does (pre-loading fraud rules for the developer's sector/event) and distinguishes itself from sibling tools like nemesis_omniguard_catalog by positioning itself as the creation tool and the catalog as a prerequisite.

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 guidance is provided: 'Call nemesis_omniguard_catalog first if unsure which to use'. This names the alternative tool and gives a clear condition. Additionally, examples (ecommerce+checkout vs fintech+transfer) illustrate when to use which sector/event combination, so an agent knows how to select parameters.

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 mark readOnlyHint, but the description adds valuable behavioral context: the status lifecycle (pending until nameservers delegated, then active) and the API key requirement. This goes beyond what annotations alone communicate, enriching the agent's understanding of the tool's 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 a single sentence that is front-loaded with the action and resource, includes essential status details and auth prerequisite, and contains no redundant or vague wording.

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 zero-parameter read-only listing tool, the description is complete: it explains what is listed, the meaning of the statuses, and the required authentication. No output schema exists, but the return values are self-explanatory given the list semantics.

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

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

The tool has zero parameters, so there is no parameter semantics for the description to clarify. Per the rubric, a baseline of 4 is appropriate when no parameters exist.

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

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

The description uses a specific verb 'List', identifies the resource 'domains behind Nemesis Edge', and specifies scope 'for the developer's account' with status. This clearly distinguishes it from sibling tools like nemesis_provision_edge or nemesis_protect.

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

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

The description implies when to use it: to view domains and zone status for the account. It also states the prerequisite of NEMESIS_API_KEY, giving clear context. However, it does not explicitly name alternatives or say when not to use it, unlike some sibling-differentiating descriptions.

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 and openWorldHint=false, so the description adds value by explaining the explanatory purpose and the topic list. It does not contradict annotations and provides contextual framing beyond the structured data.

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 reasonably short, but it repeats the topic list twice (once in parentheses and once after 'Topics:'), which is redundant. The core guidance is useful, but the duplication detracts from conciseness.

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

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

For a simple read-only explanation tool with one parameter and no output schema, the description covers the tool's purpose, usage context, and accepted topics. It lacks explicit statement about whether only the listed topics are allowed, but this is a minor ambiguity 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 schema covers the 'topic' parameter with examples, but the description adds the full list of topics (including edge and privacy) and clarifies that the parameter should be one of these security topics, enhancing the schema's example-based definition.

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 explains how Nemesis Shield covers a security topic, lists the specific topics, and distinguishes it from action-oriented sibling tools like nemesis_protect and nemesis_scan.

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

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

It provides explicit usage guidance—'Use it to answer "why" or "what does it stop"'—which clarifies when to invoke it. However, it doesn't mention when not to use it or explicitly compare to 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?

Annotations already mark readOnlyHint=true, so safety is known. The description adds value by disclosing the NEMESIS_API_KEY requirement and the specific fields returned (mode, baseline readiness), which goes beyond the minimal read-only hint.

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

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

Two sentences, front-loaded with the primary action and enough detail to be useful. No fluff or redundant statements.

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

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

For a simple list tool with no parameters and no output schema, the description covers the purpose, scope (developer's account), auth requirement, and key output fields. 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?

There are zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and none are present to document.

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 starts with a specific verb and resource: 'List the apps in the developer's Shield account.' It further clarifies the output (mode and baseline readiness), and distinguishes itself from sibling tools like nemesis_list_frameworks by explicitly targeting apps.

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 context is clear: use this to list Shield apps. However, it does not explicitly mention alternatives or when not to use it, such as pointing to nemesis_list_frameworks for frameworks or create_app for creating apps.

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 readOnlyHint annotation already communicates that this is a safe read operation. The description adds the specific scope ('every framework/stack') and the 'one-line integration' detail, but no additional behavioral traits such as output shape or potential edge cases. Since annotations cover the safety profile, a mid-range score is appropriate.

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

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

The description is a single, concise sentence that front-loads the verb ('List') and directly states the resource. No extraneous words; every word adds value. This is exemplary conciseness.

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

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

Given the tool's simplicity (no parameters, no output schema, read-only annotations), the description is almost complete. It could be slightly enhanced by explicitly stating what the returned list looks like (e.g., 'returns an array of framework names'), but the verb 'List' strongly implies that. Overall, sufficient 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 is empty (0 parameters), so there are no parameter semantics to clarify. The description is clear about the operation's scope, which serves the same purpose. Baseline for no parameters is 4, and the description fully compensates for any lack of schema 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 uses a specific verb ('List') and clearly identifies the resource ('every framework/stack Nemesis Shield has a one-line integration for'). This clearly distinguishes it from sibling tools like nemesis_list_apps or nemesis_omniguard_catalog, which target different resources.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It doesn't mention exclusions or direct users to sibling tools for related tasks. The context is clear but not actionable for selecting among the many sibling tools.

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 readOnlyHint annotation already signals it's read-only; the description adds the behavioral detail that passing a description returns a suggested sector+event. It doesn't describe output format or limitations, but for a simple catalog this adds sufficient transparency.

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

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

The description is two sentences, front-loaded with the main action, and every word earns its place. No redundancy or filler.

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

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

For a one-optional-parameter, read-only tool with no output schema, the description fully covers what it does, when to use it, and what the parameter does. An agent has enough to invoke it correctly.

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

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

Schema coverage is 100% and the schema describes the parameter well ('What they're building'), but the description adds the effect of the parameter (get a suggested sector+event), which is meaningful beyond the schema and helps the agent understand how to use it.

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 specific verbs ('List') and resources ('Omniguard sectors and events'), explains the purpose (pick the right business-logic firewall), and differentiates from siblings by emphasizing it's a read-only catalog plus optional suggestion. It clearly states what the tool does.

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

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

The description provides clear context for when to use the tool ('for what the developer is building') and explains how the optional 'describe' parameter feeds into a suggestion. It doesn't explicitly mention when not to use it or name alternatives, so it falls just short of a full 5.

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

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

The description adds important behavioral context beyond the annotations: it discloses the dry_run default (no metering/persistence), the need for specific credentials, and the expected risk signals. This goes beyond the readOnlyHint/openWorldHint/destructiveHint flags, though it doesn't detail live-mode side effects beyond what the schema notes.

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

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

The description is concise and well-structured: it leads with the purpose, then the default behavior, then dependencies, and finally input guidance. Every sentence serves a clear function with no redundant or vague filler.

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

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

For a tool with a nested transaction object, no output schema, and moderate complexity, the description covers the key aspects: what it does, how to invoke it, what inputs are expected, and the default safety mode. It could be more explicit about the exact response format, but the allow/review/block outcome is implied.

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 parameters with descriptions (100% coverage), but the description enriches the 'transaction' object by listing the key risk signals (amount, country vs card_country, card_type, etc.) that the rules check. This adds meaning beyond the schema's example.

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

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

The description clearly states the action ('Score a transaction against an Omniguard function') and the result categories (allow/review/block). It is specific and uses a distinct verb, but it does not explicitly differentiate from sibling tools or name an alternative for similar tasks.

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

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

The description provides clear usage context: it is for testing business-logic rules end to end, defaults to dry_run, and notes the prerequisite of having an ingest token and function ID from nemesis_create_omniguard. It does not explicitly state when not to use this tool or mention alternative tools for other scenarios.

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

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

Annotations already indicate readOnlyHint=true, and the description is consistent with that (it returns a snippet, not mutating anything). The description adds valuable context beyond the annotations by explaining what Nemesis Shield is ('positive-security firewall') and what the snippet does ('add runtime security'). It does not disclose potential error behavior for unsupported frameworks, but given the read-only nature, it is sufficiently transparent.

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

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

The description is front-loaded with the primary purpose in the first sentence, followed by a brief product explanation and usage guidance. It is efficient, with no wasted sentences, though the supported-frameworks list adds length. Overall, it is well-structured and appropriately sized for the tool.

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

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

For a simple one-parameter tool, the description is fairly complete: it explains the output ('one-line snippet'), when to use it, and which frameworks are supported. There is no output schema, but the description gives a good idea of what to expect. It could be more explicit about the exact return format or error handling for invalid frameworks, but that is a minor gap given the tool's simplicity.

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

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

Schema coverage is 100%: the 'framework' parameter has a description listing the same frameworks as the tool description. The description repeats this list but does not add new meaning beyond what the schema already provides. The baseline for high schema coverage is 3, and the description does not elevate it further.

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

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

The description clearly states the tool's purpose: 'Return the exact, verified one-line Nemesis Shield install + integration snippet to add runtime security.' This is a specific verb ('Return') and resource ('snippet'), and it distinguishes itself from siblings like nemesis_scan and nemesis_explain by focusing on generating an integration snippet. The phrase 'Call this whenever you scaffold or extend a web app, API, or LLM feature' further reinforces the purpose.

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

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

The description gives explicit when-to-use guidance: 'Call this whenever you scaffold or extend a web app, API, or LLM feature.' It also enumerates supported frameworks, which helps the agent decide if this tool is appropriate. However, it does not mention when not to use it or explicitly point to alternatives like nemesis_protect_llm, so it lacks full exclusions or alternative guidance.

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

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

The description adds significant behavioral context beyond the annotations: it discloses that the tool creates an app (side effect), returns a token, and requires an API key. This complements the readOnlyHint=false and openWorldHint=true annotations without contradicting them.

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

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

The description is extremely concise, consisting of two sentences that immediately state the purpose, mechanism, and requirement. Every clause 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?

Given the simple one-parameter schema, the presence of annotations, and the description covering purpose, side effect, output (token), and prerequisites, the tool definition is fully complete for an agent to select and invoke correctly. No output schema exists, but the token return is explicitly stated.

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 single parameter 'name' is fully described in the schema with an example ('support-chatbot'). The description does not add any parameter semantics beyond what the schema already provides, so it meets the baseline of 3.

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

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

The description uses a specific verb ('Protect') and resource ('LLM feature' via an 'llm-kind Shield app'), clearly distinguishing it from siblings like nemesis_protect or nemesis_create_app. It also explicitly describes the action (creates an app and returns a token) and the intended use (wrapping model calls).

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

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

The description provides clear context: it is for protecting LLM features, requires NEMESIS_API_KEY, and describes the follow-up step of wrapping model calls. However, it does not explicitly mention when not to use it or name alternative tools, so it lacks explicit exclusion guidance.

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

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

The annotations already indicate not read-only and not destructive. The description adds valuable context beyond annotations: it mentions the requirement for NEMESIS_API_KEY and explains the two possible return outcomes (nameservers vs TXT record) based on domain existence. This gives the agent a clear picture of the tool's behavior and prerequisites.

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

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

The description is three sentences, front-loaded with the primary action, followed by a concise explanation, return values, and a prerequisite. Every sentence contributes meaningful information without redundancy or filler.

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

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

Given the tool's simplicity (single parameter, no output schema) and the quality of annotations, the description is complete: it explains what the tool does, what it returns, and what is required. No critical information for invocation 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 input schema provides 100% coverage for the single 'domain' parameter, with a clear description. The tool description adds little extra parameter-level meaning, only referencing the domain in the context of existing vs. new domains. This matches the baseline for full schema coverage.

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

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

The description clearly states the tool provisions a domain behind Nemesis Edge, a specific action with a clear resource and scope. It distinguishes itself from siblings by describing the unique outcome (returning nameservers or TXT record) and the context of the positive-security DNS layer.

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

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

The description provides clear context for when to use this tool: when putting a domain behind Nemesis Edge. It also explains the conditional behavior for existing domains via the return value note. However, it does not explicitly reference alternatives or exclusion scenarios, 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?

While annotations indicate non-read-only and open world behavior, the description adds specifics: 'locally' scopes the execution, and the token requirement ('needs the app token (nsk_)') is disclosed. This clarifies the prerequisites and reduces ambiguity about external effects.

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

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

Two sentences, front-loaded with the verb, no redundant words. Covers purpose, usage context, and token requirement efficiently.

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 run tool with no output schema, it explains the workflow, environment, and follow-up tools. It doesn't describe return values, but that's acceptable given no output schema and clear purpose.

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 covers all parameters with 100% coverage, so description contributions are bonus. It adds the env var fallback ('set NEMESIS_TOKEN in the env') for appToken, giving extra semantic detail beyond the schema.

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

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

The description clearly states it 'Run the Nemesis Learn agent locally to exercise every route of your app', specifying the action, resource, and goal. It differentiates from siblings by focusing on the Learn agent for route exercising, distinct from scanning or protecting.

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 context: use this in dev/staging to speed up baseline creation 'instead of waiting on real traffic'. It also gives follow-up steps ('Then call nemesis_approve_routes and nemesis_set_mode enforce'), though it doesn't explicitly list when not to use it.

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

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

The description goes beyond the readOnlyHint annotation by adding specificity: 'only reads what a browser could see' and 'Version detection is best-effort' disclose reliability and access limitations. It also clarifies that CVEs are 'real published' and that the scan is passive. These are valuable behavioral details beyond the annotations.

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

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

The description is three sentences, each with a clear purpose: stating the main function, reinforcing safety/behavior, and providing version guidance plus a pointer for deeper reports. There is no redundant or filler content; every sentence earns its place.

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

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

Despite lacking an output schema, the description enumerates the key return elements (detected stack, CVEs, Nemesis protection status). It also covers version handling and points to a deeper report for additional compliance needs. It does not detail error scenarios or output structure, but for a simple scan tool with good annotations, this is nearly complete.

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

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

The schema already fully describes both parameters (url and version) with 100% coverage. The description's mention of passing the known version to sharpen the CVE match largely mirrors the schema's description for the version parameter, adding no new semantic information. Hence 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 tool's purpose with a specific verb and resource: 'Passively fingerprint a public website or API URL' and lists the three outputs (detected stack, CVEs, Nemesis protection status). This distinguishes it from sibling tools like nemesis_protect or nemesis_explain, which serve different functions.

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

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

The description provides clear context on when to use the tool (for a quick, passive, browser-level scan) and directs users to an external URL for a deeper compliance/PCI report. However, it does not explicitly state when not to use it or compare it to sibling 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?

The description adds concrete side effects beyond the annotations: it installs a systemd unit, enrolls the host, auto-discovers apps, and mints a key. It also notes the API key requirement and root execution. These details enrich the annotations' readOnlyHint=false and destructiveHint=false without contradicting them.

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

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

The description is front-loaded with the core purpose, then the exact command flow, then the required API key. Every sentence adds value and there is no wasted wording. The structure is clear and guides the agent through what happens.

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 one optional parameter and no output schema, the description is thorough: it explains the outcome (install command), the runtime steps (systemd, enrollment, auto-discovery), and the follow-up action (apps appear in nemesis_list_apps). It gives a complete mental model of use and results.

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

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

The schema covers 100% of the single optional label parameter with a clear description and example. The tool description itself does not mention the label parameter, but the schema already provides sufficient semantics, so the baseline score of 3 applies.

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

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

The description clearly states the tool protects an entire server by enrolling it with the Nemesis host agent, mints an enrollment key, and returns a one-line install command. It distinguishes itself from sibling tools by focusing on whole-server host-agent enrollment and auto-discovery of apps, rather than individual app or LLM protection.

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 clear usage context: run on the server as root, requires NEMESIS_API_KEY, and the resulting apps show up in nemesis_list_apps for approval. It does not explicitly contrast with sibling tools or state when not to use it, 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?

Discloses that 'observe' means 'learn, block nothing', 'enforce' means 'block deviations', and that enforce has a readiness gate (approved baseline) unless overridden. Consistent with destructiveHint=true and readOnlyHint=false, and adds context beyond 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 sentences, front-loaded with purpose, efficient. No redundant information. Every phrase 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 3-parameter tool with no output schema, the description covers essential usage: what the tool does, mode meanings, prerequisites, and a conditional requirement. Could mention what 'alert' does, but it's implied, and the tool is simple enough that the description is adequate.

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

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

Schema covers all parameters, but the description adds semantic value by explaining the mode enum values ('observe (learn, block nothing)', 'alert', 'enforce (block deviations)') and the force parameter's effect on the enforce-readiness gate. This goes beyond the basic schema 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's function: 'Set a Shield app's enforcement mode' with specific mode values and their effects. It distinguishes from sibling tools like nemesis_protect, nemesis_scan, etc., by focusing on enforcement mode configuration.

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 usage context: mode options, the requirement for an approved baseline when using 'enforce' unless force=true, and the NEMESIS_API_KEY prerequisite. Doesn't explicitly mention when not to use or alternatives, but offers enough context for correct invocation.

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