Automatic Video Face & Person Masking MCP with Original Restore (Reversible) — NoonAI DIS

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

With no annotations provided, the description carries the behavioral burden and does so well: it explains the legacy signed-URL flow, server-side fetching to avoid MinIO reachability issues, bearer-token continuity, and the base64 vs. gateway_download_url response behavior. It omits error modes and explicit read-only safety language, but the operational mechanics are unusually clear.

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 action and then adds useful implementation context without redundancy. Every sentence contributes to understanding the download flow or response behavior.

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

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

An output schema exists, so return-value detail is less critical, and the description does explain the base64 and gateway URL response behavior. Still, for a five-parameter tool with zero schema description coverage and no annotations, the missing parameter semantics leave a meaningful completeness 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 0%, so the description must compensate for five undocumented parameters. It only indirectly hints at include_base64 and inline_base64_limit_bytes behavior through the small-file/large-file explanation, and it never explains job_id, file_name, or file_index.

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: download one completed encrypt result file through the gateway. It clearly scopes the operation to completed encrypt results, but it does not explicitly distinguish this tool from the sibling get_job_result.

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

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

Usage is implied by 'completed encrypt result file' and the small-vs-large file response behavior. However, the description does not explicitly say when to use this instead of get_job_result or other siblings, nor does it state 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, the description carries the full burden, and it does disclose the composite side effects (writes to NAS, submits a remote DIS job) — a meaningful trait beyond the schema. But it omits cost/credit implications, job lifecycle (async vs sync, what job ID comes back), and any failure or overwrite behavior for an 8-parameter mutation 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?

Front-loaded with the core action in the first sentence, which is good. But the second paragraph spends a full sentence on self-promotion ('This is the main public differentiator from multi-step MCPs') that does not help an agent decide or invoke correctly.

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 8-parameter composite mutation tool with zero annotation coverage and zero schema descriptions requires a much richer description. The presence of an output schema excuses explaining return values, but the caller is left without any understanding of four required parameters or the side effects of the NAS upload and credit consumption.

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 8 parameters, so the description must compensate and it largely does not. Only target_objects gets semantic explanation (face/body/car); key_index, key_name, file_path, file_name, file_type, restoration, and encrypt_object_label are entirely undocumented anywhere.

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 first sentence names a specific verb and resource ('image anonymization') and clarifies that it composes two steps: upload to NAS then submit the DIS job. It implicitly separates itself from upload_file/submit_encrypt_job by describing the composite behavior, though it never explicitly names encrypt_video as the video counterpart.

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 one concrete usage hint (target_objects=["face"] for a single-call detect-then-blur/redact) and mentions body/car for person/plate masking. However, the stated 'alternative' is a generic comparison to multi-step MCPs rather than the actual siblings, and it never says when to call this versus submit_encrypt_job or encrypt_video.

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 so: it discloses cost ($3/video, no trial), hard limits (1 file, .mp4/.avi, 150 MB, 1920x1080, 360 s or 180 s with restoration), that only detected regions are masked rather than the whole frame, that restoration requires a registered key and that this MCP has no decrypt tool. That is unusually rich behavioral disclosure for a mutation/pipeline 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?

Well front-loaded: purpose first, then the reversible-vs-permanent decision, then price and limits, then the remote-client workflow. Dense and mostly waste-free, though the restoration limits are restated in both the prose and the parameter schema, and the Korean/English alias list is optional bulk.

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, high-stakes file-processing tool with no annotations, this covers everything an agent needs to call it correctly: prerequisites (server-side path, registered key), cost, hard limits, reversibility implications, and the fallback workflow for remote clients. Return values are covered by the output schema, so their absence from the description is fine.

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 75%, and the description adds real semantic value beyond it: the coupling between restoration and key_index/key_name (0/"null" for permanent), the shorter 180 s limit under restoration, and the constraint that file_path must exist on the server. Minor gap: file_type and encrypt_object_label remain undocumented in both schema and description.

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

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

