Simceptor

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

No annotations are provided, so the description carries the full behavioral burden. It says the tool adds a comment and mandates post-fix use, but it does not disclose permissions/auth needs, notification side effects, whether the issue must be open, or what the call returns.

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 action and followed by the trigger. Every sentence adds useful routing or workflow information, with no filler.

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

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

For a simple two-parameter comment-creation tool with no output schema or annotations, the description is mostly complete: it covers the action and when to call it. Minor gaps remain around return confirmation and any constraints on commenting on closed issues.

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

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

Schema description coverage is 100%, so both parameters are already documented in the input schema. The description adds no extra parameter semantics such as content formatting or slug-id validation beyond what the schema provides.

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

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

The description gives a specific verb and resource: 'Add a new comment/response to an issue thread.' That is clear enough to distinguish it from issue tools like resolve_issue or get_issue, though it does not explicitly name or contrast those siblings.

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

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

It clearly states the trigger for use: call this whenever finishing or addressing an issue, with a descriptive comment about what changed. It gives no exclusions or explicit alternatives such as resolve_issue, so it falls short of a full when/when-not treatment.

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, and it discloses little: 'Append' implies persistent mutation but nothing is said about error behavior for a missing mockId, whether the rule can be undone, or whether the created rule is returned. It also omits that rule ordering/evaluation semantics matter, leaving that entirely to nested schema text.

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

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

Two short sentences with the action front-loaded and no filler. The second sentence is the weakest part, since 'Token-efficient partial update' is an unsubstantiated marketing fragment rather than 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 mutation tool with nested-object parameters, no annotations, and no output schema, the description is thin: it neither describes the result of the append nor the failure modes. The rich schema compensates for the parameter detail, but the behavioral framing an agent needs before writing is 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 100% and the nested rule object is exhaustively documented (operators, conditionLogic, priority, webhook options). The description itself adds nothing about projectId, mockId, or the rule payload, so the baseline 3 applies.

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

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

States a specific verb ('Append') and resource ('a new conditional rule to an existing mock API endpoint'), which clearly separates it from remove_mock_rule and update_mock by implication. It does not explicitly name those siblings, so an agent must infer the boundary rather than being told.

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 is the fragment 'Token-efficient partial update,' which vaguely hints at preferring this over update_mock but never names an alternative or a condition for choosing it. There is no statement of prerequisites (mock must already exist) or when this tool should not be used.

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 behavioral burden, yet it says nothing about atomicity (all-or-nothing vs partial creation), validation or conflict handling for duplicate paths/methods, limits on batch size, permissions, or what the response returns. For a bulk mutation tool this is a significant gap.

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

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

A single front-loaded sentence with zero wasted words. The terse size is appropriate because the very large nested schema carries the configuration 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 this is an unannotated bulk mutation with no output schema, the description is too thin: it omits atomicity, error behavior on partial failure, batch limits, and how created mocks are returned or named in collections. The schema covers fields but not operational behavior.

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%, and the nested mock/rule schemas are richly documented, so the parameters are already well explained by the schema. The description adds no parameter-level meaning beyond that baseline, which is appropriate for a 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 states a specific verb ('Create'), resource ('mock API endpoints'), batch scope ('multiple ... at once'), and location ('under a project workspace'). This implicitly differentiates it from the single-item sibling create_mock, though it does not name the alternative explicitly.

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

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

Only the phrase 'at once' hints at batch usage; there is no explicit guidance on when to prefer this over create_mock, whether it replaces or supplements repeated single creates, or any prerequisites such as the project existing. No exclusions or alternatives are named.

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 exist, so the description carries the full behavioral burden and largely meets it: it discloses that a false result requires a user-supplied PAT with the 'Local Webhook Relayer' scope, forbids the agent from generating or reading the token itself, and warns that running the CLI opens a persistent background tunnel that must be manually killed. It also implies the return carries an 'active' boolean, which is the only output the agent needs to branch on.

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, then the mandatory precondition, then outcome-specific instructions — a sensible ordering. It runs long and drifts into operational detail (the npx command line, dashboard navigation path) that could be trimmed, but each sentence does influence the agent's next action rather than padding.

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 no-parameter status check with no output schema and no annotations, the description supplies everything an agent needs: when to call it, what each result means, the URL scheme to use on success, and the full remediation path plus safety disclosure on failure. Nothing material is left for the agent to guess.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain — the baseline for a 0-param tool. The description correctly adds nothing spurious about inputs and keeps focus on the outcome.

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

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

States a specific verb and resource — checking whether an active Local Webhook Relay session (WebSocket tunnel) exists — and immediately ties it to its only relevant sibling action, setting webhookUrl on a mock. No other tool in the sibling list touches relay/tunnel state, so the distinction is 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?

