SanctionsKit developer MCP

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

Annotations already carry the full safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower, and the description adds the two-mode behavior plus the caveat that this reflects the REST contract rather than the sandboxed account tools. The closing clause is slightly ambiguous about what 'sandbox only' applies to, but there is no contradiction with the annotations.

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

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

Three tight sentences, correctly front-loaded with the zero-argument behavior before the parameterized one, with no filler. The final sentence is compressed to the point of slight ambiguity, which costs a point.

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

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

An output schema exists, so return values need not be enumerated, and annotations cover safety; the description supplies the missing mode semantics and the scope boundary against sandbox tools. It could say more about invalid-path or unknown-method behavior, but nothing essential for correct invocation 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 coverage is 0%, so the description must carry the load, and it does: it explains that omitting 'path' switches to list mode, gives a concrete example value (/screenings), and notes the method must be lowercase (the schema only implies this via lowercase enum values). It omits the path maxLength and the default-method behavior, which the schema covers.

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 precise dual-mode verb+resource: with no path it lists consumer REST operations, with a path+method it retrieves that operation's OpenAPI request/response/examples/schemas. It also draws a scope boundary against the sibling sandbox tools ('MCP account tools are sandbox only'), so an agent can distinguish it from get_doc/search_docs 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?

It explicitly describes the two invocation modes and the condition that selects each ('Without path, list ... With a path such as /screenings and lowercase method, retrieve ...'), which is strong when-to-use guidance. It stops short of naming an alternative tool (e.g. get_doc) for the case where the agent wants prose docs rather than the contract, so no exclusions are given.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds real value by confirming the closed local catalog ('fixed local document catalog') and hinting at returned content ('code examples and error handling'), consistent with the annotations.

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

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

Two tight sentences, both front-loaded: the positive action first, the negative constraint second. Every clause earns its place; nothing is redundant with the title or 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?

An output schema exists, so return values need no elaboration, and the content hint ('code examples and error handling') is a bonus. The only gap is behavior on an invalid or unknown slug, which the description leaves unaddressed.

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

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

Schema description coverage is 0% for the single slug parameter, so the description must carry the load. It usefully identifies the slug's origin (a search_docs result) but says nothing about the allowed character pattern or length limit, which live only in the schema regex and constraints. It compensates partially, not fully.

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

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

States a specific verb and resource ('Read a document returned by search_docs') and pins the source of the identifier, which cleanly separates it from the sibling search_docs. An agent can tell what this does and where its input comes from 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?

The phrase 'returned by search_docs' implicitly routes the agent through search_docs first, and the exclusion 'does not fetch arbitrary URLs' defines when-not-to-use-it. It stops short of explicitly naming alternatives like get_api_schema or stating prerequisites, but the context is clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds that the result is derived from the authenticated connection rather than a supplied identifier, which is mildly useful context, but it adds little beyond the empty schema and annotations.

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

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

Two short sentences, front-loaded with the core action and followed by a single clarifying constraint. No filler or redundancy.

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

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

An output schema exists, so return values need not be documented, and with no parameters the description has little else to carry. It adequately covers the identity-from-connection behavior, though it omits how this profile relates to the screening/sandbox workflow the sibling tools imply.

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 is 4. The description reinforces this by explicitly stating no user or workspace selector is accepted, aligning with the schema's additionalProperties: false and empty 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?

Names a specific verb (Identify) and resource (the sandbox profile) and scopes it to the authenticated connection, which is more precise than the title alone. It does not distinguish itself from siblings like get_api_schema or get_usage, but the purpose 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 line 'Takes no user or workspace selector' implies the tool cannot be filtered or targeted and is meant purely to describe the current connection, which is a useful usage constraint. However, it never states when to call this versus the other read tools (get_usage, get_api_schema, list_sources), so guidance remains implied rather than explicit.

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

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

