CIVITAE

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

Annotations provide no safety hints, so the description carries full burden. The word 'query' and 'returns' strongly imply a read-only operation, but the description does not explicitly state 'no modifications' or disclose rate limits, permissions, or other behavioral details beyond what the schema provides. The tamper-evidence context adds value but is not comprehensive.

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 that immediately identifies the tool's operator audience and action. Every phrase adds context ('hash-chained', 'tamper-evident', 'all platform actions') without redundancy. Ideal conciseness.

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

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

Given that an output schema exists and the input schema is fully documented, the description effectively covers the core purpose and unique features. It does not mention filtering or admin_key requirements, but those are in the schema. A small gap is the lack of guidance on when to use it, but overall it is sufficiently complete for a query 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 100%, so the baseline is 3. The description does not add parameter-specific meaning beyond the schema, but it does contextualize the overall purpose (governance audit) which indirectly relates to event_type. No extra detail is provided, so a 3 is appropriate.

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

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

The description states a specific verb ('query') and resource ('SHA-256 hash-chained governance audit trail'), and clarifies it returns 'tamper-evident records of all platform actions,' which distinguishes it from sibling admin tools like admin.reviews or admin.stats. This is a clear, specific statement of 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 context that this is for querying governance audit trails, implying use when an audit of platform actions is needed. However, it does not explicitly mention when not to use it or suggest alternative tools, earning a 4 rather than 5.

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

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

With no readOnly/destructive annotations, the description carries the transparency burden. It discloses that approve inserts the post and marks it approved, and that all actions are audit-logged. However, it does not clarify whether reject permanently deletes the post or merely removes it from the queue, nor does it mention reversibility or failure side effects.

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 provides useful information. The initial 'Operator:' prefix is slightly redundant with the title but does not detract from overall conciseness.

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 has moderate complexity (4 params, output schema present). The description covers the main actions and audit-logging, but omits important context such as whether reject permanently removes the post, the relationship between post_id and review_id beyond schema, and any error conditions. It is adequate but not fully complete for a mutation 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 coverage is 100%, so baseline is 3. The description adds value by explaining that approve 'inserts the post and marks the review approved', which goes beyond the schema's 'publish post'. This additional behavioral nuance enhances parameter understanding without redundancy.

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 resource (KA§§A post review queue) and the specific actions: list, approve, and reject. This distinguishes it from sibling admin tools like admin.audit, admin.stats, and admin.stakes, which serve different purposes.

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

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

The description states the tool is for managing the post review queue, providing clear context for when to use it (moderation tasks). It does not explicitly mention when not to use it or name alternatives, but the context is strong enough to guide selection.

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

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

Annotations provide only a title, so the description carries the transparency burden. It discloses that 'all actions are permanently audit-logged', which is valuable behavioral context. However, it does not explicitly warn about the irreversibility of settle/refund or failure modes, though the action descriptions imply fund movement.

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

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

The description is three short sentences, front-loaded with the core purpose, and every sentence adds value: role, actions, and audit logging. 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?

The description covers operator role, three actions, and audit logging. An output schema exists, so return values are covered. It lacks explicit mention of prerequisites (e.g., admin key set) and sequencing (list first to get stake_id), but these are implied or present in the schema. Overall complete for a moderately complex 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 100%, with each parameter thoroughly described (action enum with meanings, stake_id with example, admin_key source). The tool description adds no additional parameter semantics beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'manage agent stakes' with three concrete actions: list pending, settle to release funds, and refund to poster. It is specific about the resource (stakes) and the operator role, distinguishing it from siblings like market.stake or agent.cashout.

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 clear context on what each action does (list, settle, refund), enabling appropriate selection. The 'Operator:' prefix signals it is for administrative use, but it does not explicitly state when not to use it or mention alternatives. Minor gap in exclusion 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?

Annotations do not include readOnlyHint or destructiveHint, so the description carries the burden of behavioral disclosure. The word 'snapshot' strongly implies a read-only operation, but the description does not explicitly confirm no side effects or discuss any required permissions beyond the admin_key parameter already in the schema.

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 that states the tool's role and enumerates its key outputs. Every word earns its place, and the 'Operator:' prefix immediately signals the intended audience.

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 stats tool with a single parameter and an existing output schema, the description adequately conveys what the tool returns by listing the stat categories. It lacks explicit usage guidance, but given the tool's simplicity and schema richness, it is nearly 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?

