Automatic Video De-identification MCP: Reversible Masking, Restore Original — NoonAI DIS

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

With no annotations, the description carries the full burden and does well: it discloses the two-step signed-URL fetch through legacy was-util, the server-side proxy rationale, the base64 default for small files, and the always-on local copy under data/downloads/<job_id>/ unless save_to_path is given. Remaining gaps are overwrite/duplicate behavior when a file already exists locally.

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 compact paragraphs, front-loaded with the core action, then the mechanism. Slightly dense with implementation detail (was-util, MinIO) but each sentence conveys operative 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?

Output schema exists so return values need not be described, and the side-effect of writing a local file is covered. However, for a 6-parameter tool with zero schema descriptions, the omission of file selection semantics and failure modes leaves meaningful gaps.

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 include_base64 and inline_base64_limit_bytes semantics and the save_to_path override, but leaves job_id, file_name, and especially the file_name vs file_index relationship unexplained.

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: download one completed encrypt result file through the gateway. It is clear enough to distinguish from get_job_status or submit_encrypt_job, but it never explicitly contrasts with the near-identical 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?

The phrase 'completed encrypt result' implies the job must be finished, but there is no explicit when-to-use or when-not guidance. Critically, it never routes the agent relative to get_job_result, which is the obvious alternative for retrieving job output.

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 behavioral burden, yet it only mentions that a "SaaS video policy validation" occurs. It omits whether the call is synchronous or returns a job id (the get_job_status/get_job_result siblings suggest async), whether credits are consumed (purchase_credits/get_pricing_policy siblings), what the key_index/key_name pair authorizes, and what restoration reverses.

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 action is front-loaded in the first sentence, and the follow-on paragraph is short and non-redundant. The final sentence about face is somewhat long-winded but does carry decision-relevant content, so waste is minimal.

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 an 8-parameter, no-annotation, credit-consuming media job the description is far too thin: key handling, restoration semantics, and job/credit behavior are all absent. It covers only the target-object policy, leaving most invocation risk 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% across 8 parameters, so the description must compensate, and it only covers the accepted values of target_objects (body, face, car). Four required parameters (file_path, file_name, key_index, key_name) and behaviorally significant optional ones (restoration, encrypt_object_label, file_type) get no explanation at all.

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 opening sentence names a specific verb and resource ("One-shot video anonymization") and adds scope detail ("with SaaS video policy validation"), so an agent immediately knows this is a single-call video redaction tool. It implicitly separates itself from chained detect/blur tools and from the image sibling, but never names encrypt_image or submit_encrypt_job directly, which keeps it short of 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 description does give real selection guidance, but only for one parameter value: "Use face when the goal is a single-call workflow ... rather than chaining separate detect and blur tools." It says nothing about when to choose encrypt_video over encrypt_image, or over the submit_encrypt_job + get_job_status job flow implied by the sibling 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?

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?

With no annotations, the description carries the full burden, yet it only implies read-only behavior through "Return ... policy". It says nothing about auth/permission requirements, whether policy varies per account, caching, or any side effects; only the vague qualifier "SaaS-side" hints at a client-side counterpart.

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 term "target-selection policy" is dense jargon left unexpanded.

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 spelled out, and one optional parameter keeps the surface small. Still, for a policy/constraints getter the description gives no sense of what the policy governs or how it should shape subsequent calls.

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 file_kind parameter has a default of "video" with no enum or description. The phrase "image/video" implicitly maps to the two possible values of file_kind, which partially compensates, but the default and accepted value set are still 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?

States a specific verb ("Return") and a specific resource ("SaaS-side upload and target-selection policy for image/video detect-then-blur anonymization"). It is distinguishable from siblings like get_pricing_policy or encrypt_video, though it does not explicitly name what it is not.

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 sentence states when to call this versus encrypt_image, encrypt_video, or submit_encrypt_job. The purpose implies it is a pre-flight policy lookup before upload/encrypt, but that is inference rather than 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 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 does carry real behavioral weight: it discloses that gateway-registry metadata is authoritative and that mismatched caller values are rejected, and it names the scope gate (dis:encrypt:image / dis:encrypt:video) that authorization depends on. However, for a mutating job-submission tool it omits job lifecycle semantics (async submission, polling via get_job_status), credit/cost implications implied by the billing siblings, and failure 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 purpose and the asset_id prerequisite are front-loaded, which is good. The opening endpoint chain ('syncTime' → /request/encrypt → /sendMessage/encrypt) is internal plumbing that adds little for an agent choosing and calling the tool, and the backtick-heavy formatting makes the text denser than it needs to be.

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, but the definition leaves significant gaps for a 13-parameter mutation tool with no annotations: two of the three required parameters (key_index, key_name) are never described, and there is no indication of job asynchrony or billing impact. An agent could construct a call but would be guessing at the meaning of required 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%, so the description must compensate for all 13 parameters. It adds real meaning for asset_id, target_objects, media_kind, and source_file_path, and implies width/height/checksum/file_name are validated against upload metadata. It never mentions the other required parameters key_index and key_name, nor restoration, encrypt_object_label, or 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?

The description opens with a specific verb+resource ('Submit a DIS anonymization job') and names the concrete pipeline it drives, so the agent knows exactly what operation is being performed. It also distinguishes itself from the sibling encrypt_image/encrypt_video path by explaining the target_objects=['face'] single-call flow. It stops short of a crisp one-line differentiation from 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 states a hard prerequisite (a valid asset_id from upload_file or upload_file_content) and gives an explicit selection rule for target_objects=['face'] versus chaining a separate detect tool plus blur tool. What is missing is explicit guidance on when to call submit_encrypt_job versus calling encrypt_image or encrypt_video directly.

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.