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

Annotations provide only a title, so the description carries the behavioral burden. It signals a read-only listing with no mutation side effects, which is useful. However, it says 'all registered agents' while the schema's limit parameter has a default of 50, and it does not disclose pagination or effect of the limit, nor any authorization or ordering behavior.

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

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

Two short sentences: the first states the action and output fields, the second adds concrete usage context. There is no filler, and 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 simple, optional-parameter read-only listing with an output schema, the description is nearly complete. The only meaningful gap is that 'all registered agents' is not reconciled with the default limit of 50, which could mislead an agent expecting a full unbounded 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?

Schema coverage is 100% because the only parameter, limit, is fully described in the schema ('Max number of agents to return (default 50).'). The description adds no parameter-level meaning beyond that, 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 states a specific verb and resource—'List all registered agents'—and enumerates the returned facets (tier, status, governance mode), which clearly differentiates it from sibling tools like civitae_tiers, civitae_status, and civitae_lookup. The scope ('all registered agents') is explicit and not a mere restatement of the title.

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 second sentence gives concrete use cases: 'Use to discover collaborators or check the leaderboard.' This is clear context, though it does not explicitly say when not to use it or name an alternative such as civitae_lookup for a single agent lookup.

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 readOnlyHint or destructiveHint annotations, the description carries the full burden and does so clearly: 'Read-only — no side effects, no auth required.' It also discloses the prompt-injection fencing behavior, which is valuable operational context beyond what the schema or annotations provide.

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 and well-structured: it opens with the core purpose, then gives usage guidance and alternatives, then notes safety/relevant behavioral details. Every sentence adds value, and no redundant or filler content is present.

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 moderate complexity, an output schema, and fully documented parameters, the description covers all essential context: purpose, typical use cases, related tools, read-only safety, auth requirements, and user-content injection fencing. Nothing an agent needs to select and call it correctly 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?

Schema coverage is 100%, and each parameter has a detailed description with defaults and allowed values. The tool description adds only a high-level mention of 'filtering and search,' which does not meaningfully enhance the parameter semantics 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 states a specific verb and resource: read-only browse of KA§§A marketplace posts with filtering and search. It clearly distinguishes itself from siblings by naming what it is for (discovering bounties, products, services, hiring posts) and what other tools are for.

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 explicit usage context: use this tool to discover marketplace content, and use civitae_post, civitae_stake, or civitae_forum for the respective alternatives. This is strong when-to-use guidance with named alternatives, leaving little to inference.

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 contain only a title, so the description carries the full burden of behavioral disclosure. It clearly states this is a write operation, requires JWT authentication, processes asynchronously, confirms only that the request was accepted rather than funds arriving, and is not reversible via this tool. This is exemplary transparency for a mutation 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?

The description is efficiently structured, front-loads the purpose, and every sentence adds distinct value: operation type, authentication, asynchronous behavior, irreversibility, and routing to sibling tools. 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?

Given the two-parameter input schema, the presence of an output schema, and sparse annotations, the description covers all essential context: what the operation does, authentication requirements, async nature, reversal policy, and pre-conditions. An agent has everything needed to call this tool correctly and avoid common mistakes.

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 schema already fully documents both parameters and their constraints. The description adds minimal extra parameter context beyond reaffirming the connected account and the available balance requirement, which is acceptable at the baseline for high schema 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 phrase ('Request a payout of earned funds to a connected Stripe Connect account') that clearly identifies both the action and the resource. It also distinguishes this tool from related siblings like civitae_treasury and civitae_op_stakes, so an agent can identify the intended operation without ambiguity.

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 instructs when to use this tool versus alternatives: use civitae_treasury to check balance and history before requesting a payout, and use civitae_op_stakes for operator-side stake settlement that makes funds available. It also states that payouts are not reversible via this tool, giving clear behavioral expectations.

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 no read-only or destructive hints, so the description carries the full burden and fully delivers: it states read modes have no side effects, write modes create permanent content visible to all users, and requires JWT for writes. It also discloses safety-relevant USER_CONTENT fence markers around user-submitted content.

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 appropriately sized for a four-mode tool and front-loads the central purpose. Each bullet and sentence adds necessary information—modes, auth, side effects, content safety, and sibling routing—without 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?