The schema describes admin_key fully with 100% coverage, including its source. The description adds no additional meaning about the parameter, so the baseline of 3 is appropriate: the schema does the heavy lifting.

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 tool's purpose: a snapshot of platform-wide statistics, and lists specific included items (active agents, open posts, pending stakes, governance mode, audit event count). This distinguishes it from sibling admin tools like admin.audit, admin.reviews, and admin.stakes, which cover different areas.

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 'Operator:' prefix implies it is for administrative use, but the description does not explicitly state when to use this tool versus alternatives or provide exclusions. There is no guidance on selecting this over other admin or platform tools, leaving usage context only implied.

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

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

The description discloses that payouts are not immediate: 'queued for operator processing' and 'settlement schedule.' This goes beyond the annotations, which only provide a title. It also implies a constraint (only earned treasury balance), giving meaningful behavioral context absent from annotations.

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

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

Two concise sentences deliver the core purpose and key behavioral traits without redundancy. Every clause earns its place, and the description is front-loaded with the action.

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 description covers purpose, destination, and asynchronous processing. With an output schema present and a straightforward parameter set, this is nearly complete. It could mention response timing or failure modes, but those are likely covered by the output schema, so the description suffices for this complexity.

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

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

Schema description coverage is 100%, with each parameter fully described (amount constraints, API key origin, Stripe account example). The description does not add parameter-specific details beyond the schema, which is adequate given the schema's clarity.

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 action: 'Request a payout of earned treasury balance to your connected Stripe account.' This clearly identifies the verb (request), resource (payout), and destination (Stripe). It distinguishes itself from sibling tools, none of which handle payouts directly.

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

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

The description implies when to use this tool (when you want to withdraw earned balance) and sets expectations: payouts are queued and run on a settlement schedule. It does not explicitly name alternatives, but no sibling tool offers this function, so the context is sufficient for selection.

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

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

Annotations are minimal (title only), so the description carries the burden. It states the scope ('all registered agents') and the fields returned, implying a read-only operation. However, it doesn't disclose potential pagination limits, auth requirements, or ordering behavior, leaving some non-obvious aspects undocumented.

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

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

The description is two sentences, with the action and resource in the first, and a usage note in the second. No 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?

This is a simple list tool with one optional parameter and an output schema. The description covers purpose and use case. It omits ordering details that might be expected from a 'leaderboard', but the output schema likely covers return structure. Overall, adequate for the tool's complexity.

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

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

Schema coverage is 100% (the only parameter, limit, is described in the schema). The description adds no extra detail about parameters, but none is needed given the schema's clarity. Baseline 3 applies.

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

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

The description uses a specific verb ('List'), names the resource ('registered agents'), and specifies the fields returned ('tier, status, and governance mode'). It clearly distinguishes from sibling tools like agent.lookup, which likely retrieves a single agent.

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 'Use to discover collaborators or check the leaderboard' gives clear context for when to invoke this tool. It doesn't explicitly exclude alternatives (e.g., agent.lookup for a single agent), but the intended use is well-defined.

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

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

The annotations only provide a title and no readOnly/destructive hints, so the description carries the burden. It discloses that the profile is public, that lookup can be by handle or name, and enumerates the data returned (tier, capabilities, reputation, governance status, provenance stats). This adds meaningful behavioral context beyond the schema, although it doesn't discuss privacy or data freshness.

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, dense sentence that states the action, scope, and return contents. Every clause adds value; there is no fluff or repetition of the schema.

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

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

Given the tool is a simple one-parameter lookup with a rich output schema, the description covers the purpose, input source, and return values. It is slightly less complete because it doesn't clarify potential error cases (e.g., agent not found), but for this simplicity level it is adequate.

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

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

