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

With no annotations, the description carries full behavioral burden and does well by disclosing the 15-minute lease and the 409 conflict response. It does not cover success return values, re-claiming by the same agent, or expiration details, but the core behavioral contract is 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 a single compact sentence with the primary action front-loaded and the lease duration and error condition appended in parentheses. Every word adds useful information and there is no filler.

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

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

For a one-parameter tool with no annotations and no output schema, the description captures the essential contract: what is locked, for how long, to whom, and what happens if another agent holds it. Minor gaps like the success response and same-agent re-claim behavior prevent a perfect score.

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 does not explicitly describe challenge_id, but the phrase 'a challenge' and the lock/lease semantics make the parameter's purpose inferable. The single required UUID parameter is self-explanatory enough that the lack of explicit parameter documentation is not severely harmful.

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

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

The description names a specific verb ('Lock'), a clear resource ('a challenge'), and the scope ('to this agent'), immediately distinguishing it from siblings like release_challenge or get_challenge. The 15-minute lease and 409 condition further pin down what the tool does.

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

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

The description implies this is the tool for acquiring an exclusive, time-limited lock on a challenge, and the 409 clause warns against claiming when another agent already holds it. However, it does not explicitly contrast with release_challenge or state when claiming is required versus optional.

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 explicitly flags the mutation nature via 'Create (write)' — the most important safety-relevant behavior for an agent weighing whether to call it. However, it does not disclose what happens after creation: no return value, no indication of whether the event must already exist, no idempotency or duplication behavior, and no permission requirements.

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

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

A single ~18-word sentence with the verb and resource front-loaded before the use cases. Every clause earns its place — the '(write)' qualifier, the resource scope, and the em-dash use-case context — with zero filler or repetition of schema content.

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

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

For an 8-parameter mutation tool with no annotations and no output schema, the description covers purpose and when-to-use but omits critical invocation details: what the call returns, whether the event must pre-exist, and how failures surface. The missing return-value information is especially notable since no output schema exists to fill that 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 50%, leaving tags, title, points, and category undocumented in the schema, and the description does not compensate. The only parameter-level contribution is 'in an event,' which clarifies the event parameter's role; the remaining undocumented parameters receive no additional meaning from the 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 the specific verb 'Create' reinforced by '(write)' and the resource 'a new challenge in an event.' The verb clearly differentiates from sibling CRUD tools (update_challenge, delete_challenge, get_challenge, list_challenges), and the explicit write flag distinguishes it from the read-only tools in the sibling set.

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

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

Names concrete use cases — 'manual entry, mockups, or archiving self-made challenges' — giving the agent clear situations in which to invoke it. It does not name alternatives or state when not to use it (e.g., that update_challenge is for modifying existing challenges), so no explicit exclusions are present.

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

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

With no annotations, the description carries the burden of disclosing behavior. It does state the admin requirement and the fact that a new event is created, but it omits side effects, defaults, validation behavior, and response details.

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

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

The description is a single, front-loaded sentence with no fluff. The admin-role requirement is usefully added rather than buried or omitted.

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

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

Given 7 parameters, no output schema, no annotations, and 0% schema description coverage, the one-sentence description is insufficient. An agent still lacks guidance on defaults, parameter meaning, uniqueness constraints, or what happens on success.

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 does not mention any of the 7 parameters or the 3 required ones. It adds no semantic meaning beyond the raw property names, enums, and patterns already present in the schema.

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

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

The description clearly names the action ('Create'), the resource ('new CTF event'), and includes an important access condition (admin role). This distinguishes it from sibling tools focused on challenges, evidence, and artifacts.

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

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

It gives clear context for when to use the tool: when creating a new CTF event, and it notes the admin-role prerequisite. It does not explicitly call out alternatives, but no sibling tool duplicates event creation.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It clearly discloses two important behaviors: the operation is restricted to admins and it cascades to evidence, flags, and artifacts. This is strong transparency for a destructive operation, though it does not mention whether the action is reversible.

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, compact sentence that front-loads the primary action and then packs two critical constraints (admin-only, cascading deletion) into four words. There is no filler or redundancy.

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

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