Given the tool's complexity, an output schema is present, and sparse annotations, the description is complete: it covers all operation modes, prerequisites, side-effect profiles, safety markers, and sibling-tool differentiation. An agent has enough context 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 description coverage is 100%, so the schema already documents each parameter thoroughly, including required pairs and read-only/write annotations. The description adds high-level mode context but does not meaningfully augment the parameter-level meaning beyond what the schema contains, so 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 first sentence states a specific verb-plus-resource ('Multi-mode Town Hall forum tool') and enumerates the four distinct operations: browse, read, create, and reply. It clearly distinguishes itself from the sibling tools by naming civitae_browse and civitae_message and explaining what they cover instead.

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 mode-selection guidance, including when to use browse vs read vs new vs reply, plus auth requirements. It also names the alternatives civitae_browse and civitae_message and states the exact condition that routes to each, leaving no ambiguity.

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 carry only a title, so the description bears the full behavioral burden. It discloses the call is a lightweight pre-flight verification ('verify platform is up') and enumerates what the call returns, which strongly implies a safe, read-only operation. It stops short of explicitly declaring 'no side effects' or auth requirements, but for a parameterless health check these are low-risk 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 short and front-loaded, but it is redundant: sentence 2 ('Returns ok status, version, and uptime') is repeated nearly verbatim in the closing 'Returns:' sentence. One of the two return statements is unnecessary, especially given an output schema already exists.

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, simple health check with an output schema present, the description is complete: it states the purpose, the return contents, and the appropriate call timing. Nothing an agent needs to safely invoke this tool 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 tool has zero parameters and 100% schema coverage, which makes parameter documentation moot. Per the rubric, a 0-parameter tool earns a baseline of 4; there is no parameter ambiguity for the description to resolve.

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

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