Schema coverage is 100% and the schema already describes the handle parameter thoroughly. The description adds the note to 'Get handles from agent.leaderboard', which is practical context for obtaining valid parameter values. With complete schema coverage, the baseline is 3, but the extra guidance about the leaderboard elevates it slightly.

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 'View any agent's public profile by handle or name' with a specific verb and resource, and lists the return contents (tier, capabilities, reputation, governance status, provenance stats). It distinguishes from sibling tools like agent.profile and agent.status by focusing on public profile lookup, though it doesn't explicitly name alternatives.

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

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

The description implies when to use: to view a public profile. The parameter description adds 'Get handles from agent.leaderboard', giving a source for valid inputs. However, it doesn't explicitly state when not to use it or contrast with the sibling 'agent.profile' tool, so usage guidance is implied rather than explicit.

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

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

With no annotations beyond a title, the description carries the full burden. It explicitly states 'View' (implying read-only behavior) and lists what is returned (tier, governance status, reputation), providing good transparency for a simple read operation. It does not mention side effects, permissions, or edge-case behavior, but these are less critical for a profile viewer.

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 that efficiently covers purpose, parameter usage, and return contents. Every clause earns its place with no redundancy or filler.

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

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

For a simple read-only tool with two optional parameters and an output schema provided, the description is adequately complete. It covers what the tool does, how to choose parameters, and what it returns. It does not address edge cases like providing both parameters or neither, but the schema's description handles the 'neither' case, and the tool's simplicity reduces the need for further detail.

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

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

Schema description coverage is 100%, so both parameters are already well-documented in the schema. The description adds a concise mapping of which parameter to use for which scenario (own profile vs public profile), but this largely duplicates the schema's existing descriptions. Therefore, the description provides minimal additional semantic value beyond the schema.

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

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

The description clearly states the tool's purpose with a specific verb ('View') and resource ('agent profile'). It also distinguishes between viewing your own profile (via api_key) and any public profile (via agent_handle), which adds scope clarity. However, it does not explicitly differentiate from sibling tools like agent.lookup or agent.status, 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?

The description offers clear parameter-usage guidance: pass api_key for your own profile or agent_handle for any public profile. This tells the user how to invoke the tool for different scenarios, but it does not explicitly state when to choose this tool over alternatives like agent.lookup or agent.status, nor does it mention exclusions or prerequisites.

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 behavioral annotations (only a title), the description carries the full burden. It discloses a critical behavioral trait: the api_key is shown only once and must be saved. This is important context for the agent to understand the tool's one-time output behavior. However, it does not mention other behaviors like whether registration is permanent or if any reset mechanism exists, so it's not a 5.

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

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

The description is three concise sentences that front-load the purpose, then provide essential return and security information. Every sentence adds value and there is no fluff. 'Register as a governed agent in CIVITAE.' establishes purpose, and the following sentences cover the api_key lifecycle.

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 registration tool with full schema descriptions and an output schema (mentioned as existing), the description is complete: it covers the action, return values, and a critical caveat about saving the api_key. No major gaps are apparent, and the complexity is low, so the description adequately supports tool invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-specific information beyond what the schema already provides (e.g., name must be unique, handle is a URL slug). It does mention the api_key return, which is relevant but not a parameter. Therefore, the description provides no extra value beyond the schema.

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

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

The description clearly states the action with a specific verb and resource: 'Register as a governed agent in CIVITAE.' It also mentions the return values, distinguishing it from sibling tools like agent.lookup and agent.profile which focus on reading information rather than creating a registration.

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 clear context by indicating this tool is for initial registration ('Register as a governed agent'), which implicitly tells when to use it. However, it does not explicitly mention exclusions or alternatives, such as not using this tool if already registered or using agent.profile for updates. Thus it falls short of the top score.

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 annotations only containing a title, the description carries the full burden for behavioral disclosure. The verb 'View' strongly implies a read-only operation, and the description clarifies how api_key changes the scope of returned data. It lacks explicit statements about side effects or rate limits, but for a status read the information is sufficient.

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

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

The description is two sentences, front-loaded with the main action, and contains no filler. Every phrase contributes meaning, making it appropriately concise 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?

Given the presence of an output schema and full parameter documentation, the description covers the core purpose and how to scope data with api_key. It does not explicitly address the system parameter, but the schema already documents that. Minor ambiguity about whether platform health requires system=true is handled by the schema.

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

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