Explicit routing rule: 'ALWAYS call this tool before setting webhookUrl on any mock if the user is working locally or might want local delivery.' It then branches on both outcomes (active=true → use simceptor://local/<path>; active=false → PAT flow), including the sub-branch for shell access vs. hosted connector. This is about as close to a decision tree as a tool description gets.

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 behavioral burden. It usefully discloses the postcondition ('the rule will always fire its normal response... no more probabilistic behavior'), but omits error behavior (e.g., what happens if no chaos exists), idempotency, and permission requirements.

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

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

Two sentences with zero waste. The core action is front-loaded and the postcondition follows immediately.

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 mutation tool with no annotations and no output schema, the description explains the intended effect well but does not cover return values, error cases, or permission context. It is adequate but leaves notable gaps an agent might need.

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

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

Schema description coverage is 100%, so the three parameters are already fully documented in the schema. The description adds no parameter-level syntax, format, or usage details beyond what the schema provides, which is acceptable at baseline 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?

States a specific verb and resource: 'Remove Rule-level Chaos from a specific conditional rule.' It implicitly distinguishes rule-level chaos from traffic-level chaos via the 'Rule-level' qualifier, but does not explicitly name the sibling tool clear_traffic_chaos.

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 by naming the action and effect, but offers no explicit guidance on when to prefer it over alternatives such as set_rule_chaos or clear_traffic_chaos. No exclusions or prerequisites are mentioned.

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 and does disclose two important traits: the operation is destructive ('completely remove') and the resulting state is normal rule evaluation. It stops short of stating whether the call is idempotent or what happens when no chaos config exists.

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, zero waste, with the action front-loaded and the consequence in the second sentence where it belongs.

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 mutation with no annotations and no output schema, the description covers what changes and what the system looks like afterwards. Missing only edge-case behavior (no-op vs error when chaos is absent) and any permission notes.

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% and both parameters (mockId, projectId) are documented in the schema, so the description needs to add nothing. It adds nothing — baseline 3 applies.

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

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

States a specific verb pair ('disable and completely remove') and a specific resource ('Global Traffic Chaos configuration' for a mock), which distinguishes it from set_traffic_chaos and get_traffic_chaos_status. It does not explicitly contrast with the closely named sibling clear_rule_chaos, so an agent must infer the global-vs-rule scope distinction.

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 post-condition sentence ('all requests will be served normally through the standard rule evaluation pipeline') implies the use case: restoring normal behavior. But it never states when to prefer this over set_traffic_chaos (e.g., disable without removal) or clear_rule_chaos, nor does it note any prerequisite of having chaos configured.

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 behavioral burden. It discloses important behavior — rule evaluation order, first-match-wins, fallback to top-level response, auto-creation of missing collections, and stateful simulation — which is valuable. But it omits other mutation-relevant behavior: permissions/auth requirements, what happens when a mock with the same method+path already exists, whether creation is idempotent, and how webhook failures are handled.

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 creation action, then the most important configuration guidance (rules), then stateful simulation. Every sentence covers substantive behavior. It is dense and the emphasis via capitalization and dashes is useful, though the rule-engine paragraph is somewhat long relative to the rest.

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 22-parameter mutation tool with no annotations and no output schema, the description covers the most complex feature (rule engine/stateful simulation) well, and the schema is extremely detailed. However, it does not address creation lifecycle concerns an agent would want to know: uniqueness constraints on path/method, error/side-effect behavior on creation, or auth prerequisites. Those gaps make it adequate but not complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by emphasizing the priority ordering and fallback semantics of rules, and by adding behavior not explicit in the schema: 'If collectionName is provided but doesn't exist, it will be auto-created.' It also frames stateLookupExpr/stateCaptureExpr around a concrete use case (stateful database simulation), which aids correct usage.

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

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

The description opens with a specific verb and resource: 'Create a new mock API endpoint in a project.' That is unambiguous about what gets created. However, it never distinguishes this tool from sibling creation tools such as 'bulk_create_mocks' or 'add_mock_rule', so it stops short of the sibling differentiation required for 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 gives strong prescriptive guidance for the 'rules' field ('Always use the rules field') and explains the rule engine's purpose and fallback behavior, which is genuine usage context. What's missing is explicit guidance on when to choose this tool over 'bulk_create_mocks', or any when-not-to-use conditions.

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

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

With no annotations, the description carries the full burden and largely delivers: it discloses that each project receives a unique slug, that the slug drives request routing through the mock engine at a stated URL pattern, and it warns against hand-constructing URLs because sibling responses expose a real mockUrl. It omits permissions/auth, whether project names must be unique, and what state a new project starts in (e.g. empty mock list).

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 action and resource, then the slug/routing consequence. The final sentence about mockUrl is slightly tangential to a create operation but is a genuinely useful caution, so it earns most of 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?

There is no output schema, so the description should describe what comes back; it only implies a slug is returned. It also leaves open whether creating a project is idempotent, whether names are unique, and any auth or quota constraints — gaps an agent would want filled for a create tool with no annotations.

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

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

Schema coverage is 100%, so all three parameters (name, userNotes, description) are already documented with examples and purpose. The description adds no parameter-level detail such as slug derivation from name or character constraints, so the baseline 3 applies.

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

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

States a specific verb and resource ('Create a new project workspace') and adds the purpose ('organizing and mocking API endpoints'), which distinguishes it from create_mock and list_projects. It stops short of naming adjacent alternatives explicitly, but the resource is 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 intent ('organizing and mocking API endpoints') implies when to reach for it, and the warning about not hand-building URLs implies a usage pattern downstream. However, there is no explicit when-to-use vs. when-not, and no mention of list_projects, create_mock, or import_project as 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes inspection and simulation, but does not state whether the operation is read-only, whether it alters mock rules or state, what permissions are required, or what the trace output includes.

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 efficient sentence with the diagnostic purpose front-loaded. It is appropriately sized, though the slashed 'simulate/evaluate' phrasing is slightly dense.

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 2-parameter tool with complete schema coverage, the description identifies the diagnostic purpose but omits usage alternatives and behavioral details such as mutability and output shape. It is minimally viable but leaves gaps because there are no annotations or output schema to compensate.

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

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

Schema description coverage is 100%, so projectId and mockId are already fully documented in the schema. The description does not add parameter-level meaning beyond the schema, making the baseline 3 appropriate.

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

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

The description states a specific diagnostic action on the latest request log and mock rule conditions, so the tool's purpose is clear. It does not explicitly differentiate itself from siblings like get_request_logs or test_mock, which keeps it below a 5.

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

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

The phrase 'to diagnose mismatches' gives an implied use case, but the description does not explicitly say when to use this tool versus get_request_logs, test_mock, or get_mock_detail. It provides context without clear alternatives or exclusions.

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 present, the description carries the full burden and does disclose the critical trait: deletion is permanent and cascades to all rules and request logs. It omits remnants like required permissions, irreversibility confirmation, or error behavior on an unknown ID.

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

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

Two short sentences with zero waste, front-loading the permanence warning before the cascade detail. Nothing is padded or redundant.

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 destructive tool with no annotations and no output schema, the description covers the essentials an agent needs: what is removed and that it cannot be undone. It stops short of confirming return/error behavior or permission prerequisites.

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

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

Schema description coverage is 100%, so projectId and mockId are already documented in the schema. The description only hints at the project scoping relationship and adds no format or constraint meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Permanently delete a mock API endpoint from a project') with clear scope. It is readily distinguishable from siblings like delete_project, update_mock, or remove_mock_rule without opening any schema.

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

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

The word 'Permanently' signals this is a destructive action rather than an update, which implies usage. However, it never names alternatives (e.g., update_mock to modify, remove_mock_rule to drop only rules) or states when deletion is inappropriate.

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

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

With no annotations at all, the description carries the full behavioral burden and does disclose the two things an agent most needs: the operation is irreversible ('Permanently') and it destroys an enumerated set of child resources. It stops short of stating authorization requirements, confirmation needs, or what happens to in-flight state on failure.

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?

One sentence, front-loaded with the destructive verb and resource, then the blast radius. Nothing is redundant or padded.

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-parameter destructive tool with no annotations and no output schema, the description covers the essential facts: irreversibility and what is destroyed. It is slightly thin on authorization and failure behavior, which an agent might need before invoking a permanent delete.

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% and the single projectId parameter is already documented as 'Database ID of the project to delete'. The description adds no format, range, or lookup guidance beyond that, so the schema does all the work and baseline 3 applies.

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

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

The description pairs a specific verb ('Permanently delete') with a precise resource ('an entire project workspace') and enumerates the cascading scope (collections, mock endpoints, rules, request logs). That scope statement makes it distinguishable from the narrower delete_mock and delete_state siblings without needing to open any schema.

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

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

Usage is only implied by the word 'Permanently' and the breadth of the cascade; there is no explicit when-to-use vs when-not guidance, no mention of the alternative of removing individual resources, and no stated preconditions such as required ownership or permissions.

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 must carry the full behavioral burden. It does signal a destructive operation and reveals the backing store (Redis), but says nothing about whether deletion is idempotent, what happens if the sessionKey is absent, whether the project's other state is affected, or any permission requirements.

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

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

A single front-loaded sentence with zero filler; the destructive verb leads and the scope qualifier follows immediately.

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 2-parameter mutation with no output schema, the definition is barely adequate: it omits the outcome of the call (success indicator, behavior on a missing key) and any interaction with sibling state tools, which matters for a destructive operation carrying no annotations.

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

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

Schema description coverage is 100%, so both projectSlug and sessionKey are already documented in the schema. The description adds no format, scoping, or example detail beyond what the schema provides, which is the baseline expectation.

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?

Uses a specific verb pair (Clear/Delete) with a precise resource (session state stored in Redis for stateful simulation). An agent can distinguish this from set_state/get_state without opening any schema, though the description never names those siblings explicitly.

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

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

Usage is only implied via 'for stateful simulation' — the reader must infer that this applies to sessions created by set_state. There is no explicit when-to-use, when-not-to-use, or named alternative (e.g., that leaving state intact is the default).

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 usefully discloses scope (all configuration categories) and the output shape (portable JSON), but says nothing about whether the operation is non-destructive, whether sensitive data like webhook secrets is included, size limits, or permissions.

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

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

A single front-loaded sentence that names the action, the scope, the contents, and the output format with zero 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 single-parameter, non-destructive read tool, the definition is nearly complete — it states content scope and return format even without an output schema. The remaining gap is the unspecified internal structure of the JSON and any side conditions such as secret inclusion.

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?

Only one parameter and schema coverage is 100%, so the schema already explains projectId fully. The description adds no format or constraint details beyond it, so the baseline 3 applies.

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

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

Specific verb 'Export' plus the resource 'entire project configuration', with an explicit enumeration of what's included (collections, mocks, webhooks, rules). It does not name import_project as the inverse sibling, but the verb/resource pairing makes the distinction obvious without opening a 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?

There is no explicit when-to-use or when-not-to-use guidance and no reference to import_project or other alternatives. The usage is implied by the word 'Export' rather than stated.

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

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

No annotations exist, so the description carries the full burden. 'Retrieve' implies a read-only operation and the token-efficiency hint helps, but there is no disclosure of behavior on a missing/invalid slug, permission requirements, or what 'details' comprises.

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

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

Two short sentences with the core action front-loaded and the optional-parameter tip second. Nothing is wasted or buried.

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 two-parameter read tool with full schema coverage and no output schema, this is minimally adequate. It still leaves 'the details' undefined and says nothing about error behavior, which an agent would want when calling by slug.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description's includeComments guidance essentially restates the schema text ('omit full conversation comments for token efficiency') rather than adding new meaning, so the baseline 3 applies.

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

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

States a specific verb (Retrieve) and resource (details of a specific issue), which is enough to distinguish it from list_issues and list_open_issues_for_mock. It stops short of naming those siblings explicitly, so it doesn't earn 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?

Usage is only implied: 'a specific issue' suggests you need a known issueSlugId, but the description never says when to prefer this over list_issues or how to obtain the slug. The includeComments note is parameter advice, not tool-selection 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?

No annotations are supplied, so the description carries the full disclosure burden. 'Look up' implies a non-destructive read, but the description never states what is returned (full mock definition vs. summary), how a missing/invalid slug is surfaced, or whether any auth/scope applies — meaningful gaps for an unannotated 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?

A single front-loaded sentence with no filler; the key identifier and the example appear immediately, and the clarifying benefit is stated last where it reads as a qualifier rather than preamble.

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 one required parameter is fully documented and the lookup key is unambiguous, but with no annotations and no output schema the description should say what the call yields (full mock object, rules, project linkage) and what happens on a slug miss. For a simple read it is callable, but the result contract is missing.

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

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

Schema description coverage is 100% and the single parameter already documents the slugId format with an example ('MOCK-5cbb91d3'). The description repeats that same example rather than adding new semantics such as case sensitivity or accepted slug variants, so baseline 3 applies.

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

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

Specific verb ('look up') plus a singular resource ('a single mock endpoint') keyed by slugId, so the agent knows exactly what it retrieves. It does not name or contrast with the closest siblings (get_mock_detail, search_mocks, list_mocks), so the boundary between this and those tools must be inferred.

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

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

The clause 'without needing to know project or DB ID' gives a concrete selection condition: use this when you only hold a slug. It stops short of explicitly excluding alternatives — an agent is not told to prefer get_mock_detail when a DB ID is known or search_mocks when the slug is unknown.

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 behavioral burden; it does signal a read operation and describes the payload contents (rules, state, webhooks), which is useful. However, it says nothing about permissions, what happens when the ID doesn't exist, or whether the response is large/paginated.

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

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

Two sentences, front-loaded with the core action and contents, followed by the key identifier guidance. No filler, though the capitalized "PREFERRED:" fragment reads slightly awkwardly.

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?

There is no output schema, and the description does compensate by enumerating the returned fields. Still, for a tool with zero annotations and an overlapping sibling, it omits error behavior and the distinction from get_mock_by_slug, leaving an agent with gaps at selection time.

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 schema already documents all three parameters, including the slugId preference and the projectId-only-with-mockId rule. The description restates that preference without adding syntax, format, or validation 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?

States a specific verb and resource (get full detail of a single mock endpoint) and enumerates what's returned: rules, stateful config, webhook settings, slugId, description. It is clear, but it never distinguishes itself from the sibling get_mock_by_slug, which appears to overlap heavily given the slugId emphasis.

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 advises supplying slugId rather than mockId/projectId, which is argument-level guidance rather than usage guidance. It gives no condition for choosing this tool over get_mock_by_slug or list_mocks/search_mocks, and no when-not-to-use cases.

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

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

With no annotations, the description carries the full disclosure burden, and it reveals almost nothing: not what the briefing contains, whether it errors when no project is active, whether it is read-only, or what the response shape looks like. A zero-parameter tool that depends on implicit session state especially needs that 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?

A single front-loaded sentence with no filler. It is efficient, though the brevity comes at the cost of substance rather than being a model of tightness.

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 annotations and no output schema, the description is the only source of information about the return value, yet it never says what fields or scope the "context briefing" covers. An agent cannot anticipate what it will receive or decide afterward what to do with 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 tool takes no parameters, so there is nothing to disambiguate; the schema is empty and 100% covered. The description does at least convey that the project is resolved implicitly rather than passed in.

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 ("Get") and resource ("context briefing of the currently active project"), and the qualifier "currently active" implicitly distinguishes it from list_projects and the various get_* state tools. However, it doesn't explain what a "context briefing" actually is, so the agent knows the target but not the payload.

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 call this versus siblings like list_projects, get_state, or get_mock_detail, nor any prerequisite stated (e.g., that a project must already be active). The usage is only implied by the name.

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 burden and does solid work: it discloses the exact shape of each log entry and explains that 'matchedRuleLabel' identifies which rule fired — genuinely useful behavioral context for interpretation. It stops short of covering retention windows, ordering guarantees, or what happens when no logs exist.

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

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

Front-loaded with the core action and return shape, then a numbered list of use cases. The final sentence about 'matchedRuleLabel' partially restates the field list already given, but the slight redundancy earns its place as an interpretation aid.

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 correctly steps in to describe the returned record fields in detail. For a 4-parameter read tool with no annotations, that covers the essential gap; missing only edge-case behavior (empty log sets, retention limits, whether logging is always enabled).

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

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

Schema description coverage is 100%, so size, mockId, status, and ruleLabel are all already documented in the schema. The description's mention of 'matchedRuleLabel' refers to a returned field, not the ruleLabel filter parameter, so it adds no supplementary meaning to any input. Baseline 3 is correct here.

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

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

States a specific verb and resource: 'Retrieve recent incoming HTTP requests captured by a mock endpoint', and enumerates exactly what each entry contains (headers, body, query params, matched rule label, status, timing). The purpose is unmistakable, though it never explicitly distinguishes itself from closely-named siblings like debug_last_request or get_saved_requests.

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 three concrete usage scenarios: debugging rule matching, inspecting outbound payload structure, and verifying the correct rule scenario fired. Clear context for when to reach for it, but no exclusions or named alternatives (e.g., when to use debug_last_request or get_saved_requests instead).

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; "Read" does establish it is non-mutating, and "Token-efficient" hints at response size. It says nothing about permissions, behavior when no chaos is configured, or error cases for invalid rule IDs — gaps for a tool with zero annotation coverage.

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

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

Three short sentences, front-loaded with the verb+resource and followed by the alternative. Every sentence carries information, though the 'token-efficient counterpart' clause sits slightly awkwardly after the routing advice.

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 three-required-parameter read with fully documented parameters and no output schema, the description covers what the tool returns conceptually (one rule's chaosConfig) and when to prefer it. The absence of any note on the shape of a 'no chaos configured' response is the only real gap.

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

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

Schema description coverage is 100% and the ruleId field already documents the crucial stale-ID caveat after update_mock, so the schema does the heavy lifting. The description adds no parameter meaning beyond what the schema provides; baseline 3 applies.

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

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

"Read the current Rule-level Chaos configuration for a specific rule" states a precise verb (read) and a narrowly scoped resource (one rule's chaosConfig). It is immediately distinguishable from set_rule_chaos, clear_rule_chaos and get_mock_detail.

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 says "Call this instead of get_mock_detail when you just need to check one rule's chaosConfig" and positions itself as the counterpart to get_traffic_chaos_status, giving a clear selection rule. It does not state exclusions (e.g. when the whole mock is actually needed), so it falls just 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 the burden and does well by disclosing that this is a retrieval operation and listing exactly what each saved request includes: name, method, URL, headers, body, description, and associated mock/collection/project names. It does not address permissions, pagination, or result scope, which keeps it from a 5.

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

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

The description is front-loaded with the core purpose and then structured into concrete use cases and returned fields. It is somewhat long but every section is useful; minor phrasing could be tightened.

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?

There is no output schema, so the description compensates by enumerating returned fields and explaining the tool's role in the broader workflow. The main remaining gap is scope clarity: with no parameters, it does not explicitly say whether all saved requests are returned or how results are bounded.

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 has zero parameters, so there are no parameter semantics to clarify; baseline is 4. The description appropriately does not invent parameter behavior.

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: 'Retrieve saved request samples from the Playground.' It clearly explains what saved requests contain and distinguishes this discovery/read operation from related actions like saving requests or testing mocks.

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

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

It gives explicit use cases, including discovering expected payloads, reading field names for rule conditions, understanding test cases, and supplying saved bodies to test_mock. It does not explicitly state when not to use it or name a direct alternative such as save_request, so it falls 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?

No annotations exist, so the description carries the full behavioral burden. It does disclose the scope and topics of the returned reference material, and 'retrieve' implies a non-mutating read. However, it says nothing about payload size or token cost despite promising 'complete' documentation, nor about whether the content is static or versioned — a real concern for a tool an agent is told to always call first.

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 resource then the directive, and every listed topic is concrete rather than filler. The topic enumeration is long-ish, but it earns its place because it tells the agent what questions the doc can answer.

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 must describe what comes back — and it does, by enumerating the documentation sections. It is complete enough for an agent to decide to call it and to know roughly what it will get; only verbosity/format expectations are left open.

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 an empty object with zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; the description correctly implies a parameterless fetch.

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?

A specific verb plus resource ('Retrieve the complete reference documentation for the Simceptor simulator') followed by an enumeration of what the docs cover: expression placeholders, condition operators, rule engine mental model, session simulation, webhooks, relay configs. No sibling offers documentation, so the tool is implicitly distinguishable, though the description never names a contrast case.

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

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

It gives an explicit, imperative trigger: 'ALWAYS call this tool first when setting up mocks for a new task to understand all available features.' That tells the agent exactly when to reach for it. It does not state when-not to call it (e.g., it's unnecessary for editing an existing mock), but for a docs tool that omission is minor.

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, yet it only discloses the storage backend (Redis) and scenario (stateful simulation). It says nothing about behavior when the session key is missing, whether calls are side-effect free, permission requirements, or the shape of the returned state.

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

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

A single front-loaded sentence with no filler. It is arguably too sparse rather than padded, but every word earns its place.

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

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

For a tool with no annotations and no output schema, the description leaves important gaps: what the returned state contains, what happens for an unknown sessionKey, and how it relates to set_state/delete_state. Only the storage location and scenario context are supplied.

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% - sessionKey is documented as resolved via stateLookupExpr/stateCaptureExpr and projectSlug as the project scope - so the schema already does the heavy lifting. The description adds no parameter context beyond that, which is the baseline 3 case.

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

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

States a specific verb ('inspect') and resource ('session state stored in Redis under stateful simulation for a project'), so an agent can tell this is a read of simulated state. It doesn't explicitly name the set_state/delete_state siblings, but 'inspect' versus their mutation verbs makes the distinction 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?

The phrase 'stateful simulation' implies this is used to check state after a simulation runs, but there is no explicit when-to-use, no prerequisites, and no reference to set_state or delete_state as the alternatives for changing or clearing state.

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 and does well: it frames this as a read, and spells out the return shape (enabled flag, distribution mode, traffic targets with percentages, error status code). Missing only operational context such as permissions or what happens if no chaos config exists.

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

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

Two tight sentences: the first front-loads the operation and its scope, the second gives the ordering guidance. No filler and nothing repeated from the schema.

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 read tool with no output schema and no annotations, the description supplies both the return contents and the usage context an agent needs to call 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 description coverage is 100%, with both projectId and mockId documented including how to obtain projectId. The description adds no parameter-level meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource: read the current Global Traffic Chaos configuration for a specific mock API, and enumerates what the configuration contains. It is clear on its own, but never contrasts itself with the sibling get_rule_chaos_status, which an agent could easily confuse with it.

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

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

"Call this before set_traffic_chaos to understand the current state" gives explicit ordering guidance and names the complementary write tool. It stops short of saying when not to use it or how it differs from get_rule_chaos_status.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that project, collections, and mock endpoints are automatically recreated, but it omits whether an existing project is overwritten or duplicated, permission/auth requirements, atomicity, failure behavior, and response details.

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

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

Two sentences, front-loaded with the core action and source, then one sentence explaining the automatic recreation behavior. There is no redundant text or repetition.

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

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

For a bulk-import mutation with no annotations and no output schema, the description covers the core behavior but lacks safety context such as overwrite/duplication risk, prerequisites, and error/return semantics. It is minimally adequate given the fully documented schema, but not complete for a complex import 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 100%, so the schema already explains data, name, and description. The description reinforces that data is an exported JSON string but adds no extra meaning for the optional name or description parameters. 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 uses a precise verb ('Import') and resource ('entire project configuration'), names the expected source ('exported JSON string'), and specifies the nested resources recreated. This clearly distinguishes it from create_project or export_project.

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

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

It implies the tool is for importing a project from an export, but it does not explicitly say when to use this instead of create_project, how to obtain the JSON, or what conditions make it inappropriate. Usage is inferable but not guided.

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, and it discloses almost nothing: no statement that it is read-only, no pagination or ordering behavior, and crucially no indication of whether resolved issues are included. For a listing tool whose sibling is explicitly 'open issues', that omission is a significant behavioral gap.

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 purpose and followed by the invocation constraint. No filler, no repetition of the title.

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

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

There is no output schema and no annotations, so the description should say more about what a returned issue looks like, whether the result set is filtered or paginated, and how mockId versus targetSlugId differ in scope. It covers target selection but leaves the return side undocumented.

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 would be 3, but the description adds genuine meaning by stating the two parameters are alternatives ('either ... or ...') — a mutual-exclusivity/one-of constraint the schema does not express, since required is empty and both are typed as independent properties.

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

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

States a specific verb+resource ('List issues') and scopes it to a mock or rule target. It does not distinguish itself from the close sibling list_open_issues_for_mock, leaving the agent unable to tell whether this returns all issues or only open ones without inspecting schemas.

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

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

The only guidance is 'Provide either targetSlugId or mockId', which is an invocation constraint rather than when-to-use guidance. There is no statement of when to prefer this over list_open_issues_for_mock or get_issue, which is the real selection risk given the near-duplicate 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?

No annotations are provided, so the description carries the full burden. It does disclose that results are limited to labels created by the authenticated user and span the named scopes, but it does not describe return format, ordering, or pagination 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 front-loaded sentence with no filler. Every phrase contributes to identifying the resource, ownership scope, and supported label scopes.

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 listing tool with a fully documented single enum parameter, the description is largely complete. The main missing piece is any mention of output shape or ordering, though the lack of an output schema makes that less critical.

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 only parameter has 100% schema description coverage with an enum and explicit fallback behavior ('Omit for all'). The description repeats the scope values but adds no meaning beyond what the schema already provides, 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 uses a specific verb and resource: it lists labels/tags, and it names the four supported scopes. It clearly distinguishes the tool from sibling resources like projects, mocks, and issues, though it does not explicitly contrast with an alternative label-listing tool because none exists.

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 what the tool does but gives no explicit guidance on when to use it versus alternatives, nor any prerequisites or exclusions. Usage is only inferable from the verb 'List' and the scope list.

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 behavioral burden. It discloses the returned fields and the slim-mode behavior, but it does not state read-only status, authorization requirements, pagination behavior, or what happens when the project has no mocks.

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

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

The description is two tight sentences: the first states purpose and grouping, and the second states return contents plus the slim alternative. It is front-loaded with no wasted text.

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 that there is no output schema, the description usefully explains the returned fields and the slim return shape. The main gap is the lack of sibling differentiation from search_mocks, but the parameter schema is rich enough to cover filtering details.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters including path, label, method, and slim. The description repeats the slim behavior but does not add 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 states a specific verb and resource: list all mock API endpoints in a project, organized by collections. That is clear enough to act on, but it does not distinguish this tool from the sibling search_mocks, which also appears to retrieve mocks.

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 explicit guidance on when to use list_mocks versus alternatives such as search_mocks or get_mock_detail. The only usage-like cue is the slim parameter for token efficiency, which is a parameter behavior rather than when-to-use guidance.

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

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

With no annotations, the description carries the full burden. It usefully discloses a behavioral fact not in the schema — that only OPEN/unresolved issues are returned, and that the scan covers the default response plus all rules. It says nothing about ordering, pagination, or result size, which matters for a list tool on a whole endpoint.

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

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

A single sentence with zero filler, and the most decision-relevant qualifier (OPEN) is front-loaded immediately after the verb. Nothing is redundant and nothing needs to be re-read.

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-parameter read tool with no output schema, the description covers what is listed and the traversal scope, which is enough to call it correctly. Minor gap: it doesn't hint at what an 'issue' record contains or how large the result may be.

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

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

One parameter with 100% schema coverage ('Database ID of the mock endpoint'), so the schema already does the work. The description adds no format or sourcing hints for mockId, leaving it at the baseline for fully documented schemas.

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?

Specific verb ('List') plus resource ('issues') plus scope ('across an entire mock endpoint, including its default response and all its rules'), so an agent knows exactly what is enumerated. It implicitly separates itself from the project-wide sibling list_issues via the per-mock scope, but never names that alternative explicitly.

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

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

The per-mock scope implies when to use it (you already have a mockId) versus a global issue listing, but there is no explicit when/when-not guidance and no sibling is named. An agent must infer the routing decision from the word 'mock endpoint' alone.

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 and does substantial work: it discloses that only active projects are returned, that results are scoped to the authenticated developer, and what fields come back (IDs, names, slugs). It omits pagination behavior and any ordering/limit, which is the remaining gap.

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

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

Three short sentences, front-loaded with the action and scope, then return shape, then the actionable downstream hint about test_mock. No filler.

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

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

For a zero-parameter list tool with no output schema and no annotations, the description covers what is returned, the scoping rule, and how to use the result. Missing only pagination and result-size expectations.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description correctly implies no filtering inputs are available by framing the call as an unfiltered list of the developer's active projects.

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

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

States a specific verb and resource with scope qualifiers: 'List all active mock API projects belonging to the authenticated developer.' This clearly separates it from list_mocks (mock-level) and get_project_context, though it never names a sibling explicitly.

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

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

The link between the returned slug and calling test_mock implies a primary use case, but there is no explicit 'use this when...' statement or exclusion of alternatives like search_mocks or get_project_context.

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

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

No annotations are provided, so the description carries the full burden. It does add real behavioral context beyond the name: only one rule is affected, remaining rules survive, and the operation is a token-efficient alternative to a full-array update. However, it never states that removal is destructive/irreversible, what happens if the ruleId doesn't exist, or whether removing the last rule is allowed — notable gaps for an unannotated mutation.

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

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

Three short clauses, front-loaded with the action and object, then the efficiency rationale, then the prerequisite. No filler and nothing redundant to the schema.

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-required-parameter mutation with no output schema, the description covers what it does, what it needs, and where to get the ID. The remaining gap is behavioral edge cases (error on unknown ruleId, irreversible nature) which matter more because there are no annotations.

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

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

Schema description coverage is 100%, so all three parameters (projectId, mockId, ruleId) are already documented in the schema, including the get_mock_detail hint for ruleId. The description repeats that hint but adds no format, constraints, or validation semantics beyond the schema — baseline 3 applies.

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

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

States a specific verb and resource ('Remove a single conditional rule from an existing mock API endpoint by its rule ID') with clear scope — exactly one rule. It distinguishes itself from update_mock (which would resend the full rules array) and from add_mock_rule, so the agent can separate it from siblings without opening a 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?

Gives a clear condition for use — when you want to drop one rule without resending the whole array — and names the prerequisite source ('Obtain the ruleId from get_mock_detail'). It doesn't explicitly state when NOT to use it (e.g. use delete_mock to remove the endpoint itself), but the guidance is concrete enough to act on.

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 burden and clearly discloses that this is a restricted mutation requiring user authorization rather than agent-initiated use. It does not describe return behavior or other side effects, but the critical safety constraint is explicit.

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, front-loaded with the action, and immediately follows with the critical prohibition. Every sentence has a clear operational purpose.

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

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

For a simple one-parameter mutation with no output schema and no annotations, the description gives the essential action and authorization constraint. It could say slightly more about what resolution changes or returns, but nothing critical is missing for correct invocation.

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

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

There is only one required parameter and the schema already documents issueSlugId at 100% coverage. The description does not add much parameter detail, but for a single fully documented parameter the baseline is appropriately high.

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: mark an issue status as RESOLVED. It is clearly distinct from sibling read/list/update tools such as get_issue or list_issues.

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

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

It gives explicit when/when-not guidance: DO NOT call automatically, only the user may resolve or close issues, and the AI should only recommend this action. That is stronger than typical usage guidance and directly prevents misuse.

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 behavioral burden. It says the payload is saved to the Playground, implying persistence and mutation, but it omits overwrite behavior, permissions, return values, and side effects for a 10-parameter save 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 first sentence is front-loaded and useful, but the second sentence largely repeats the playground/testing idea without adding actionable detail. It is short overall, but one sentence does not fully earn its place.

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

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

With no annotations and no output schema, the description should clarify the save behavior and result for a fairly complex 10-parameter tool. It covers high-level purpose and a use case, but leaves behavioral and return-value context missing.

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

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

Schema description coverage is 100%, so parameter meanings are already documented in the schema. The description adds no parameter-level detail beyond 'payload' and 'recreates parameters', 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 gives a specific verb, 'Save', and resource, 'sample request payload to the Playground', plus its documentation/testing purpose. It does not distinguish itself from siblings such as get_saved_requests or create_mock, so it is clear but not fully differentiated.

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

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

It implies a use case by saying the tool is 'for documentation and testing', but it never states when to choose this over related tools or any prerequisites/exclusions. That is enough for loose context but not explicit routing guidance.

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

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

With no annotations, the description carries the full burden and does disclose two non-obvious traits: it is a read/search operation and results are restricted to the token owner's projects (an auth-scoping constraint an agent must know to interpret empty results). It does not mention result limits, ordering, or pagination 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?

Three short sentences: scope first, then the workflow guidance, then the authorization constraint. No filler, and the most decision-relevant information is 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 three-optional-parameter read tool with full schema coverage and no output schema, the description covers purpose, scope, and the primary workflow trigger. It could be stronger by noting that all parameters are optional / how filters combine, but nothing essential to calling it correctly is missing.

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

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

Schema description coverage is 100% and each parameter already documents its matching targets in detail. The description's phrase 'by keyword, tags, or HTTP method' merely restates the parameter set without adding syntax, combination, or precedence rules. Baseline 3 applies.

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

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

States a specific verb+resource ('Search mock APIs') plus both scope ('across all of the authenticated user's projects') and the three matching axes (keyword, tags, HTTP method). This implicitly separates it from list_mocks, but no sibling is named explicitly, so the differentiation is inferred rather than stated.

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

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

Gives a genuine usage rule: 'Use this BEFORE creating new mocks to avoid duplicates,' which orients the agent in a create workflow. It stops short of naming alternatives (e.g. list_mocks for unfiltered enumeration, get_mock_by_slug for exact lookup) or stating 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?

No annotations are provided, so the description carries the full burden, and it does substantial work: it explains activation timing (post-condition-match), both modes, and that kill_connection drops TCP with no HTTP response. It omits whether an existing chaos config is replaced, what permissions are needed, and what is returned on success.

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

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

It is short and front-loaded: the scoping distinction comes first, then modes, with no filler sentences. The trailing mode enumeration slightly duplicates what the schema's enum descriptions already say.

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 an 8-parameter mutation tool with no annotations, no output schema, and full schema coverage, the description supplies the two missing pieces an agent needs: when the chaos actually fires and what each behavior does to the client connection. Nothing essential is 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 100%, so the schema already documents every parameter including enum semantics for mode and behavior. The description's worked example ('name=agung', 30% kill) and mode summary add conceptual framing rather than new parameter-level meaning, which fits the baseline 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+resource ('Configure Rule-level Chaos for a specific conditional rule inside a mock') and explicitly contrasts itself with Global Traffic Chaos, which is the sibling set_traffic_chaos. An agent can distinguish the two without opening either schema.

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

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

It states the key selection condition clearly: rule-level chaos only activates after the rule's conditions match, unlike global chaos which intercepts all requests. It does not, however, name the sibling tools by name (set_traffic_chaos, clear_rule_chaos, get_rule_chaos_status), so the routing advice stops short of explicit 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?

No annotations exist, so the description carries the full burden — and it discloses the single most important behavioral trait: the write MERGES with existing variables rather than replacing the whole object, plus the TTL default inheritance from stateCaptureExpr. It does not cover permissions/auth or what the response looks like after writing, leaving a modest gap for a mutation tool with zero annotation coverage.

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

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

Three sentences, front-loaded with the core action, then motivation, then the merge caveat. Nothing is padded, though the parenthetical 'e.g. jump straight to settled or completed' and the mock-endpoint aside run slightly long.

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 4-param write tool with no annotations and no output schema, the description covers purpose, alternative-path avoidance, merge semantics, and TTL behavior. The one thing an agent might still wonder — what the tool returns after the write — is not addressed, but everything needed to call it correctly is present.

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 schema already documents all four parameters and the baseline would be 3. The description adds genuine meaning beyond the schema by specifying merge-not-replace semantics for `variables` and the guidance to pass only the fields being added or overwritten.

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

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

States a specific verb and resource — 'directly write/overwrite session state in Redis for a project' — and immediately contrasts it with the normal path ('without needing to fire a real request through stateCaptureExpr first'), which is exactly how it differs from the capture-based siblings get_state/delete_state.

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

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

Gives a concrete scenario ('forcing a stateful test scenario into a specific state, e.g. jump straight to settled or completed') and explains why you'd prefer it over building fake helper endpoints. It does not explicitly name siblings like get_state or delete_state, 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?

With no annotations, the description carries the full behavioral burden and does well: it explains the rate-sum failure condition, TCP drop behavior, HTTP error behavior, rule routing, and that chaos is evaluated before rule logic. It does not explicitly state whether existing chaos configuration is overwritten or what permissions are required.

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 purpose and constraints, and every sentence earns its place by defining channels, modes, failure conditions, prerequisites, or evaluation order.

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

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

Given the complex mutation behavior, absence of annotations, and no output schema, the description provides enough context to call the tool correctly: required distribution sum, ruleId sourcing, channel meanings, and evaluation ordering are all covered.

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

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

Schema description coverage is 100%, so parameter semantics are already well documented in the schema. The description reinforces the sum-to-100 constraint and ruleId source, but adds little beyond what the schema fields already state.

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: configure Global Traffic Chaos for a mock API. It clearly distinguishes this from status/clear operations by describing configuration of traffic distribution and the supported channels.

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

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

The description gives clear context for use, including the ruleId prerequisite via get_mock_detail and the evaluation ordering before rule conditions. It does not explicitly name when to use this versus clear_traffic_chaos, get_traffic_chaos_status, or set_rule_chaos, so it stops short of full alternative routing guidance.

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

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

With no annotations provided, the description carries the full disclosure burden and does well: it states the request is real and hits the local mock engine, and it surfaces the diagnostic contract (the 'X-Rule-Matched' response header identifies which rule fired). It stops short of saying whether the call is logged or persists state, or what the full response shape is.

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?

Five sentences, all actionable, with purpose front-loaded before the sequencing advice and the debugging fallback. It is dense but nothing is filler; it could be tightened slightly by merging the rule-testing and header-checking guidance.

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?

There is no output schema, so the description correctly discloses the one return detail that matters for interpretation, the 'X-Rule-Matched' header. It doesn't cover whether the mock's status code and body are returned verbatim or whether the call is recorded in the request log, which an agent would want to know.

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 every parameter, including the nested headers map, is documented in the schema itself. The description adds only indirect hints, such as using bodies from get_saved_requests as test inputs, but no format or constraint detail beyond what the schema already states.

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

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

The description opens with a specific verb and resource: fire a real HTTP request at the local mock engine to verify a mock endpoint returns the expected response. That is clearly distinguishable from siblings like debug_last_request or get_request_logs, which are inspection tools rather than live-request testers.

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

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

It gives explicit sequencing ('use this AFTER creating or updating a mock'), a required testing pattern ('test EACH rule scenario by sending different request bodies/headers'), and names the fallback tool ('use get_request_logs to debug the condition mismatch') under a stated failure condition.

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 well: it flags full-replacement (destructive) semantics, that partial rule updates are unsupported, and that stateful simulation fields can be added/removed. It does not say what happens to omitted optional fields (cleared vs. preserved) or whether any permissions are required, leaving a real ambiguity for a 24-param mutation.

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

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

Four sentences, front-loaded purpose, then the destructive-replacement warning in caps, then the prerequisite, then the stateful-field note. No filler or restatement of schema fields.

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

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

For a 24-parameter mutation with no annotations and no output schema, the description covers the two things an agent would otherwise get wrong: wiping data via partial rules and skipping the read-before-write step. Only the fate of omitted optional fields and any auth requirements are left unstated.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns an extra point by adding cross-parameter semantics the schema can't express — that the rules array is authoritative and must be complete, and that the three state* fields are the toggle points for stateful simulation.

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?

Starts with a specific verb+resource ('Update an existing mock API endpoint') and immediately adds the defining trait — full replacement including the rules array — which is what separates it from add_mock_rule/remove_mock_rule. An agent can tell which sibling to reach for without opening the schema.

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

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

Names an explicit prerequisite ('Use get_mock_detail first to read the current state before modifying') and states the hard constraint for rule updates. It never explicitly contrasts with add_mock_rule/remove_mock_rule, but 'replaces all fields including rules' implies the distinction.

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 behavioral burden, but it does not explain overwrite semantics, required permissions, whether existing notes are replaced, or what happens on success/failure. It only says the tool updates or sets notes and pins them on the dashboard banner.

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 definition is short and front-loaded, with purpose first and usage guidance second. The uppercase guideline phrasing is slightly verbose, but there is little wasted text.

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 two-parameter update tool with no output schema, the description covers purpose and basic usage. It remains incomplete for a mutation tool with no annotations because it omits overwrite behavior, permissions, and response expectations.

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

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

Schema description coverage is 100%, so the schema already documents both projectId and userNotes. The description reinforces the resource and notes concept but adds no format, length, or syntax details 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 names a specific verb and resource: updating or setting AI Context Notes for a project workspace. It is distinguishable from siblings like get_project_context and create_project, though it does not explicitly contrast itself with any alternative.

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: call this tool to pin key context on the user's dashboard banner. However, it does not state when not to use the tool or name alternatives such as get_project_context.

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