For a one-parameter destructive delete tool with no output schema, this description covers all essential operational context: what is deleted, the permission requirement, and the cascading behavior. Nothing an agent needs to decide whether to call it is missing.

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

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

The schema has one self-explanatory parameter, challenge_id, with a UUID format and pattern. The description does not add parameter-level detail, but the parameter's purpose is obvious from the tool action and schema, slightly mitigating the 0% schema description coverage.

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

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

Identifies the exact action (Delete), the target resource (a challenge), and the scope of deletion (its evidence/flags/artifacts). This clearly distinguishes it from update_challenge and set_challenge_status, which modify rather than destroy.

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?

States when this tool is appropriate: an admin deleting a challenge and its associated data. It also implies non-admins and users who only want to modify or release a challenge should use alternatives, though it does not name them explicitly.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose the output fields (description, status, tags, flag status, lock owner), which adds value beyond the name. However, it does not explicitly state that the operation is read-only, nor what happens for missing/invalid IDs or whether flag status is visibility-restricted.

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

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

The description is a single concise sentence with the verb, resource, and returned fields front-loaded. There is no filler or redundant information.

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

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

For a simple one-parameter getter with no output schema, the description sufficiently names the key returned fields and the required identifier. It omits error/not-found behavior and access controls, but these are minor for a low-complexity read operation.

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

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

Schema description coverage is 0%, and the description adds little beyond 'challenge's' to explain challenge_id. However, the parameter is self-descriptive, and the schema provides a UUID format and pattern, so the minimal compensation is adequate for a single obvious 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?