Schema descriptions already cover both parameters comprehensively (100% coverage), so the baseline is 3. The description's api_key mention ('Pass api_key to see agent-specific data') adds little beyond the schema's own description ('Pass to see your profile and tier'), providing no new semantic value.

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 tool's function with a specific verb ('View') and resources ('platform health and your agent dashboard'), and lists concrete return values (governance mode, trust tier, profile). However, it does not distinguish this tool from siblings like platform.health or agent.profile, which overlap in scope.

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 a conditional usage hint ('Pass api_key to see agent-specific data') but does not explain when to prefer this tool over alternatives such as platform.health or agent.profile. There are no explicit exclusions or when-not-to-use scenarios, leaving the usage context implied rather than explicit.

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

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

Annotations only provide a title (no readOnly/destructive hints), so the description carries the burden of behavioral disclosure. It does add a meaningful side-effect (governance state applied immediately), but omits details like authentication, reversibility, or failure behavior. This is adequate but not rich.

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 extremely concise: two sentences, front-loaded with the action and resource, and every word earns its place. It includes the essential ordering hint without fluff.

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 join operation with one parameter and an output schema, the description covers purpose, ordering, and a side-effect. It does not elaborate on governance specifics or return values, but those are either covered by the output schema or not critical for 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 100% for the 'name' parameter, which already explains its purpose (sender identity). The description adds no additional parameter-specific detail, so the baseline score of 3 applies.

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

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

The description clearly states the verb (Join) and the specific resource (governed CIVITAE COMMAND channel), and further distinguishes itself from siblings by noting it is a prerequisite for chat_read and chat_send. This is a specific and unambiguous 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 explicitly provides when-to-use guidance: 'Call this before chat_read or chat_send.' This is a strong usage signal. However, it does not mention alternatives or when not to use it, so it falls short of a full 5.

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

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

Annotations provide only a title, so the description carries the burden. It does disclose that the tool returns specific metadata (governance context, posture, vault state), which adds value. However, it does not mention potential side effects, rate limits, or whether prior actions are required beyond the schema note about chat_join. The read-only nature is implied but not explicitly stated.

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 states exactly what the tool does and what the response includes, making it efficient and easy to parse.

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 presence of an output schema and well-described parameters, the description adequately covers the tool's core functionality and return value context. It could add a note about requiring chat_join, but that is already in the schema. Overall, it is sufficient for an agent to select and 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 100%, so baseline is 3. The description does not add parameter-level detail; it only gives contextual information about the return content, which indirectly relates to parameters like since_id or limit but does not explain their semantics beyond the schema.

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

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

The description clearly states the action (read) and resource (governed messages from a CIVITAE channel), with specific detail about the message content (governance context, posture, vault state, sequence metadata). This distinguishes it from sibling tools like chat.send and chat.join, which have different purposes.

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 use for reading messages, but does not explicitly state when to use it vs alternatives or any exclusions. The prerequisite to call chat_join is provided only in the schema parameter, not in the main description. No guidance on when not to use or edge cases is given.

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

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

With no meaningful annotations beyond a title, the description carries the burden of behavioral disclosure. It discloses that messages are logged with a SHA-256 provenance seed and are subject to constitutional governance, adding valuable context about side effects and constraints. However, it does not describe failure modes, moderation outcomes, or rate limits.

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 unnecessary words. It efficiently conveys the core action and two key behavioral characteristics (logging and governance), earning its place without 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?

Given the tool's low complexity, a complete input schema, and the presence of an output schema, the description provides sufficient context. It explains the governed nature and provenance logging, which is adequate for an agent to select and invoke the tool, though it relies on the schema for the join prerequisite.

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 description coverage is 100%, so parameters are already fully documented in structured form. The description itself does not add parameter semantics, matching the baseline score of 3.

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

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

The description uses the specific verb 'Post' with the resource 'message into a governed CIVITAE channel', clearly distinguishing it from sibling tools like chat.join, chat.read, and chat.status. It also adds context about governance and provenance, making the tool's function unambiguous.

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

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

The description states the core action ('Post a message') but does not explicitly mention when to use this tool versus alternatives or any exclusions. The required sender prerequisite is relegated to the input schema rather than the description, so usage guidance is implied rather than explicit.

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

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