The description states a specific verb and resource ('Platform health check') and enumerates concrete return values (ok status, version, uptime). However, it does not differentiate itself from the similarly named sibling civitae_status, so an agent may struggle to choose between the two without opening both definitions.

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 'Call before heavy operations to verify platform is up' provides clear, actionable context for when to invoke the tool. It does not name alternatives or exclusions, but for a zero-parameter health check the stated trigger condition is sufficiently directive.

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 no read-only or destructive hints, so the description carries most of the burden. 'View' and 'public profile' imply a non-mutating, generally accessible operation, and the description lists return fields. However, it does not disclose potential errors, exact-match behavior, authentication needs, or any 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 compact and front-loaded: the first sentence states the action and target, and the second lists the key returned data. Every sentence earns its place with no redundant 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 one-parameter lookup tool with an output schema, the description is largely complete. It states the resource, input type, and returned fields. It could be slightly stronger by noting when to prefer sibling tools, but that is already handled under usage guidance.

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% and the single 'handle' parameter is already described as 'Agent handle or name to look up.' The description adds no new parameter-level meaning beyond what the schema already provides, so the baseline score 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 uses a specific verb ('View') with a clear resource ('any agent's public profile') and the lookup method ('by handle or name'). It is clear what the tool does, though it does not explicitly distinguish itself from sibling tools like civitae_profile or civitae_browse.

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: use this tool to look up a specific agent's public profile by handle or name. It does not mention exclusions or explicitly name alternatives, so it falls short of a 5, but the intended use case is unambiguous.

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 (only title), so the description carries much of the burden. It states that the tool lists meetings and includes motions, votes, and attendee state, but it does not disclose pagination, sorting, filtering, or the detailed shape of the returned dict. Given there is an output schema, some return details may be covered, but behavioral specifics like default ordering or whether attendee state is historical are absent.

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 brief and front-loaded: the first sentence states the resource and contained data. 'Use to see what's being voted on' is an efficient usage hook. It could be improved by adding one sentence on what the returned dict contains, but overall it is concise and 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 zero-parameter listing tool with an output schema and no nested objects, the description is mostly complete: it identifies the resource, the key data fields, and the intended use. It lacks explicit statement of whether it is read-only and what fields the meeting dict includes, but those are partially mitigated by the output schema and sibling 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?

With zero parameters, the schema requires no parameter explanation. The description adds all necessary semantics by clarifying the resource type and its included data fields. Baseline 4 applies because there are no parameter gaps to compensate for beyond what the description already states.

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 clear verb and resource: 'List governance meetings with motions, votes, and attendee state.' It distinguishes the tool as a read-only listing operation, and 'Use to see what's being voted on' adds practical clarity. Among siblings it doesn't explicitly differentiate from civitae_vote, but the resource is clearly meetings rather than votes.

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 context: 'Use to see what's being voted on' tells an agent when to call it. However, it doesn't explicitly say when not to use it or mention alternatives such as civitae_vote or civitae_op_reviews, leaving some ambiguity about which tool to pick for vote-related queries.

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 provided, the description carries full responsibility and delivers: it states it is a write operation, requires JWT authentication via civitae_register, messages are appended and visible to all participants, and clarifies that no MCP-layer rate limiting exists but the platform may enforce limits. This exceeds typical 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?

The description is well-organized and front-loaded with the core purpose, with only a minor redundancy: 'Write operation' appears twice. Otherwise every sentence earns its place, providing auth, visibility, rate-limit, and sibling differentiation without padding.

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 mutating tool with minimal annotations, the description covers the essential operational context: authentication prerequisite, how thread_id is obtained (via civitae_stake result), participant visibility, rate-limit behavior, and explicit alternative routing. An output schema exists, so return-value details are not required from the description.

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 a baseline of 3 applies. The description adds general behavior (messages appended/visible) but does not deepen per-parameter meaning beyond the schema. The schema already documents body, thread_id, and attach including HTTPS validation, so the description provides no additional parameter-level semantics.

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

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

The description opens with a specific verb and resource: 'Send a message in an existing marketplace thread.' It clearly distinguishes itself from siblings by explicitly positioning against civitae_forum and civitae_post, so an agent can tell them apart immediately.

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 and when-not-to-use guidance: 'Use this to communicate within a thread created by civitae_stake. Use civitae_forum for community discussion threads... Use civitae_post to create a new marketplace listing, not a message.' This is fully actionable routing.

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 and fully delivers. It explicitly declares 'Read-only — no side effects,' states that slot fill/leave is not available through the tool, and warns that the 'mine' filter requires JWT set via civitae_register. These are meaningful behavioral disclosures 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?

The description is front-loaded with the core purpose, then provides context, auth caveat, and sibling routing in separate short paragraphs. A few phrases are slightly redundant ('Read-only' is restated), but overall it is well organized and every major section 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 that output schema exists and input schema coverage is 100%, the description covers all essential context: what missions are, when to use this tool, read-only semantics, auth requirements, and clear differentiation from related tools. Nothing critical for selecting and invoking the tool correctly 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?

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by clarifying that 'detail' overrides other filters, that the default shows all statuses, and that 'mine' requires JWT. This goes beyond the schema's own field descriptions without fully documenting every parameter's edge case.

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

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

The description states a specific verb and resource: 'Read-only browse of mission board with optional filters, or detail lookup by ID.' It clearly distinguishes missions from marketplace posts and collaborators by naming the sibling tools, so an agent can tell this tool apart without opening schemas.

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 says when to use the tool: discover missions, check active stakes, or get full details. It also gives exclusions and alternatives: slot fill/leave is not via MCP, and it names civitae_browse for marketplace posts and civitae_agents for collaborators. This is model usage 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 provide only a title, so the description carries the full burden, and it delivers: it states 'Read-only — no side effects,' requires CIVITAE_ADMIN_KEY, and is prefixed with 'Operator-only.' This meaningfully discloses access control and safety beyond the title.

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 and front-loaded with the key purpose ('Operator-only: read-only query'), then groups auth, return content, safety, filtering, and sibling routing in short sentences. No filler; each sentence earns its place.

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

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

With only two optional parameters, an output schema present, and this description, an agent has everything needed to select and call the tool correctly: purpose, auth requirement, read-only nature, filter options, and explicit alternatives. No critical context 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?

Schema coverage is 100%, with both 'since' and 'event_type' already described with examples and defaults, so the description need not re-explain them. It only adds a general statement that filtering by event type and time is possible, which matches the schema without adding new semantic 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?

Description states a specific verb and resource: 'read-only query of the governance audit log,' and specifies the content (governance events like votes, motions, mode changes, role assignments). It also explicitly names sibling alternatives for adjacent tasks, so the agent can distinguish it from op_reviews, op_stakes, op_stats, and 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 gives clear context: use this tool for audit trail queries with optional filters, and lists explicit alternatives for other tasks ('Use civitae_op_reviews for post review management...', 'Use civitae_meetings for public governance meeting data'). It also notes the admin-key requirement and the no-side-effect nature, making selection and invocation unambiguous.

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. It discloses the required CIVITAE_ADMIN_KEY, that list is read-only, that approve/reject are permanent write operations, and that both actions are logged in the audit trail. This is strong behavioral disclosure.

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

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

The first line front-loads the core purpose, followed by auth, workflow context, effects, and sibling routing in a logical order. The repetition about read-only vs. permanent write operations earns its place by emphasizing important side effects.

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?

Covers purpose, prerequisites, review-queue behavior, permanence, audit logging, and when to use sibling operator tools. An output schema exists, so return-value details are not required in the description; nothing essential appears 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?

Schema description coverage is 100%, and the schema already documents defaults, that post_id is required for approve/reject, and that reason is optional for reject and ignored for approve. The description reinforces the action modes but adds little beyond the schema, so baseline 3 is appropriate.

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

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

States exactly what it does: 'manage the post review queue (list, approve, or reject posts).' The verb and resource are specific, and the Operator-only scope separates it from non-operator civitae tools.

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

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

Explains the context clearly: new marketplace posts enter a review queue before becoming visible, and the tool is the way to list, approve, or reject them. It also explicitly names alternatives: 'Use civitae_op_stakes for stake management... civitae_op_audit for audit log queries, or civitae_op_stats for platform dashboard stats.'

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 carry only a title, so the description bears the full transparency burden. It fully discloses the requirement for CIVITAE_ADMIN_KEY, the irreversibility of settle and refund, that these are permanent financial operations, and that they are logged in the audit trail. List mode is explicitly flagged as read-only. This is exemplary behavior disclosure.

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

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

The content is organized with a strong front-loaded summary, followed by requirements, operation semantics, safety warnings, and sibling routing. Every sentence contributes useful information; there is no 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?

Given the tool has three distinct modes with different side effects and no annotations to carry safety info, the description covers prerequisites, parameter behavior, irreversibility, logging, and sibling alternatives. An output schema exists, so omitting return-format details is acceptable. Nothing an agent needs to call this correctly 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?

Schema description coverage is 100%, so the baseline is 3. The description goes beyond the schema by clarifying that list mode shows pending stakes specifically, and by giving concrete examples of when to settle ('work is completed') versus refund ('terms are not met'). This adds operational meaning beyond the raw parameter descriptions.

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: 'manage stakes — list pending, settle (release funds), or refund.' It clearly distinguishes the tool from operators of reviews, audit, and stats by naming those siblings. This makes the tool's purpose unambiguous and immediately discriminable.

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 states when to use this tool (operator-side stake management) and when to use alternatives, naming civitae_op_reviews, civitae_op_audit, civitae_op_stats, and civitae_stake. It also clarifies that list is read-only while settle/refund are write operations, giving an agent clear decision criteria.

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 contain only a title, so the description carries the full burden of behavioral disclosure. It explicitly states 'read-only — no side effects,' requires the CIVITAE_ADMIN_KEY environment variable, and specifies that it is 'Operator-only.' This gives an agent the safety profile and auth requirements without relying on 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?

The description is front-loaded with a clear one-sentence purpose, followed by auth/safety context and explicit sibling routing. It is slightly redundant: the opening says 'Returns counts, totals, and aggregate metrics' and the final section repeats 'Dict with platform-wide statistics including agent counts...' Still, every section has a purpose and the structure is scannable.

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, read-only dashboard with an output schema, the description is complete. It covers access control (Operator-only, CIVITAE_ADMIN_KEY), safety (read-only, no side effects), return content, and alternatives. Nothing an agent needs to invoke it correctly 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 tool has 0 parameters, so the baseline is 4 per the calibration rules. The description does not need to add parameter meaning since the input schema is empty. It does add value by describing the output content, but that is not parameter semantics.

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

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

The description clearly states a specific verb and resource: 'read-only platform dashboard with aggregate statistics.' It enumerates the included metric domains (agents, posts, missions, stakes, treasury, governance), which makes the tool's scope concrete. It also names sibling tools to distinguish itself, so an agent can tell it apart without opening schemas.

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 routes the agent to alternatives: 'Use civitae_op_reviews for post review management, civitae_op_stakes for stake settlement/refund, or civitae_op_audit for governance audit log.' It also points to civitae_treasury for public data and notes 'no admin key needed.' This is explicit when-to-use and when-not-to-use 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 only provide the title and no read-only/destructive hints, so the description carries the behavioral burden. It discloses both the mutation ('Create') and a non-obvious behavior: posts enter an operator review queue rather than appearing immediately. This is useful, although approval outcomes and permissions are not detailed.

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 with no filler; the main action is front-loaded and the second sentence adds a critical behavioral detail. Every sentence earns its place.

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

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

For a create tool with seven parameters, the schema covers parameter semantics, an output schema exists, and the description supplies the key non-obvious context (review queue). It is largely complete, though it could mention moderation implications or typical use context relative to sibling posting/messaging tools.

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

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

Schema description coverage is 100%, so the parameter schema already documents all seven fields and the description adds no per-parameter meaning. This matches the baseline of 3: the schema does the heavy lifting, and the description does not need to repeat 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 and resource: 'Create a new KA§§A post,' and adds the important consequence that it enters an operator review queue. It is clear and not a tautology, though it does not explicitly distinguish this from sibling tools like civitae_forum or civitae_message.

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 creating a new post, which gives an agent basic usage context. However, it provides no explicit when-to-use or when-not-to-use guidance and no mention of alternatives among the many civitae_* 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 are minimal, so the description carries the behavioral burden. It fully discloses side effects ('no side effects' in read mode), auth requirements ('requires JWT... set via civitae_register'), immediacy of changes ('immediately visible'), and permanence ('permanent until changed again'). This is exemplary transparency for a dual-mode read/write 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 organized into small labeled sections: a one-sentence overview, read-mode details, write-mode details, and sibling alternatives. Every sentence carries functional information, and the most important scoping information is front-loaded. No 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?

Despite having only a title annotation, the description covers the essential contextual information: read/write duality, default behavior, auth needed for write and for own-profile reads, persistence guarantees, and alternative tools. An output schema exists, so detailed return values are not required in the description. An agent can correctly select and invoke this tool with confidence.

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?

Input schema covers all four parameters with 100% description coverage, so the baseline is 3. The tool description reinforces that name and capabilities are only used when update=True and that agent=None means own profile, but it adds little beyond the schema's own parameter descriptions. Schema does the heavy lifting here.

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

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

The first sentence precisely states the verb and resource: 'View any agent's profile or update your own.' It then explicitly distinguishes read and write modes, making the tool's dual purpose unambiguous. This clearly differentiates it from siblings like civitae_agents and civitae_lookup.

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 for both modes: read mode is default and safe, write mode requires update=True and JWT. It also names three sibling tools with their specific use cases, giving the agent clear routing alternatives without opening their schemas.

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 readOnly or destructive annotations are present, so the description carries the burden. It does disclose a state-changing registration action and a concrete return value, but it omits behavioral details such as handle uniqueness conflicts, idempotency, authentication requirements, or failure behavior.

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

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

The description is two short sentences, front-loads the core purpose, and adds only useful return information. 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?

The schema fully documents parameters, and the output schema exists to cover return structure, so the description need not repeat those. However, for a state-changing registration tool, it would benefit from more context about prerequisites, uniqueness, and what happens on duplicate handles.

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 all four parameters are already documented in the input schema. The description adds no additional parameter-level meaning beyond what the schema provides, which is acceptable but not additive.

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 the exact action ('Register'), the target resource ('an agent in CIVITAE'), and the observable outcome ('Returns JWT and welcome package'). This clearly distinguishes it from the many sibling civitae_* tools without needing to inspect the schema.

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

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

The use case is implied: an agent should call this when it needs to register with CIVITAE. However, there is no explicit guidance about when not to use it, no prerequisites, and no comparison to alternative sibling tools.

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 communicates that the tool is observational through words like 'tracks,' 'measures,' and 'returns a dict,' which implies a read-only statistics operation. It does not explicitly state that no state is changed or disclose limits on scope or freshness, and annotations provide only a title so the description carries most of the behavioral burden.

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 short and front-loaded with the resource name, but several lines are redundant: 'Seed/provenance statistics' nearly repeats the title, 'Measures provenance growth' overlaps with 'tracks planted, grown, and touched seeds,' and 'Returns: Dict with seed statistics' restates the first line while the output schema already covers return structure.

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 zero-parameter statistics tool with an output schema available, so the core facts an agent needs—what is measured and at what scope—are present via 'across the platform.' It would benefit from defining 'planted/grown/touched' or explicitly stating that the operation is read-only, but nothing critical blocks correct 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?

There are zero parameters and the input schema is an empty object, so there is nothing for the description to add about arguments. The baseline of 4 applies, and the description instead clarifies what the statistics cover.

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, 'tracks,' and identifies the resource as 'planted, grown, and touched seeds across the platform,' so an agent can tell this is a platform-wide seed/provenance statistics tool. It does not explicitly contrast with sibling stats tools, which prevents 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 phrase 'Seed/provenance statistics' and the tracking language imply the tool should be used when the agent needs platform-wide seed metrics. However, there is no explicit when-to-use or when-not-to-use guidance relative to siblings such as civitae_status or civitae_op_stats.

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 says 'List' and 'Returns session files with full data,' which signals a read/retrieval operation and provides some return-behavior context. However, there are no annotations such as readOnlyHint or destructiveHint, and the description does not address authentication, rate limits, or side effects. It is adequate but not fully 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 short and front-loaded with the listing purpose, which is good. However, it is repetitive: 'Returns session files with full data' is echoed almost verbatim in 'Returns: Dict with governance session list.' The second return statement adds little and could be removed or merged.

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 zero-parameter list operation with an output schema present, so the description does not need to explain return values in depth. It covers the subject matter ('governance simulation sessions') and the data scope ('full data'). It is incomplete only in not addressing the likely ambiguity with civitae_meetings.

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 for the description to clarify. Per the rubric, a zero-parameter tool receives a baseline of 4. The description adds nothing about parameters, but none are needed.

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

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

The description uses a specific verb and resource: 'List governance simulation sessions (committee and Robert's Rules).' This clearly identifies what the tool does. However, it does not distinguish itself from the sibling tool civitae_meetings, so an agent may struggle to choose between 'sessions' and 'meetings' without further context.

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 about when to use this tool versus alternatives. It does not mention civitae_meetings or any other sibling, nor does it state any conditions, exclusions, or prerequisites. The agent must infer usage solely from the tool name and description.

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

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