The description uses a specific verb ('Get') with a clear resource ('one challenge's summary') and enumerates the exact fields returned. This distinguishes it from siblings like list_challenges (all challenges) and get_writeup (writeup-specific retrieval).

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 singular 'one challenge's' clearly implies this is for fetching a single challenge by ID, which separates it from list_challenges. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for an agent.

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. 'Read' implies a non-destructive retrieval, and the content note adds some specificity. However, it does not disclose what happens when no writeup exists, whether the full writeup is returned, or any access/error behavior; no output schema fills that gap.

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

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

The description is a single short sentence with no filler, front-loads the operation and resource, and uses the parenthetical for extra content context. It is economical and well-structured.

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

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

For a one-parameter read tool, the core call is clear, but with no output schema and no stated behavior for missing writeups, an agent cannot fully predict the response. The 'Thai human + English AI' note is the only extra context and is itself somewhat ambiguous.

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

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

The schema exposes one required challenge_id with format and pattern, but gives no semantic description. The tool description only implies via 'a challenge's' that challenge_id identifies the challenge. Because there is exactly one self-explanatory parameter, the cost is low, but the meaning is still left implicit.

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 ('Read') and a clear resource ('a challenge's writeup'), making the operation unambiguous. It also distinguishes itself from the sibling save_writeup by read/write orientation. The parenthetical content note adds detail without obscuring the purpose.

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

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

The description gives clear context: use this when you need an existing challenge writeup. The 'Read' wording naturally contrasts with the sibling save_writeup, so the appropriate selection is straightforward. It does not explicitly list exclusions or alternatives, but the pair is obvious.

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?

There are no annotations, so the description carries the behavioral burden. It communicates that the operation is a read-only listing and that results include sha256 hashes, but it does not disclose pagination, output format, permissions, or error behavior. This is adequate but with clear 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 sentence conveys the action, resource, scope, example artifact types, and a key output field with no wasted words. The most important information is front-loaded.

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

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

For a one-parameter list tool, the description is mostly sufficient to attempt a call, especially with the schema providing the required UUID format. However, there is no output schema and no mention of return structure, pagination, or relation to upload_artifact, leaving some ambiguity about what a successful response contains.

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

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

The input schema has 0% description coverage for challenge_id, and the description does not explicitly explain the parameter or its format beyond the context 'attached to a challenge'. The tool name and schema format make challenge_id somewhat self-evident, but the description adds little direct parameter-level meaning.

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

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

The description clearly states the verb 'List' and the resource 'files/artifacts attached to a challenge', with concrete examples (images, pcaps, notes) and an output detail (sha256). This distinguishes it from sibling tools like list_events or list_challenges, which target different resources.

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

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

No guidance is provided on when to use this tool versus alternatives such as upload_artifact or list_evidence. The description implies usage from the tool name, but it does not give context, prerequisites, or exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'List' implies a read operation, but the description does not mention pagination, ordering, filtering semantics, or any limits. An agent gets little beyond the literal fact that challenges are listed.

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, focused sentence with no filler. It states the action, the resource, and the key input format efficiently.

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

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

For a tool with no output schema and no annotations, the description is too sparse. It does not describe the returned data shape, explain the optional filter parameters, or provide enough context for an agent to know what values or behavior to expect when using status and category.

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 only 33%, so the description must compensate. It adds useful meaning for the required 'event' parameter by saying it accepts an ID or slug, but the optional 'status' and 'category' parameters remain completely unexplained in both the schema and the 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?

The description names a specific verb and resource: 'List challenges in an event'. It also clarifies the key input as 'event id or slug'. It does not explicitly distinguish itself from sibling tools, but the intent is clear enough that an agent can separate it from list_events and get_challenge.

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

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

No guidance is provided about when to use this tool versus alternatives. There is no mention of when list_events or get_challenge would be more appropriate, nor any exclusions or prerequisites beyond naming the event.

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

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

With no annotations provided, the description carries the full burden. 'List' implies a read-only operation, and 'with challenge/solved counts' hints at the return content, but the description does not disclose ordering, pagination, filtering, authentication, or potential edge cases. For a simple zero-parameter list, this is adequate but still leaves room for clarification.

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

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

The description is a single sentence with no redundancy. The action ('List'), resource ('CTF events'), and relevant output detail ('challenge/solved counts') are all front-loaded, and every word earns its place.

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

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

For a zero-parameter list operation with no output schema, the description conveys the essential purpose and a key part of the return value. It is missing explicit notes on read-only behavior, default ordering, or whether all events or only upcoming ones are returned, but these are minor gaps given the tool's simplicity.

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

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

The tool has zero parameters, so there is nothing for the description to explain beyond what is already evident from the empty input schema. The absence of parameters makes this dimension trivially satisfied, matching the baseline of 4.

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

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

The description uses a specific verb ('List') and resource ('CTF events') and adds a distinct detail ('with challenge/solved counts'). This clearly separates it from sibling tools like list_challenges, which lists challenges instead of events, and create_event, which creates rather than lists.

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 intended use is implied by the verb and resource, but there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions. An agent can infer it is for listing events rather than challenges, but the description does not state direct conditions or mention siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It conveys a read-only listing operation scoped to a challenge, but it does not mention pagination, ordering, output shape, or whether full evidence details are returned. This is a minimal behavioral disclosure with significant gaps.

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

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

The description is a single, front-loaded sentence with no filler. It conveys the verb, resource, and scope efficiently, earning its place without unnecessary detail.

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

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

Given the absence of annotations, output schema, and usage guidance, the description is only minimally adequate for invoking the tool with a challenge_id. It does not explain what the response contains, whether results are paginated, or how this tool relates to the surrounding evidence workflow.

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 does not explicitly explain the challenge_id parameter. It only hints at the parameter by saying 'on a challenge'. The schema defines the UUID format, but the description adds little semantic meaning beyond that.

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

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

The description uses a specific verb ('List') and resource ('evidence'), and qualifies it with 'recorded on a challenge'. This clearly distinguishes it from sibling list tools like list_events, list_flags, and list_artifacts, though it does not explicitly name an alternative.

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

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

No guidance is provided about when to use this tool versus alternatives such as save_evidence, get_challenge, or list_flags. There are no conditions, exclusions, or context about the intended workflow, leaving the agent to infer usage 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 provided, the description carries the behavioral disclosure burden. It meaningfully discloses that the vault never returns plaintext and that only redacted previews are provided, which is important for an agent's expectations about output sensitivity. It does not mention permissions or pagination, but for a simple list operation this is useful transparency.

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

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

A single sentence with no filler, front-loading the action ('List flags on a challenge') and then adding the key behavioral caveat about redaction. Every word earns its place.

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

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

For a tool with one parameter and no output schema, the description covers the operation, the scoping resource, and the nature of the returned data. It is slightly light on explicit parameter semantics and any error or pagination behavior, but those are minor gaps for this simple tool.

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

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

Schema property descriptions are 0%, so the description must compensate. It only says 'on a challenge', which implies challenge_id identifies the target challenge, but it does not explicitly explain the parameter's role, format, or requiredness. The schema already defines the UUID format and required flag, and the single self-explanatory parameter makes this minimally adequate.

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: 'List flags on a challenge', and further clarifies the output is redacted previews. This clearly differentiates it from sibling tools such as submit_flag_candidate (submission) and get_challenge (challenge detail retrieval).

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

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

The description implies the tool is used for listing flags on a challenge, but it provides no explicit guidance on when to choose this tool over alternatives, nor any exclusions or prerequisites. There is no reference to sibling tools or conditions that would make this tool the right choice.

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. 'Release' signals a mutation, but the description does not disclose what happens if no claim/lock exists, whether the operation is idempotent, what permissions are required, or whether it affects challenge state/data. This is a meaningful gap for a state-changing 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?

A single sentence that is front-loaded with the key action and resource, with no filler or redundant restatement of the tool name. It is appropriately sized for the tool's simplicity.

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

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

The tool is simple (one required parameter, no nested objects), so the description may suffice for a basic call. However, with no annotations and no output schema, it lacks safety/error/return behavior (e.g., failing if the challenge is not claimed), leaving an agent to guess at edge cases.

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 description does not explicitly map challenge_id, but 'on a challenge' plus the self-naming parameter make the intended identifier clear. The schema provides type/format/required, so the description adds only a slight semantic link; at 0% schema_description_coverage, more explicit parameter guidance would improve it.

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

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

The description uses a specific verb ('Release') and a clear resource ('claim/lock on a challenge'), so an agent can tell that this undoes the claim made by claim_challenge. It does not explicitly name the sibling or contrast itself, so it falls 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?

There is no guidance on when to call this tool versus alternatives, no prerequisites, and no mention that claim_challenge is the counterpart. The only usage signal is the action itself, which implies but does not explain the condition (e.g., a claim must exist).

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says evidence is 'recorded,' but does not explain side effects, return behavior, whether it creates a new evidence entry, or what happens on validation failure. This is a lean description that leaves the tool's runtime behavior largely implicit.

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

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

The description is a single front-loaded sentence with no filler. Every part adds meaning: the action, the resource, the context, and the examples of evidence.

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

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

With no output schema and no annotations, the description is the only source of guidance, but it does not explain what the tool returns, that evidence is tied to a challenge_id, or what constraints apply. The operation is simple, yet several practical details an agent would need for correct invocation are missing.

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

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

The schema covers 50% of parameters with descriptions (content, command_text), and the description adds examples like 'hypothesis, observation, command output' that map onto the evidence_type enum. However, it does not clarify challenge_id semantics or the conditional relationship between command_text and evidence_type beyond what the schema already provides.

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

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

The description uses a specific verb ('Record') with a clear resource ('evidence') and gives concrete examples of what counts as evidence: hypothesis, observation, command output. This distinguishes it from siblings like list_evidence and create_event, which are clearly different actions and resources.

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

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

'During solving' provides a clear context for when this tool should be used, and the examples of evidence types help an agent decide that this is the right place for hypotheses, observations, and command outputs. It does not explicitly name alternative tools or exclusion cases, but the context is clear enough for a simple recording operation.

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

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

With no annotations provided, the description carries the full burden, and it does disclose meaningful behavior: markdown rendering context, the artifact-id image workflow, and a concrete failure mode ('relative paths like /_astro/... will 404'). The critical gap is that it never states whether saving overwrites an existing writeup for the same challenge, which is essential mutation semantics for a save 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?

The core purpose is front-loaded in the first sentence, followed by a numbered image-embedding workflow and a concise 404 warning. Every sentence earns its place, and the list format is scannable. Slightly verbose in the rendering sentence, but overall tight and well-organized.

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

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

Despite no output schema and no annotations, the description handles the complex parts well: rendering behavior, the two-step artifact workflow, and a known failure mode. But it omits two things an agent needs to call it safely: the meaning of the status enum values, and whether re-saving the same challenge_id replaces the existing writeup. These gaps keep it from being fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It adds real meaning for language ('Thai for human review, English for AI-generated') and for markdown (rendering rules, image syntax, forbidden paths). However, the status enum (draft/reviewed/final) is completely unexplained, and challenge_id semantics beyond the schema's uuid format are absent — a notable gap for an optional enum field the agent must choose among.

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

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

The description states a specific verb+resource+format: 'Save a writeup as markdown.' The language mapping ('Thai for human review, English for AI-generated') further clarifies scope and differentiates this from the read-side sibling get_writeup and from save_evidence by resource type. It doesn't name siblings explicitly, so it falls just 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 gives clear conditional workflow guidance: 'To embed an image: upload it with upload_artifact → reference it in the markdown,' and notes external URLs as an alternative. The Thai/English instruction tells the agent which language value to use in which scenario. However, it never states when to prefer this over save_evidence or get_writeup, and there are no explicit 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?

No annotations are provided, so the description carries the full burden. It discloses the search scope and content coverage, and the verb 'search' implies a read-only operation. It does not explicitly state that no data is modified, nor does it mention result format, pagination, or performance implications of searching across all events.

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

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

A single, front-loaded sentence that states the action, scope, content types, and intended use in sequence. Every part earns its place; no redundant modifiers. The structure is ideal for quick agent scanning.

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

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

For a simple two-parameter search tool with no output schema, the description gives enough to select and invoke it: query text is covered by the schema, and the description adds the cross-event scope and likely purpose. It does not describe the return shape, but for a search tool with no output schema this is a minor gap rather than a blocker.

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 50%: q is described, but language only has an enum. The description's reference to 'writeups (Thai/English)' hints at the language dimension, but it does not directly explain the language parameter's filtering behavior. The q parameter's purpose is already clear in the schema; the description adds searchable-content context but no parameter-level detail.

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

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

The description opens with a specific verb and resource ('Search across all events') and enumerates the exact content types searched: challenge descriptions, writeups (Thai/English), and tags. This clearly distinguishes it from sibling CRUD/list tools, which operate on individual events, challenges, or writeups rather than cross-cutting search.

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 'find how similar challenges were solved before' implies a research/knowledge-retrieval use case, and the scope 'all events' suggests when a broad search is appropriate. However, it does not explicitly state when to prefer this tool over alternatives such as get_writeup or list_challenges, and it offers no exclusions or conditions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the operation updates working status, but it does not describe side effects, permission requirements, transition constraints, or whether any status can be set from any current state.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently communicates the action and the allowed values, and is appropriately sized for a simple two-parameter tool.

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

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

The tool is simple and the input schema is rich with an enum and UUID format, which helps completeness. However, there is no output schema, no annotations, and no mention of side effects or status transition rules, leaving some contextual gaps for an agent deciding how to invoke and interpret this tool.

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

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

Schema description coverage is 0%, so the description must compensate. It repeats the status enum values that already exist in the schema but adds no meaning about the challenge_id parameter or how the statuses relate to each other. The description does not clarify behavior beyond what the schema already provides.

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

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

The description clearly states the verb 'Update' and the resource 'working status', and enumerates all valid status values. It is distinguishable from sibling tools like update_challenge because it focuses specifically on the status field, though it does not explicitly name that distinction.

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

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

There is no guidance on when to use this tool versus alternatives such as update_challenge, claim_challenge, or release_challenge. The description implies usage but does not explain workflow context, prerequisites, or when not to use it.

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

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

With no annotations, the description carries the full burden, and it does disclose two meaningful behaviors: encryption at rest and deduplication. However, it omits important behavioral details such as whether duplicates are rejected or silently ignored, whether the operation is idempotent, what auth is required, and what happens on success or failure. The disclosure is useful but incomplete for a mutation-style 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?

The description is a single, compact sentence that front-loads the primary action and resource, then adds two high-value behavioral details in parentheses. Every phrase earns its place with no redundant or filler content.

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

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

For a tool with no annotations and no output schema, the description leaves significant gaps: it does not explain the workflow around flag candidates, whether this affects challenge state, or what response the caller should expect. It also does not clarify how this relates to claim_challenge or list_flags. The core action is clear, but the surrounding context is under-specified.

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

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

The schema already provides descriptions for value and source, and a UUID format/pattern for challenge_id, covering 67% of parameters. The description adds no parameter-specific semantics, such as explaining that 'value' is the raw flag string or that 'source' is optional context. This is acceptable but not exceptional given the schema's existing coverage.

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

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

The description uses a specific verb ('Store') and resource ('a flag candidate for a challenge'), making the tool's core purpose clear. It also adds two distinguishing operational details—encrypted at rest and deduplicated—that separate it from read-only siblings like list_flags. However, it does not explicitly contrast it with any sibling tool, so it stops short of full differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is for storing a candidate before final submission, nor does it route users to list_flags or claim_challenge for related operations. Usage context is entirely implied by the tool's name and schema.

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 only states that the tool updates fields, which is essentially the core operation; it does not disclose whether updates are partial or full replacement, how omitted fields are treated, what happens on invalid input, or whether permissions are required. No contradiction with annotations exists, but the behavioral detail is minimal.

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 'Update' and the resource 'existing challenge's fields' appear first, making the core purpose immediately clear. It is concise, though the ellipsis placeholder is a minor structural weakness.

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

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

For a tool with 7 parameters, no output schema, and no annotations, this description is incomplete. It does not explain partial-update behavior, which fields are optional, whether a full replacement occurs, or how the update interacts with sibling status/claim tools. An agent would need to inspect the schema and infer several important behaviors to safely invoke the tool.

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

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

Schema description coverage is 0%, so the description must compensate, but it only names a few fields (title, description, points, tags) and relies on '...' for the rest. It does not explain that challenge_id is the required identifier, that other fields are optional, or how the update semantics apply to each parameter. This adds little beyond the schema's property names.

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

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

The description clearly identifies the operation as updating an existing challenge's fields, with concrete examples (title, description, points, tags). This distinguishes it from create/delete/get/list sibling tools. However, it leaves the scope slightly open with '...' and does not clarify whether status updates are included or excluded, especially given the separate set_challenge_status sibling.

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

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

The description implies usage: use this when you need to modify fields on an existing challenge. It does not explicitly state when not to use it or mention alternatives like create_challenge or set_challenge_status, so the agent must infer the boundary. This is adequate but lacks direct routing guidance.

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

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

With no annotations, the description carries the behavioral burden. It discloses the operation, the input modes, the returned artifact record, and the practical use of its id for embedding images in writeups. It does not cover permissions, size limits, or overwrite behavior, but the core behavior is transparent.

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

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

The description is compact, front-loaded with the core purpose, and every sentence adds either usage or output context. The embed example is directly actionable without adding unnecessary length.

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 5-parameter tool with no output schema and no annotations, the description covers the main workflow, return value, and a concrete downstream use. It is not fully exhaustive because mime_type and encoding details are left implicit, but it is sufficiently complete for an agent to call it correctly in most cases.

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 usefully explains the file_path vs. content_base64 distinction and the role of filename, but it does not mention mime_type or clarify that 'raw content bytes' should be base64-encoded as content_base64 implies. This leaves some parameter ambiguity.

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

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

The description names a specific verb ('Upload'), a target resource ('a challenge as an artifact'), and gives concrete examples of accepted file types. This clearly distinguishes it from siblings like list_artifacts or save_evidence.

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

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

It gives clear context: upload an artifact to a challenge, and provides two mutually exclusive input methods (local file path vs. raw content bytes with a filename). It does not explicitly name sibling alternatives or state when not to use the tool, so it stops short of a 5.

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