Opens with a specific verb+resource ('One-shot video anonymization') and enumerates exactly what gets detected and masked (body, face, car/license plates). It explicitly distinguishes itself from the detect+blur tool chain and, by naming the sibling workflow tools, from submit_encrypt_job/encrypt_image as well.

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 routing: use this tool for one-shot local-path anonymization; remote clients must go upload_file_content -> submit_encrypt_job -> get_job_status -> get_job_result; live policy should be fetched via get_encrypt_constraints(file_kind="video") and get_pricing_policy. It also states the when-not condition (no free video trial, split longer clips first).

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, but 'Return' implies a non-mutating read and 'caller's ... principal' implies identity is derived from auth context rather than parameters. It says nothing about permissions, failure modes, or staleness of the status, so gaps remain but the read-only nature is conveyed.

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 front-loaded sentence with no filler. Only slight cost is the dense 'flat-price billing principal' phrasing, but nothing is wasted.

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 and no parameters, the description need not explain return values. It adequately covers scope and identity source for a simple read tool, though auth requirements are left implicit.

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?

Zero parameters, so baseline is 4. The description does add useful semantics: the principal is the caller's and is 'stable', clarifying that no identity argument is needed.

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

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

States a specific verb ('Return') and resource ('current flat-price billing status'), which is clearly distinct from siblings like get_usage_summary and get_pricing_policy. The phrase 'stable billing principal' is somewhat jargon-y but does scope the resource.

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 indication of when to use this versus get_usage_summary or get_pricing_policy, and no stated preconditions. The agent must infer routing from the name 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?

No annotations exist, so the description carries the full burden, and it does disclose real constraints: video capped at 360 s, or 180 s when restoration='true', plus the presence of billing-policy data. It does not state whether the values are account-specific, cached, or require auth, but the core behavioral constraint an agent needs is present.

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 dense sentence with no filler, front-loading the returned data before the constraint detail in parentheses. Minor deductions for the awkward line break and reStructuredText backticks leaking into prose.

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 needn't be explained, and the description covers what categories of data come back plus the key video limits. What's missing is whether the result is per-account/per-plan and how it relates to the pricing/billing siblings, which matters for a tool whose output overlaps three other tools.

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 file_kind enum-like values are already documented. The description adds only indirect meaning by tying video to the 360 s/180 s limits, without explaining how image differs. 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?

States a specific verb ('Return') and a concrete payload (upload limits, target-object options, billing policy) scoped to image/video detect-then-blur anonymization. An agent can distinguish it from encrypt_image/encrypt_video, but it never names get_pricing_policy or get_billing_status as alternatives, so sibling differentiation is only implicit.

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: read constraints before submitting an encrypt job. There is no explicit when-to-use, no exclusions, and no pointer to the overlapping siblings (get_pricing_policy, get_billing_status) that also return billing information.

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 usefully discloses that this is a legacy endpoint and that it may return a 404 when the job isn't ready, but says nothing about auth requirements, idempotency, or what 'metadata' contains beyond what the output schema implies.

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 with the purpose front-loaded and the usage condition immediately after. No filler, though the second sentence is slightly compressed to the point of being cryptic about the 404 behavior.

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

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

For a single-parameter read tool with an output schema, the description covers what to call and when. The main gap is the undocumented job_id semantics and lack of permission/error behavior detail, but the output schema absorbs the return-value burden.

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% and the single parameter job_id is never mentioned in the description. The only hint is the ':id' placeholder in the endpoint path, which is weak compensation for an undocumented required parameter.

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 ('Fetch') and resource ('encrypt result metadata'), and ties it to the legacy endpoint GET /encrypt/result/:id. It implicitly contrasts with download_job_result by specifying 'metadata' rather than the artifact itself, though it never names that 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?

Gives a clear trigger: call when get_job_status reports completion, and explains the not-ready case (surface legacy 404). It does not mention when to prefer download_job_result instead, which leaves one obvious alternative unmapped.

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

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