Annotations already declare idempotent, non-destructive, closed-world behavior, and the description adds genuinely new context: results are 'retained' evidence, expired results raise an error rather than returning stale data, and the caller must preserve coverage/version/warning metadata. The only tension is that 'Retrieve' reads as a pure read while readOnlyHint=false, but that is a conservative default rather than an outright mutating claim. No auth or rate-limit detail is given.

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

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

Three tight sentences with the core action front-loaded, followed by the failure mode and retention caveats. The final clause ('Preserve coverage, versions, warnings and potential-match review requirements') is slightly cryptic and reads more like an instruction to the consuming agent than a description of the tool, which slightly dilutes an otherwise efficient block.

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

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

With an output schema present, the description does not need to enumerate return fields, and it correctly focuses on scope, retention, and the expired-result error. For a single-parameter retrieval tool this is nearly sufficient, missing only guidance on behavior when the ID is invalid or the result 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?

There is a single parameter, and the schema fully specifies it as a UUID string with an explicit pattern and format, so the schema already carries the constraint burden (coverage 0% here reflects absent prose, not absent constraints). The description adds only the notion that the ID is a 'screening ID' identifying retained evidence, which is a modest clarification over the schema field name 'id'.

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 — 'Retrieve retained evidence by screening ID from the connected sandbox workspace' — which is unambiguous about what comes back and the lookup key. It implicitly separates itself from run_sandbox_screening by framing this as retrieval of an existing result rather than execution, though it never names the sibling outright.

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

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

Usage is implied (fetch a result by ID after a screening has run), and one useful precondition is stated: 'An expired result is an error.' However, there is no explicit when-to-use guidance, no mention of how this relates to run_sandbox_screening or validate_screening_request, and no statement about what to do if the ID is unknown or the result was never created.

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

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

Annotations already declare the full safety profile (readOnly, idempotent, non-destructive, closed-world), so the description need not restate safety. It adds useful scope detail by naming the three payload areas returned (allowance, completed subjects, pending reservations), but no further behavioral context such as freshness or caching is given.

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 wasted words. The enumerated payload areas are slightly list-like but each term carries meaning.

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

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

With an output schema present, return values need not be documented, and annotations cover the safety profile. The description supplies enough scope for a zero-parameter read tool; only the lack of when-to-use framing keeps it below the top.

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 is 4. There is no parameter surface for the description to clarify.

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

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

States a specific verb (Read) and resource (the connected sandbox workspace allowance, completed subjects, pending reservations), which is more informative than the title alone. It is distinguishable from siblings like get_profile or get_screening_result, though it does not explicitly contrast itself with them.

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

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

No guidance on when to call this versus alternatives such as get_profile or get_screening_result, and no preconditions mentioned. The agent must infer usage entirely from the name and description.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is fully covered. The description adds bounded pagination and a sandbox-scoping caveat, which is useful context, but it does not disclose return ordering, total-count behavior, or what happens with the limit ceiling, leaving some behavioral gaps.

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

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

The core purpose is front-loaded in the first sentence, but the second sentence is jargon-heavy ('sandbox@1') and reads as tangential to selecting this tool, diluting the signal. The overall length is acceptable but not maximally efficient.

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

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

An output schema exists, so return values need not be explained, and annotations cover the safety profile. For a simple list tool the sandbox scoping and pagination note are adequate, but the entirely undocumented parameters and thin filtering semantics leave it only minimally complete.

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

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

Schema description coverage is 0%, so the description must compensate for three undocumented parameters. It only gestures at 'bounded pagination', which loosely maps to limit/offset, and says nothing about what the query string matches or how filtering works. This falls short of what a 0%-coverage schema requires.

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 ('Read current source metadata and qualification') and scopes it to the connected sandbox workspace, so the agent knows this is a listing/enumeration tool. However, it does not explicitly differentiate itself from the other 'get_*' and listing siblings like get_usage or get_profile, so the boundary is left to inference.

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

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

There is no explicit when-to-use statement or reference to an alternative sibling. The second sentence about catalog/production availability versus sandbox screening is a caveat about downstream screening behavior, not guidance on when to call list_sources itself. The agent must infer usage from context 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?