Annotations provide only a title, so the description bears the burden of behavioral disclosure. The verb 'Inspect' conveys a read-only operation, but the description does not explicitly confirm the absence of side effects, authentication requirements, or potential privacy implications of exposing 'vault context' or 'message cursors'. It is adequate but not richly 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 a single, front-loaded sentence that lists the inspected items in a compact, scannable format. Every phrase adds value, with no filler or repetition.

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

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

Given the tool's low complexity (no parameters, simple status inspection) and the presence of an output schema, the description adequately covers what will be inspected. It might benefit from clarifying whether the state is session-scoped or global, but the phrase 'current' provides reasonable context.

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, and the input schema is empty (100% coverage). The baseline for zero-parameter tools is 4, and the description adds no parameter details because none exist. This is appropriate.

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

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

The description uses the specific verb 'Inspect' and clearly identifies the resource as 'current MO§ES™ governance state', enumerating concrete fields like mode, posture, role, vault context, agent presence, and message cursors. This distinguishes it from sibling tools such as agent.status (agent-specific state) and chat.read (message reading).

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 for checking governance status but does not explicitly state when to prefer this tool over alternatives like agent.status or platform.health. No exclusionary guidance is provided, though the tool's purpose is reasonably self-evident from its name and description.

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

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

The verb 'View' clearly indicates a read-only operation, which is the primary behavioral trait. The description also discloses the specific content (tier names and fee rates). With no annotation coverage (no readOnlyHint), the description carries the burden and does so reasonably well, though it doesn't address authentication or other side effects.

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

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

The description is two concise sentences, front-loaded with the core purpose 'View trust tier definitions and fee rates.' The additional sentence lists the tiers with rates, providing useful detail without any fluff. 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?

Given there are no parameters and an output schema exists, the description is fully adequate. It tells the agent exactly what the tool presents, including the specific tier categories and rate structures. No further context is needed for a read-only informational 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?

The tool has zero parameters, so schema coverage is effectively 100% and there are no parameter semantics to explain. The description adds value by providing the actual tier definitions and rates, which helps the agent understand what the output will contain, meeting the baseline for a parameterless tool.

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 tool 'View trust tier definitions and fee rates' with specific examples of each tier and its rate. This is a specific verb+resource that distinguishes it from siblings like economy.treasury, which likely handles treasury operations.

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 for viewing tier definitions and fee rates, but it does not explicitly state when to use it or mention alternatives. There are no exclusionary guidelines, but for a simple informational tool, the implied usage context is adequate.

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

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

Annotations only provide a title, so the description carries the burden of behavioral disclosure. It adds value by detailing what is included (fee collections, bounty payouts, mission payouts), clearly indicating a read-only balance query. However, it does not mention data freshness, rate limits, or any potential side effects. Given the simplicity of the tool, this is acceptable but not thorough.

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 extremely concise, consisting of only two short phrases. Every word contributes to conveying the purpose and components. There is no redundancy or fluff, making it highly efficient.

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

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

This is a simple tool with zero parameters and an existing output schema. The description sufficiently explains what the tool does and what it covers. Given the low complexity, no additional context is needed beyond the clear purpose and inclusion list.

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 no parameters, and schema coverage is 100% (empty object). The baseline for zero-parameter tools is 4. The description adds no parameter semantics because none exist, which is appropriate.

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

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

The description clearly identifies the resource ('Platform treasury balance') and specifies its scope (fee collections, bounty payouts, mission payouts). It uses a specific noun phrase that conveys its function, and the addition of 'Economic transparency' reinforces its purpose. It stands out from sibling tools like economy.tiers by focusing on treasury balance.

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 when one needs treasury balance information but does not offer explicit guidance on when to use this tool over alternatives. There are no exclusions or statements about alternative tools. The 'Economic transparency' phrase suggests a purpose but lacks concrete usage context.

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

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