No annotations are provided, so the description carries the full burden. It discloses useful context beyond the schema — that this hits a legacy was-util endpoint and that job_id maps to enc_request_list.id — but says nothing about terminal states, polling cadence, behavior when the job id is unknown, or auth/rate-limit constraints.

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 with the action front-loaded and the parameter provenance second. No filler or restatement of the tool name.

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 and there is only one parameter, both of which are covered, so the description is close to complete. The remaining gap is behavioral: for a polling tool, the absence of any guidance on cadence or completion criteria leaves an 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?

Schema description coverage is 0%, so the single job_id parameter is documented only as a bare string in the schema. The description compensates well by explaining it is a ULID returned by submit_encrypt_job and mapping it to enc_request_list.id, which is exactly the provenance an agent needs.

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: 'Poll encrypt job progress' via a named legacy endpoint, which is clearly distinct from the sibling get_job_result that fetches outputs. It does not explicitly name get_job_result as the alternative when the job is finished, so sibling differentiation is implied 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?

The verb 'poll' implies repeated invocation and the description tells the agent where job_id comes from (submit_encrypt_job), which is genuine usage context. However, there is no statement of when to stop polling, how often to poll, or when to switch to get_job_result/download_job_result.

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 disclosure burden; it does add one behavioral fact by calling the policy 'flat', implying pricing does not vary per request or volume. However, it says nothing about whether this is a static/read-only lookup, whether credentials are required, or whether values can change over time, and no annotations fill those 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?

A single front-loaded sentence with no filler, and the resource is stated before the qualifier. Minor redundancy in restating 'MCP' alongside 'billing policy' keeps it from being maximally tight.

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 zero parameters and an output schema present, the description does not need to explain return values, and the one sentence covers what the tool yields. The remaining gap is routing context against the several sibling billing tools, which the description never addresses.

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 nothing for the description to disambiguate; the baseline of 4 applies. The description correctly implies the call is parameterless and scoped by nothing beyond the tool itself.

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 ('Return') and a specific resource ('flat MCP billing policy for image/video requests'), which is clear enough to act on. It does not explicitly differentiate itself from billing-flavored siblings such as get_billing_status or get_usage_summary, leaving the agent to infer the difference from naming alone.

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 no when-to-use condition, no prerequisites, and no mention of the confusable siblings (get_billing_status, get_usage_summary, purchase_credits) in a cluster where picking the wrong billing tool is a realistic error. It only implies usage through the word 'policy'.

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 discloses the underlying table (public_id_map) but says nothing about whether this is a safe read, whether results are paginated or truncated, or what access scope is required; "List" weakly implies read-only but that is inference, not disclosure.

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

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

A single short sentence with no filler, and the operative verb is front-loaded. The only inefficiency is the parenthetical implementation detail, which adds context but is slightly noisy for an agent-facing definition.

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 tool with an output schema, the description covers enough to make a call possible, and return values need not be explained. It remains incomplete because the mismatch with the tool name is unresolved and there is no indication of scale or scope of the listing.

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; baseline 4 applies. The description does not need to compensate for any coverage gap.

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

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