Annotations already declare idempotentHint=true, readOnlyHint=false, destructiveHint=false, openWorldHint=false, so the safety profile is covered. The description adds substantial behavior beyond that: it retains screening evidence according to policy, may create a review case, and consumes sandbox allowance rather than paid production allowance, plus the retry semantics of the idempotency key. These are exactly the side effects an agent needs to anticipate.

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 dense sentences, front-loaded with the core action before constraints and side effects. Every sentence contributes, though 'sandbox@1' is opaque enough to cost a little clarity.

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 nested, complex submission tool with an output schema present, the description covers quota, retention side effects, review-case creation, and idempotency reuse. The main gap is the unexplained nested request payload, but the schema and output schema carry that detail.

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

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

Schema description coverage is 0%, so the description must carry the load. It documents synthetic=true and the idempotencyKey format/length/reuse semantics well, and 'cannot link counterparties' implicitly addresses counterpartyId. However, the three-parameter nested `request` object (policy, subject, identifiers, retention, reference) is not explained at all, leaving a large share of parameters undocumented in both places.

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 (Submit) and resource (invented data to sandbox@1), and the title/description make clear this is a sandbox screening test. An agent can distinguish it from validate_screening_request, get_screening_result, and get_screening_result-style siblings 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?

Gives explicit constraints and exclusions: 'Requires synthetic=true', 'Cannot screen production or link counterparties'. These tell the agent when the tool is not appropriate. It stops short of naming the alternative sibling (e.g., validate_screening_request) for the invalid cases, so it is clear context rather than full 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?

The annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the bar is lower. The description adds useful context that the tool is public and requires no account, plus that it returns slugs for get_doc, though it does not mention result limits 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 three short, front-loaded sentences with no waste. It moves from purpose to return value to access requirement efficiently.

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

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

For a simple two-parameter search tool with an output schema and strong annotations, the description covers purpose, return routing, and access model. The main gap is the lack of explanation for the 'limit' parameter, but the schema supplies numeric constraints and the output schema handles return structure.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies the 'query' parameter as keyword-based search, but says nothing about the 'limit' parameter's meaning, default, or bounds, leaving half the parameters semantically undocumented.

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

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

The description states a specific verb ('Find') and resource ('current integration documentation and guides by keyword'), and distinguishes itself from the sibling get_doc by returning document slugs for it. However, it does not explicitly contrast itself with other sibling search or listing tools.

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

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

It implies usage by saying it returns slugs for get_doc, which suggests a search-then-fetch workflow. It also notes the tool is public with no account needed, but it gives no explicit when-not-to-use guidance or alternative sibling comparisons.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the description is not the sole carrier of the safety profile. It nevertheless adds substantive semantics beyond the annotations: no submission, no retention, no eligibility evaluation, no clearance grant — the exact non-effects an agent must know to avoid mistaking validation for enforcement.

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, zero filler, with the scope statement front-loaded and the caveats ordered from operation to side-effect to input guidance. Every sentence earns its place.

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

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

An output schema exists, so return-value explanation is not required, and the description covers scope, non-effects, and input expectations. The remaining gap is the missing pointer to the authoritative schema source (e.g. get_api_schema) for the opaque 'request' payload.

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

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

Schema coverage is 0% and the single 'request' property is a bare untyped object, so the description must compensate. It tells the agent what the value is validated against (the runtime REST screening schema) and that it should be synthetic, which is meaningful, but it gives no shape, format, or example of the payload and never points at where to obtain that 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 — validating a screening request against the runtime REST screening schema — and immediately bounds the scope with 'without submitting or retaining it.' An agent can distinguish this from the actual execution sibling (run_sandbox_screening) purely from the text.

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 operative guidance ('Use synthetic development inputs') and exclusions ('Does not check live source eligibility or grant clearance'), which tells the agent when this is appropriate versus when a real screening call is needed. It stops short of explicitly naming a sibling alternative, so it is clear but not fully routing.

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