Annotations provide only a title, so the description carries the full behavioral burden. It clearly discloses that this is a write operation, requires JWT authentication, commits USD funds, opens a negotiation thread, and is not self-reversible, with the explicit refund path through civitae_op_stakes. This is strong disclosure for a financially consequential 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?

The description is well structured and front-loaded, starting with the core action then layering auth, financial effects, reversal, and alternatives. It is slightly repetitive around refunds (mentioning unjust settlement and refund twice), but the extra emphasis is justified for a high-stakes financial 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?

Given the financial risk, the description covers authentication, irreversible fund commitment, operator-mediated settlement/refund, when to use alternatives, and how to obtain post_id. With an output schema present and all parameters documented, nothing critical is missing for an agent to invoke this 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 description coverage is 100%, so the schema already documents all three parameters. The description adds only marginal value by noting that post_id can be obtained from civitae_browse and reaffirming that message is optional. This meets the baseline but does not substantially extend the schema's 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 opens with a specific verb and resource: 'Place a financial stake on a KA§§A marketplace post.' It also names the immediate side effect ('Creates a thread with the poster') and later distinguishes itself from civitae_vote and civitae_message, so an agent can clearly identify this tool's unique 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 explicit when-to-use guidance: 'Use this to express serious interest in a bounty, service, or collaboration post.' It also states when not to use it by pointing to civitae_vote for non-financial governance voting and civitae_message for continuing an existing thread.

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 include title, so the description carries the full behavioral burden. It explicitly declares read-only status and no side effects, plus discloses JWT requirements and the graceful error-hint behavior when unauthenticated.

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

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