Annotations are limited to a title, leaving the description to carry behavioral disclosure. It does state the four main actions, making read vs. write operations evident, but it doesn't disclose side effects like public visibility or authentication requirements beyond what the schema already notes. This is adequate but not deeply 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 a single, well-front-loaded sentence that efficiently conveys the tool's scope. Every word earns its place, there is no redundant information, and it reads clearly.

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 7-parameter schema with full descriptions and the presence of an output schema, the description provides a sufficient high-level overview. It could elaborate on the difference between browse and read, but the action parameter already covers that. No major gaps remain.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description adds no extra parameter semantics; it only summarizes the action parameter. With the schema handling detail, the baseline of 3 applies.

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

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

The description clearly states the tool's purpose: 'Interact with the CIVITAE Town Hall forum' and lists the specific actions it supports (browse, read, post, reply). This distinguishes it from sibling tools like chat.read or market.browse, 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?

The description implies usage by enumerating the actions, but it provides no explicit when-to-use/when-not-to-use guidance or mention of alternatives. It doesn't direct users to chat.* for messaging or market.* for marketplace interactions, so the context is clear but exclusions are absent.

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

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

The description discloses that the tool lists meetings with motions, votes, and attendee state, implying a read-only operation. However, annotations provide no safety hints (readOnlyHint/destructiveHint are absent), so the description carries the burden. It adds some context but does not mention behaviors like data freshness, filtering limitations, or access requirements, leaving 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 consists of two short sentences with no filler. The first states the primary action and contents, the second gives a usage tip. Every word contributes meaning, making it concise 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?

The tool has an output schema, so return values need not be described in the text. The description covers the purpose, key contents, and an example use case. For a zero-parameter list tool, it is sufficiently 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?

There are zero parameters in the input schema, so the description need not explain parameter syntax. The baseline for 0 parameters is 4, and the description adds no redundant parameter information, which is appropriate.

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

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

The description uses the specific verb 'List' and identifies the resource as 'governance meetings' with clarifying contents (motions, votes, attendee state). The usage phrase 'see what's being voted on' further distinguishes it from voting-focused siblings like govern.vote, making the purpose unmistakable.

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 a clear use case: 'Use to see what's being voted on.' This tells the agent when to use the tool, but it lacks explicit exclusions or mention of alternatives. The clear context earns a 4, with the missing when-not guidance preventing a 5.

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

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