The description gives a specific verb and resource ("List registered public job ULIDs") with an implementation detail (ENCRYPT_JOB rows in public_id_map), so the operation itself is discernible. However, it does not align with the tool name get_usage_summary, so an agent seeking usage metrics gets a ULID enumeration instead; the purpose is stated but not reconciled with the name.

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 such as get_job_status, get_job_result, or get_billing_status, nor any prerequisites or exclusions. The agent must infer usage purely from the sentence.

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 it discloses only that money is charged and a balance credited. It says nothing about irreversibility, refunds, double-charge protection via the idempotency_key, failure modes such as a missing stored method or declined charge, or whether the ledger update is atomic with the charge.

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 well-formed sentence with the charge action front-loaded and no filler. It is efficient, though the efficiency comes partly at the cost of the missing detail noted above rather than genuine density.

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 described, but this is an unannotated financial mutation with three undocumented parameters and a sibling tool it never distinguishes itself from. Key information an agent needs to call it safely 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% for all three parameters, so the description must compensate and does not: it never explains the unit or bounds of 'credits', the purpose of the 'description' field, or the critical semantics of 'idempotency_key' (empty default implies no protection unless supplied). An agent could easily mis-set credits or omit the idempotency key and cause a duplicate charge.

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 ('Charge') and the exact resource ('the caller's stored payment method'), plus the resulting effect ('credit the legacy tenant balance'). It implicitly contrasts with purchase_credits_with_card by specifying the stored method rather than a supplied card, but never names that sibling, so disambiguation 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 statement of when to use this versus purchase_credits_with_card, register_billing_payment_method, or get_billing_status. The phrase 'stored payment method' hints that a method must already be registered, but no prerequisite, exclusion, or alternative is spelled out for a tool that moves real money.

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 that this is a direct charge using raw card details and that the card data is not stored, but it omits key payment behavior such as whether the charge is irreversible, what authorization is required, and how idempotency is 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 a single front-loaded sentence with no filler: the verb 'Charge' appears first, followed by the scope and the no-storage constraint. Every phrase carries information, even though the overall definition remains under-specified elsewhere.

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 output schema exists, so return values need not be explained. However, for a 12-parameter financial mutation with no annotations and 0% schema description coverage, the description is far too thin: it lacks parameter semantics, usage guidance, authorization expectations, and charge/idempotency 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 0% across 12 parameters, so the description must compensate but largely does not. 'Raw card details' loosely maps to card fields and 'current billing principal' hints at buyer identity, but it does not explain credits, required fields, defaults, payment_type, idempotency_key, or card_ssn/card_cvc semantics.

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 action, 'Charge raw card details directly,' and scope, 'for the current billing principal,' plus a data-handling constraint, 'without storing them.' It is clear enough to distinguish a direct card charge from a stored-payment method flow, though it never explicitly says it purchases credits or names the sibling purchase_credits.

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: 'raw card details directly' and 'without storing them' suggest this is for cases where card data is supplied directly rather than using a registered payment method. There is no explicit when-to-use, when-not-to-use, or named alternative such as purchase_credits or register_billing_payment_method.

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. Saying 'Encrypt and store' usefully implies the card data is not persisted in the clear, but nothing is said about whether it replaces an existing default, whether it charges the card (e.g., zero-dollar authorization), what permissions or billing state are required, idempotency, or how highly sensitive fields (card_ssn, card_cvc, card_password_2digits) 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 single sentence has zero waste and is front-loaded with the action and resource. It is efficiently written, though its very compactness is part of the under-specification problem rather than a stylistic flaw in itself.

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 needn't be explained, but for a 9-parameter, PCI-sensitive mutation with no annotations and no parameter documentation, the description is far too thin. It omits replacement semantics, required billing state, and any guidance on the sensitive optional fields.

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% across 9 parameters, so the description must compensate, and it supplies no parameter meaning at all. Cryptic, high-risk fields such as payment_type (defaulting to 'LOCAL02'), card_password_2digits, and card_ssn are entirely unexplained, leaving the agent to guess at regional card schemes and security-code conventions.

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 pair ('Encrypt and store') and a concrete resource ('a default payment method') scoped to the caller's billing principal, so the agent knows this is a card-registration write, not a charge. It does not distinguish itself from the closest sibling, purchase_credits_with_card, so the agent must infer the register-vs-charge boundary.

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 statement of when this tool should be used versus purchase_credits / purchase_credits_with_card, no prerequisites (e.g., whether the caller must already have a billing principal), and no exclusions. The agent is left to infer that this registers a reusable payment method rather than executing a payment.

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 non-obvious behavior: gateway-registry metadata becomes authoritative and mismatched caller values are rejected, and an HTTP scope gate requires dis:encrypt:image or dis:encrypt:video for constrained clients. It does not state auth requirements, async/queueing behavior, or cost/credit implications, which matters for a job-submission 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?

Front-loaded with the pipeline and the required prerequisite before the optional-mode discussion, and most sentences earn their place by adding constraint information. It is somewhat dense and cluttered with RST-style double-backtick markup that hinders readability more than it helps.

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 13-parameter job-submission tool with an output schema present (so return values need no explanation), the description covers prerequisites, the alternative single-call detection mode, metadata-authority semantics, scope gating, and the one optional path. An agent has enough to invoke it correctly without opening the schema.

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

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

Schema coverage is only 31% across 13 params, yet the description meaningfully compensates: media_kind must match upload metadata, source_file_path only re-reads local file size for the split flow, and width/height/checksum/file_name/file_type are described collectively as authoritative-or-rejected. key_index/key_name/restoration/target_objects are already covered by schema descriptions, leaving encrypt_object_label and file_type effectively undefined.

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 action and resource (submit a DIS anonymization job) and sketches the underlying pipeline (syncTime → /request/encrypt → /sendMessage/encrypt), so an agent knows this is a job-submission tool rather than a synchronous image op. It implicitly separates itself from encrypt_image/encrypt_video by describing the detect-then-mask-in-one-call mode, but 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?

Gives concrete conditions: an asset_id from upload_file/upload_file_content is required, and target_objects=["face"] should be used when the workflow should stay one MCP call instead of chaining a detect tool plus a blur tool. That is a real use/use-differently signal, though it does not state when a caller should pick the sibling encrypt_image/encrypt_video 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 exist, so the description carries the full behavioral burden. It does disclose useful traits — the underlying transport, that the result is a ULID registered in public_id_map, and that heavy uploads are isolated from job submission — but says nothing about auth requirements, size limits, overwrite behavior on name collision, or failure modes, which matter for an upload 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?

Three short sentences, front-loaded with the action and endpoint, then the return contract. Dense and free of filler, though the heavy inline code formatting adds little for the reader.

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?

A write/upload tool with no annotations and 0% schema coverage needs more support than this. The output schema exists so return values are reasonably covered, but with three undocumented parameters and no stated constraints, limits, or collision behavior, the definition is only minimally sufficient.

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% and the description never mentions file_path, file_name, or file_type. The distinction between file_path and file_name, and the meaning/accepted values of the optional file_type (default empty string), are left entirely undocumented in both schema and description.

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

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

States a specific verb and resource with implementation detail ("Upload a file to legacy NAS via was-util /uploadNAS (port 5000)"), which distinguishes it from the encryption and billing siblings. It does not explicitly contrast with the closely-named sibling upload_file_content, so an agent must infer the path-vs-content distinction from the parameter names.

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 clear workflow context: the returned asset_id is "for use with submit_encrypt_job," which tells the agent this is a prerequisite step in the encryption pipeline. It offers no exclusions or explicit statement of when to prefer upload_file_content 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 exist, so the description carries the full burden. It usefully discloses that content goes only to a temporary file and is excluded from audit events, but says nothing about size limits, supported formats, permissions, or failure modes for a write 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?

Three tight sentences, front-loaded with purpose before the usage condition and the downstream id contract. 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?

An output schema exists, so the mention of the returned asset_id is bonus rather than necessity. However, missing format/size constraints and the meaning of file_type leave real gaps for an upload tool with zero annotation and zero schema-description coverage.

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% across 3 params. The description only implicitly covers file_base64 ('base64 image/video content'); file_name and file_type (default "", no enum, no description) remain unexplained, so an agent cannot infer valid values for file_type.

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 ('Upload base64 image/video content') plus the exact scope condition distinguishing it from sibling upload_file: clients that cannot share server file paths. An agent can select between the two upload variants 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?

Gives the selecting condition for this tool versus upload_file (no shared file path) and names the downstream consumer, submit_encrypt_job. It does not explicitly say 'use upload_file when you do have a path', so the routing is implied rather than enumerated.

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