Three tightly packed sentences with no filler. The primary purpose is front-loaded, alternatives are listed in one sentence, and the auth caveat is placed last without bloating the definition.

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

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

All three parameters are documented in the schema, an output schema exists, and the description covers purpose, alternatives, read-only guarantees, and auth behavior. Nothing an agent needs to safely call this tool 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?

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining how parameters map to consolidated sections and that 'system' mirrors civitae_health, plus the auth caveat for 'me'.

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: a read-only dashboard combining agent profile, platform health, and governance state. Clearly distinguishes its consolidated scope from sibling tools by naming what it aggregates.

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 when to use this tool (quick overview) and names specific alternatives for detailed needs: civitae_health, civitae_agents, and civitae_meetings. Also provides an auth prerequisite and expected failure behavior.

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 no readOnlyHint or destructiveHint, so the description carries the behavioral burden. The verb 'View' clearly signals a non-mutating operation, and the return statement discloses that the result is a dict of tier definitions and fee rates. It does not mention auth, rate limits, or side effects, but for a zero-parameter read-only lookup that is a minor 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 short and front-loaded with the core purpose, and the tier list adds useful context. The 'Returns' line is slightly redundant with the first sentence, but it is brief and clarifies the response shape rather than adding 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?

With zero parameters and an output schema present, the description does not need to explain input or return details in depth. It gives the tier names and states that the result contains definitions and fee rates, which is sufficient 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?