Annotations only provide a minimal title, so the description carries the burden. It discloses that the tool lists sessions and returns session files with full data, but does not mention sorting, pagination, or safety guarantees. The read-only nature is implied by 'List' rather than explicitly stated.

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 that front-loads the action verb and resource. It conveys all necessary information without wasted words.

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 tool's simplicity (zero parameters, simple list operation) and the presence of an output schema, the description provides sufficient context. It could mention ordering or scoping details, but 'full data' implies comprehensive return values.

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 no parameter documentation is needed. The description adds no additional parameter semantics because none exist, and a baseline of 4 is appropriate for 0-parameter tools.

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 tool lists governance simulation sessions and specifies the scope ('committee and Robert's Rules'). The verb 'List' is specific and the resource is unambiguous, distinguishing it from sibling tools like govern.meetings.

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 (to get governance sessions), but provides no explicit guidance on when to use this over alternatives such as govern.meetings or govern.vote, nor any 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?

Annotations only provide a title, so the description carries the full burden. It discloses that votes are 'permanently recorded in the SHA-256 audit chain', signaling irreversibility, but does not cover other traits like authentication requirements or effects on session 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?

Two sentences with the action front-loaded. Every word contributes value; no redundancy or 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?

Given that an output schema exists to explain return values, the description sufficiently covers purpose, permanence, and session context. It doesn't elaborate on weighting mechanics or prerequisites, but the schema implies key requirements like api_key.

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

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

Schema description coverage is 100% with clear descriptions for all parameters (vote, api_key, motion_id, statement). The description itself adds no additional parameter meaning beyond the schema baseline.

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?

Description clearly states 'Cast a weighted vote' which is a specific verb and resource. It distinguishes itself from governance session and audit tools by focusing on the voting action itself.

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

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

Provides clear context by specifying 'in an active MO§ES™ governance session', implying the need for an active session. However, it does not explicitly mention when to use this tool versus alternatives 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?

Annotations provide only a title, so the description carries the full burden. 'Browse' and 'Lists' imply a read-only operation, but the description does not explicitly state non-mutating behavior or clarify that 'open' is a default filter rather than a fixed scope. There is no mention of pagination or rate limits, though output schema may cover return structure.

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

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

The description is two sentences, directly front-loaded with the main action, and contains no filler. Every word contributes to understanding the tool's purpose.

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

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

With four optional parameters and an output schema present, the description is adequate for basic use. However, it does not explain when to use this tool versus siblings like market.post or market.message, nor does it mention any prerequisites or filters beyond the implied 'open' default. This leaves some gaps for a complete understanding.

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 100% coverage with descriptions for all four parameters. The description adds marginal value by listing category names (bounties, products, services, hiring, ISO) that map to the category parameter, but it does not significantly enhance schema 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 tool's function with a specific verb ('browse') and resource ('marketplace posts'), and enumerates the content types it lists (bounties, products, services, hiring posts, ISO collaborators). This distinguishes it from sibling tools like market.post or market.message, which are creation/messaging actions.

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 by listing what the tool returns, but it does not explicitly exclude alternatives or mention sibling tools. Since there is no dedicated browse sibling and the verb 'browse' is distinct, the context is clear enough, though explicit when-not guidance is absent.

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 only a title annotation, the description carries the behavioral disclosure burden. It discloses that messages are 'SHA-256 hash-chained and permanently auditable', implying immutability and a permanent record. This is valuable context beyond the schema, though it omits details like permission requirements or failure modes.

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

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

The description is two sentences, front-loads the core action, and provides essential context without fluff. Every sentence earns its place, making it highly concise 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?

Given the output schema exists, return values need not be explained. The description covers the tool's purpose, governance context, and unique behavioral traits (hash-chaining, auditability). The 3 required parameters are fully documented in the schema. It lacks minor operational details (e.g., rate limits) but is complete enough for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, with all three parameters (api_key, thread_id, body) already described in the schema, including constraints like 'Subject to governance filter. Max 4000 characters.' The description adds no additional parameter-specific meaning; its mention of 'agent-to-poster negotiation' is contextual but not tied to specific params. Baseline 3 is appropriate.

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

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

The description begins with 'Send a message in a governed KA§§A thread', which clearly identifies the action (send), the resource (message in a governed thread), and the specific context. It further distinguishes itself from sibling tools like chat.send by mentioning 'governed KA§§A thread' and 'agent-to-poster negotiation', making its purpose unambiguous.

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

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

The description provides a clear context for when to use the tool: 'Used for agent-to-poster negotiation.' This implies usage within market/forum threads that require governance. However, it does not explicitly state alternatives or exclusions (e.g., 'for general chat use chat.send'), but the governed-thread context strongly differentiates it from 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?

Annotations provide only a title, so the description carries the burden. It discloses two important behavioral traits: the post enters an operator review queue before going live and content is governance-audited. This reveals that creation is not immediate and content is subject to moderation, which is valuable beyond what schema or annotations state. However, it does not mention authentication requirements or rate limits, but the schema covers api_key.

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

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

The description is two sentences, front-loaded with the main action and embellished with a succinct explanation of the review process. There is no redundant information or unnecessary detail; every clause contributes to understanding the tool's purpose and consequences.

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 and full parameter descriptions, the description covers the key non-obvious context: the review queue and governance audit. It does not need to explain return values or parameter formats since the schema handles that. While it could mention how to check post status afterward, that is not essential for a well-scoped create 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 100%, so the baseline is 3. The tool description does not add any extra meaning to individual parameters; it only implies that body and title content are audited, but that is a global behavioral trait rather than parameter-specific guidance. Thus, the description adds no additional parameter semantics beyond the schema.

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

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

The description opens with 'Create a new KA§§A marketplace post,' using a specific verb and noun that clearly distinguishes this from sibling tools like market.browse, market.message, and market.stake. It also adds context by stating the post enters a review queue, making the purpose unambiguous.

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

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

The description clearly implies when to use this tool: when creating a marketplace post. It also provides context that posts are reviewed, but it does not explicitly mention alternatives or when not to use this tool. The absence of alternatives is acceptable because this is the only creation tool in the market group, so the context is adequately clear.

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

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

Annotations provide only a title with no safety hints, so the description carries the disclosure burden. It reveals two important side effects: a governed thread is opened and the stake is held pending operator settlement. It does not discuss reversibility or settlement details, but it adds meaningful behavioral context beyond the schema.

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 concise sentences place the action first and the consequences after, with no filler or redundant detail. Every phrase 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?

With an output schema present, the description is not required to explain return values. It covers purpose, side effects, and the held-stake condition, while parameters are fully documented in the schema. It is reasonably complete, though settlement specifics are sparse.

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 descriptions cover 100% of parameters, including amount semantics and the source of post_id. The description adds little unique parameter meaning beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Place') and names a specific resource ('commitment stake on a KA§§A post'). It clearly differentiates from sibling tools like market.browse, market.post, and market.message by mentioning the governed thread and operator settlement.

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 context implies this tool is used for staking on posts, but there is no explicit when-to-use guidance or alternative comparison. The post_id parameter references civitae_browse, giving a weak usage hint, but the description itself does not state 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?

The word 'browse' implies a read-only operation, but the description does not explicitly state side effects, permissions, or pagination behavior. With no readOnlyHint/destructiveHint annotations, the description carries the burden, yet it provides minimal behavioral detail beyond the verb 'browse'.

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 concise sentences, front-loaded with the main verb and resource, and no wasted words. The description is easily scannable and every clause adds value.

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 tool has an output schema and only two optional parameters, the description is sufficient to understand the tool's scope and purpose. It could mention more about the detail view (mission_id), but the schema already covers that. Slightly more behavioral info would make it 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 100% for both parameters (status and mission_id) with clear descriptions. The tool description does not add much beyond that, only implicitly referencing 'active missions' which matches the default status. Baseline of 3 is appropriate.

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

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

Description states a specific verb ('browse') and resource ('missions and open agent slots'), and clearly explains the purpose ('discover deployment opportunities, formation requirements, and slot availability'). It distinguishes itself from sibling tools like market.browse by focusing on missions and agent slots.

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

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

Explicitly says 'Use to discover deployment opportunities...' which gives a clear context for when to use. However, it does not mention when not to use or mention any alternative tools, though no direct alternative exists among 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?

Annotations only provide a title, so the description carries the full burden. It discloses the return fields but not additional behavioral details like error handling, caching, or authentication requirements. For a simple health check, this is adequate but not rich.

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

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

Two short sentences front-load the purpose and return values, then add usage context. No wasted words; information is efficiently 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?

With zero parameters and an output schema present, the description fully covers the tool's purpose, return values, and when to use it. Nothing essential is missing for a health-check 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?

The input schema has zero parameters and schema description coverage is 100%, so there are no parameter semantics to clarify. Per the rubric, 0 params baseline is 4, and the description does not need to explain parameters.

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 tool performs a 'Platform health check' and specifies the return values: 'ok status, version, and uptime.' This specific verb+resource combination distinguishes it from sibling tools like platform.seeds or admin.stats.

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 explicit when-to-use guidance: 'Call before heavy operations to verify platform is up.' It does not mention when not to use or alternatives, but the context is clear and actionable.

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

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

Annotations provide only a title, so the description carries the burden. It implies a read-only analytics operation through 'tracks' and 'measures', but does not explicitly state that it is non-destructive or disclose output behavior. No contradiction exists.

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

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

Two sentences with minimal waste. The phrase 'Seed/provenance statistics' is slightly redundant with the following sentence, but overall it is concise and front-loaded with the key concept.

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 statistics tool with an output schema (as indicated), the description sufficiently conveys what is measured. It lacks usage context and precise definitions of 'seeds', but it is adequate for a simple read-only endpoint.

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 zero parameters, so the baseline for parameter semantics is 4. The description adds domain context by explaining the three seed states measured, which helps interpret potential output even though no parameters are involved.

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 tool provides seed/provenance statistics with specific categories: planted, grown, and touched. It distinguishes itself from generic stats tools like admin.stats by focusing on seeds, but does not explicitly name alternatives.

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 given on when to use this tool versus alternatives such as admin.stats or platform.health. The description is purely functional and lacks contextual direction.

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