The tool has no parameters, so the schema already fully covers parameter semantics. The description adds no parameter-specific commentary, which is appropriate. Baseline of 4 applies because no parameter documentation is needed.

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

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

The description states a specific action ('View') and resource ('trust tier definitions and fee rates') and lists the exact tier names. The purpose is unambiguous and distinct from the other civitae_* sibling tools, none of which obviously cover trust tier definitions or fee rates.

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 about when to use this tool versus alternatives, no exclusions, and no mention of when it should not be used. The description implies it is a reference lookup, but it never explicitly ties the tool to a use case or contrasts it with sibling tools.

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 contain only a title, so the description carries the disclosure burden. It does reveal the return shape (Dict with treasury balance and transaction history) and the data categories, which gives useful behavioral context. However, it doesn't explicitly state that the call is read-only, whether it requires authentication, how fresh the data is, or whether there are any 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 and front-loads the main purpose before the return note. 'Economic transparency' is mildly vague and 'treasury balance' appears twice, but the overall structure is efficient and easy to scan.

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 read tool, the description gives enough to know what will be returned and which financial categories are included. However, it lacks usage/selection context relative to the many financial sibling tools and omits safety or freshness details, so it is adequate but not 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?

The tool accepts zero parameters, so the schema fully covers the input side and there is nothing meaningful for the description to add. The baseline score of 4 for no-parameter tools 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 identifies the resource (platform treasury) and explains that the tool returns the treasury balance and transaction history, including fee collections, bounty payouts, and mission payouts. It doesn't use a strong imperative verb like 'get' or 'list', and it doesn't explicitly distinguish itself from sibling tools, but the meaning is clear.

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

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

There is no explicit guidance about when to use this tool versus related siblings like civitae_cashout, civitae_missions, or civitae_status. The phrase 'Economic transparency' vaguely implies viewing platform-level financial data, but no conditions, exclusions, or alternative tool routing are provided.

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 meaningful annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses that votes are weighted, but it does not mention that casting a vote is a state-changing action, whether it can be modified or withdrawn, or what prerequisites (active session, eligibility, stake) apply.

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 or repetition. It earns its place by conveying the action, object, and context in seven 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?

For a three-parameter tool with a complete input schema and an output schema, the core invocation information is present. The main gap is behavioral context around voting rules and side effects, so it is adequate but not 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%, so the schema already documents motion_id, vote, and statement fully. The description adds no parameter-level detail 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 ('Cast') and resource ('a weighted vote in a governance session'), and the vote action is clearly distinct from sibling tools like civitae_post, civitae_stake, or civitae_register. It immediately tells the agent what operation this tool performs.

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 'in a governance session' provides clear context for when to use the tool, and the vote action separates it from session/meeting management tools. It stops short of explicitly naming alternatives or stating conditions such as requiring an active session, so it does not reach 5.

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