ChiefLab

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

With no annotations, the description carries the full transparency burden, and it succeeds. It discloses the approval side effect, the autoExecute path that invokes chieflab_execute_approved_action, the default false behavior, and the response's executionPlan/suggestedTool when autoExecute is not used. It also notes when the connector is manual_handoff or blocked, providing richer behavioral context than a simple 'approve' would.

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 dense and lengthy, but the complexity of the tool justifies most of the length. It front-loads the purpose and use case, then provides the necessary workflow and parameter context. A slight deduction is warranted because some details, such as P74 references, could be clearer or more tightly integrated.

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, no output schema, and many optional parameters, the description covers the full workflow: when to call, how to find the action ID, the IDE-native path, the autoExecute behavior and conditions, and the expected next step when autoExecute is not used. It is sufficiently complete for an agent to select and invoke the tool correctly in most scenarios.

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

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

The schema already covers all 7 parameters with 100% coverage, so the baseline is 3. The description adds value by emphasizing actionId as preferred and id as a legacy alias, and by explaining how platforms/recipients/subject are used together with autoExecute. This goes beyond a simple restatement of parameter names.

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

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

The description uses a specific verb ('Approve') and resource ('one ChiefMO publish/send action') and clearly distinguishes this from sibling tools like chieflab_execute_approved_action and chieflab_publish_approved_post. It also explains the IDE-native approval path and how it differs from pushing the user to reviewUrl.

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 the tool ('USE WHEN the user said approve <channel>, approve all, ship it, go ahead'), and gives a precise procedure for finding actionId from agentGuide.renderInChat. It also explains when autoExecute is appropriate and what to do without it, making alternatives and expected next steps 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?

With no annotations, the description carries full burden. It states the tool 'recovers all open business loops with literal user commands' and notes the same response shape and handler as chieflab_status. It adds a caveat about not blindly resuming loops, which shows behavioral nuance. However, it doesn't explicitly disclose whether the recovery mutates state or is purely read-only, which would be valuable.

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 sentences, front-loaded with the most critical information (alias, first tool usage). Every sentence adds value: what it does, when to use it, and a specific behavioral warning. 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 tells the agent exactly when and how to use the tool, mentions the output shape is the same as chieflab_status, and includes an important edge-case warning. It doesn't need to restate parameter details since the schema covers them. Slightly incomplete regarding return specifics, but the alias reference compensates.

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 descriptions for projectName, workspaceId, and currentRepoContext. The tool description doesn't add further parameter-level meaning, but it does reference the currentRepoContext implicitly in the caveat about unrelated loops. Baseline 3 is appropriate since the schema fully documents 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 is an alias of chieflab_status and that its purpose is to recover all open business loops with literal user commands. It explicitly frames it as the first tool to use on session start, which distinguishes it from the sibling chieflab_status by usage context even though they share the same handler.

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 explicit instructions on when to use: 'Use as the FIRST tool when an agent session starts on a workspace that already has activity.' It also gives a direct exclusion: if a recovered loop looks unrelated to the user's current repo launch request, do not blindly resume it. This is clear, actionable 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It explains the return type (plain-English paragraph) and contents set, implying a non-mutating read operation. It does not explicitly state read-only or side effects, but the summary nature and 'Returns' wording are sufficient for a low-risk 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 front-loaded with 'USE WHEN' and efficiently lists use cases and return content. The phrase 'The moat made visible' is stylistic but not strictly necessary. Sentences are purposeful 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 simple summary tool with no output schema, the description adequately covers the return format and content areas. It also references the sibling raw-data tool for follow-up. It does not describe edge cases like empty brain, but given the simplicity, this is acceptable.

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

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

Schema coverage is 50% (only tenantId has a description). The tool description adds context by mentioning 'per-workspace brain', which implies workspaceId is the scoping parameter, but it does not explain how tenantId relates or how parameters combine. This is marginal added value beyond the schema, not full compensation.

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: returning a plain-English summary of the per-workspace brain. It lists specific content (launch count, channel performance, brand voice, rejections) and distinguishes itself from the raw-data sibling chieflab_brain_read.

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 provides trigger phrases ('what do you remember about my brand?', 'show me my brain', 'what have you learned?') and directs users to pair with chieflab_brain_read for raw structured data, effectively framing when to use this summary vs the alternative.

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

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

No annotations are provided, so the description carries the full burden. It discloses the exact selection criteria, the return fields, and the fact that it works regardless of execution method. Although it does not explicitly state 'read-only,' the 'queue inspector' phrasing and action of listing imply no side effects, which is sufficient for a non-mutating 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 dense but efficient, front-loading the purpose and usage, and including the return shape. The 'P71' prefix adds a minor cryptic label that isn't necessary, but overall every sentence contributes meaningful context.

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?

There is no output schema, so the description compensates by listing the exact return fields. It also covers the filtering condition, execution methods, and the tool's relationship to cron-driven reviews. This is complete for a read-only queue inspection tool with optional parameters.

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 runId described as 'Optional. Restrict to one run.' and workspaceId as 'Optional workspace id.' The tool description does not add further parameter-specific semantics, so it neither enhances nor detracts from what the schema already provides.

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

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

The description clearly identifies the tool as a 'measurement queue inspector' and states it 'Lists actions where metadata.proof.measurementDueAt <= now AND metadata.proof.measuredAt is unset.' This specifies a distinct purpose and resource, differentiating it from other tools like force_measurement_due or post_launch_review.

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 'USE WHEN the agent wants to know which executed actions are ready for their 24h readback' and explains how it relates to chiefmo_post_launch_review. It clearly states the tool surfaces the queue for opportunistic use instead of waiting for the next cron tick, but does not explicitly list when not to use it or name direct alternative tools for exclusion.

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

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

With no annotations, the description carries the behavioral disclosure burden. It reveals the return values (pending/connected/failed) and the dependence on a connectionId, which adds meaningful context beyond the bare schema. It does not mention potential delays or side effects, but for a read-only status check, the disclosed behavior 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 a single, front-loaded sentence that immediately states the usage condition. It includes practical example queries and the exact output statuses, with no filler or redundancy.

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

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

For a simple status-check tool, the description covers the core purpose, usage trigger, and return values. However, it lacks explanation of the optional workspaceId parameter and any potential error conditions or edge cases, leaving small gaps in completeness given the absence of an output 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 description coverage is 0%, so the description must compensate. It explicitly explains that connectionId refers to the connection being checked, but it provides no guidance on workspaceId, which is also a parameter. Since only one of two parameters is addressed, the compensation is incomplete.

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 confirms a connector OAuth flow succeeded, with specific verb 'confirm' and resource 'connector status'. It provides example user queries ('did my connection work?') and distinguishes from related tools by specifying the exact statuses returned (pending/connected/failed).

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 opens with 'USE WHEN the user just completed a connector OAuth flow', giving explicit context for when to invoke it. It does not explicitly mention alternatives or when-not-to-use, but the trigger condition is clear and distinct from sibling tools like chieflab_connect_provider.

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?

Discloses return behavior for some providers: OAuth providers (ga4/search_console/hubspot) return an authorizeUrl, and API-key providers (zernio/resend) return instructions for the set-key tool. However, it omits behavior for Stripe, Linear, Notion, and Slack, and does not mention side effects like overwriting existing connections or whether user authentication is required. Since no annotations are provided, the description bears full responsibility for transparency but only partially fulfills it.

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 efficient and front-loaded with the core purpose, followed by a clear 'USE WHEN' flag and concise behavioral notes. It contains five sentences, but each adds value, and there is no fluff 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?

With only one parameter and no output schema, the description should clarify return behavior for all providers. It explains OAuth and API-key flows but leaves Stripe, Linear, Notion, and Slack unspecified. This gap prevents the agent from knowing what to expect when connecting these providers, making completeness only partial.

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 provider parameter lists all valid values. The description adds meaningful context by categorizing providers into OAuth vs API-key types, which explains different behavior expectations beyond what the schema states. This enriches the 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 the tool's function: 'Connect a third-party provider... to this workspace' and enumerates all supported providers. It distinguishes itself from sibling tools like chieflab_set_provider_key by explaining it returns instructions for the set-key tool for API-key providers, making its role unique.

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 explicit usage context with 'USE WHEN the user wants to wire up publishing, email sending, or analytics readback' and clarifies the prerequisite condition: 'Without this, publish/send/measure tools return configure first errors.' It also differentiates between OAuth and API-key provider flows, giving clear direction on when to invoke this tool.

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

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

With no annotations provided, the description carries the full burden. It discloses response size behavior ('Default response is summary-sized') and the alias relationship, which are useful. However, it does not clarify whether the tool itself can execute approved actions or merely returns the next step, leaving potential side effects ambiguous. This is a notable gap for a tool that might trigger actions.

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 concise and front-loaded: it starts with an alias note and purpose, then usage context, response shape, and parameter guidance. Each sentence contributes valuable information without fluff. The list of possible next actions is compact and informative.

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

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

The tool is part of a complex workflow with many siblings, but the description adequately covers its role: when to call it, what it does, and key response characteristics. It lacks detailed return structure and side-effect clarification, but the schema and usage context fill in most gaps. Given no output schema, the description is fairly complete 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 description coverage is 100%, so baseline is 3. The description adds meaning by explaining that runId comes from chieflab_get_users_after_build or chiefmo_launch_product, and by clarifying when responseShape:'full' should be used ('only for debug/export'). This goes beyond the schema's basic descriptions, enhancing parameter understanding.

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: 'Resume a ChiefLab launch loop from runId.' It specifies the main input (runId) and lists the possible next actions it handles (surface reviewUrl, execute an approved action, etc.). It also differentiates itself by noting it is an alias and by stating when to use it, 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 explicit usage context: 'USE WHEN an agent has already called chieflab_get_users_after_build / chiefmo_launch_product and needs the exact next action.' It also warns to use responseShape:'full' only for debug/export. However, it does not explicitly name alternative tools or say when not to use it, so it lacks a complete when-not/alternatives specification.

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?

Since no annotations are provided, the description carries the full burden. It details the internal behavior: creates an actionStore entry with status='awaiting_approval', inline draft body, an executionMatrix pointer, and how the reviewer sees it in the Launch Room/IDE chat. It does not mention permission requirements or error handling, but the state-changing nature and approval flow are transparent enough for an AI agent to predict outcomes.

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 dense but every sentence adds value: purpose, usage condition, internal state details, and loop context. It is front-loaded with the primary action, though the 'P75 —' prefix adds minimal noise. Slightly longer than strictly necessary but not wasteful.

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 no output schema and no annotations, the description covers the essential context: when to use, what it creates internally, how the review process appears to users, and the broader loop. It does not explain exact return value or error cases, but the state-creation behavior is well specified. This is adequate for a non-trivial action.

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

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

The schema already covers 100% of parameters, and the description adds contextual meaning beyond the schema. It explains that metrics should be the same object passed to chieflab_suggest_next_move, and that runId enables chain tracking. This extra semantic linkage helps the agent construct correct calls.

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 clear verb+resource statement: 'turn a Next Move suggestion into an approval-gated draft action.' It explicitly distinguishes from siblings by referencing chieflab_suggest_next_move and specifying the condition (kind is not 'wait' or 'noop'). This is a specific purpose with clear 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?

Provides explicit usage guidance: 'USE WHEN you've called chieflab_suggest_next_move and the suggestion's kind is not wait or noop.' It also describes the workflow context (approval card flow) and the overall loop, making it clear when and why to invoke this tool versus alternatives like chieflab_approve_action.

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

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

No annotations provided, so the description carries the burden. It transparently describes the open request lifecycle, including how offers are reviewed and accepted via chieflab_accept_offer and that acceptance triggers an approval-gated spend. Missing details on permissions, reversibility, or visibility, but the workflow disclosure is strong.

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 sentences, front-loaded with 'USE WHEN', and every sentence adds value (trigger, core action, follow-up flow). No fluff or redundant repetition of schema info.

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 7 params, nested objects, and no output schema, the description provides the key rationale and workflow context. The schema covers the remaining details. Lacks edge-case or error-handling info, but is adequate for typical use.

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 86% (>80%), so the baseline is 3. The description doesn't add parameter-specific meaning beyond the schema, but the schema already documents each parameter well. The description's focus is on the overall workflow, not param details.

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?

Clearly states it creates an open work request to route work to other operators, with concrete trigger examples ('demo video', 'design help'). The verb+resource is specific, and the offer/accept workflow distinguishes it from sibling 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?

Explicitly says 'USE WHEN' with scenarios where an operator hits a gap they can't fulfill, and explains the follow-up accept flow. However, it doesn't provide explicit when-not-to-use or compare with similar alternatives like chieflab_request_specialist.

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?

Discloses routing logic, execute-time sanity gate, metadata.proof shape, followup scheduling, uniform return shape, and manual/blocked behavior. With no annotations provided, this description carries the full burden and exceeds expectations.

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?

Dense but front-loaded with the purpose and USE WHEN condition. Despite length, every clause provides distinct value—no filler.

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

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

Very complete for a complex tool: return shape, post-execution hook, manual/blocked handling. The incorrect 'chiefmo_' tool references in the narrative create minor completeness gaps, but the behavioral model is otherwise well-covered.

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 schema already documents all six parameters clearly. The description adds little param-specific semantics beyond the schema; it only references actionId and mode indirectly.

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 it is a closed-loop executor wrapper that routes to native executors and writes metadata.proof, distinguishing it from direct executors. However, it incorrectly references 'chiefmo_publish_approved_post' and 'chiefmo_send_approved_email' while sibling tools are named 'chieflab_*', which could mislead tool selection.

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?

Explicit 'USE WHEN' conditions with mode/connectorReady criteria, and explains manual_handoff/blocked branches with alternatives. Deducted because 'chiefmo_approve_action' is referenced instead of the actual sibling 'chieflab_approve_action', creating potential confusion about the prerequisite.

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

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

With no annotations, the description carries the full burden. It discloses the admin-token auth requirement, the refusal condition if the row is already measured, and the default behavior (now - 60s). This gives an agent a clear picture of side effects and preconditions.

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?

Every sentence adds value: the purpose, use cases, auth, refusal condition, and parameter behavior. Although it starts with 'P93' which is cryptic, the rest is dense and efficient. No filler or redundant wording.

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 the action, conditions, auth, and parameter behavior. Since there is no output schema, it does not describe the return value or error behavior, but for a mutation tool this is acceptable. Overall, the tool is fully contextualized for an agent.

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

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

The schema already has 100% coverage for all three parameters. The description adds the default behavior for dueAt and clarifies that proofId comes from elsewhere, but these are minor additions. The baseline of 3 is appropriate since 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 specific action: forcing a proof_ledger row's measurement_due_at into the past. It distinguishes itself from siblings by calling itself an 'admin escape hatch' and explaining its role in the cron flow, which sets it apart from measurement or approval 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?

The description explicitly provides use cases: smoke testing the launch-to-measure chain and retrying stuck measurements. It also mentions the admin token gate. However, it does not explicitly name alternative tools or state when not to use it, which keeps it just below full marks.

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

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

No annotations are provided, so the description must disclose behavior. It lists the output contents ('inputs, outputs, pricing, approval-required flag, endpoint') and frames it as a pre-flight check, suggesting read-only. However, it does not explicitly state safety, permissions, or error cases, leaving some burden unmet.

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, front-loaded with 'USE WHEN,' and no filler. Every part 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?

For a simple two-parameter lookup with no output schema or annotations, the description covers purpose, usage, and return contents. It lacks explicit behavior notes (e.g., whether it is read-only) but is fairly complete given the tool's simplicity.

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

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

Schema coverage is 0% with no param descriptions. The description provides context by mentioning 'operatorId + capability' and 'capability profile,' giving some meaning to the two string parameters, but does not define their expected format or origin. It partially compensates for the missing schema 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?

Description opens with 'USE WHEN you have a specific operatorId + capability' and specifies the result 'full machine-readable profile...' It also distinguishes itself by naming 'Pre-flight check before chieflab_create_work_request.' This clearly identifies the tool's function and differentiates it from the create tool.

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

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

States the condition 'when you have a specific operatorId + capability' and positions it as a 'pre-flight check before chieflab_create_work_request,' giving clear context and naming the related workflow. It implies when not to use (without a specific pair) but does not explicitly name an alternative like search_capabilities.

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

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

With no annotations provided, the description carries the burden. It discloses the read-only nature via 'read' and explicitly lists the return shape: { profile, source, confidence, updated_at }. This gives the agent a good sense of behavior, though it does not cover edge cases like missing profile or error handling.

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-loaded with the core action and resource. Every sentence adds value: the first defines the operation and return, the second gives the usage context.

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 tool with one optional parameter and no output schema, the description adequately covers purpose, usage, and return shape. It could be more complete by noting behavior when no profile exists, but it is sufficient for an agent to use 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% for the single optional workspaceId parameter, so the schema already documents it. The description does not add extra parameter-specific details, but none are needed given the simple optional workspace-scoping.

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 'read the workspace's stored company profile', specifying both the action and resource. It also distinguishes from siblings like chieflab_set_company_profile by emphasizing 'read' and 'stored', and adds the specific use case 'before launch'.

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 'Use before launch to confirm what ChiefLab will ground in', giving clear timing and context. It does not mention when not to use it or alternative tools, but the guidance is sufficient for common use.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states this is a read operation ('read'), describes the return value ('Returns { channelTargets, store }'), and indicates it reads stored defaults. It does not mention error cases or side effects, but for a simple getter, this is adequate. No contradictions with 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 two sentences: the first states the core function, and the second provides a practical use case with a concrete example message. It is front-loaded, concise, and every sentence earns its place without unnecessary detail.

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

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

For a simple getter with one optional parameter and no output schema, the description is complete: it states what is read, what is returned, and when to use it (before launch). It even provides a sample user-facing message, making its role in the larger workflow clear. Given the low complexity, no further details are needed.

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 100% description coverage for its one parameter, 'workspaceId' described as 'Optional workspace id.' The description beyond the schema mentions 'the workspace's stored publishing target defaults,' which slightly clarifies the parameter's role, but adds little new semantics. Baseline 3 is appropriate given 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 clearly states the tool's function: "read the workspace's stored publishing target defaults." It specifies the verb 'read' and the resource 'publishing target defaults,' and distinguishes it from sibling chieflab_set_publishing_targets by indicating this is a read operation. The returned shape '{ channelTargets, store }' adds further specificity.

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 concrete usage scenario: 'Useful before launch so the agent can surface... instead of blocking on first auto-execute.' It implies when to use (prior to launch) and references the sibling for setting targets, which helps differentiate. However, it does not explicitly state when not to use it or describe alternative tools beyond the one sibling.

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

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

With no annotations, the description carries full burden and does well by revealing the behavioral loop: launchPack, signed reviewUrl, approval-gated publish/send actions, 24h measurement, memory, next move, moneyLoop, and agentDependency. It lacks explicit side-effect or permissions detail, but the behavioral arc is clear.

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

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

The description is longer than two sentences but each sentence adds value: alias identification, trigger conditions, output artifacts, prerequisite, and routing/exclusion. It is front-loaded and structured, though slightly verbose.

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, usage context, behavioral outputs, and routing, which is substantial given no annotations or output schema. It stops short of detailing return values or explicit side effects, but for an alias tool with 11 parameters, it is reasonably 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 input schema has 100% parameter coverage with detailed descriptions, so baseline 3 applies. The tool description adds general guidance about repoContext but doesn't enhance per-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 clearly defines the tool as an outcome-named alias for launching a product to acquire users, with explicit trigger phrases like 'get users' and 'find customers'. It distinguishes from the marketing diagnostic tool via 'do not use chiefmo_diagnose_marketing for a new product', establishing a unique purpose among siblings.

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

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

Provides explicit when-to-use scenarios ('after build... user asks get users, find customers...'), a prerequisite ('Gather repoContext first'), and an explicit alternative exclusion ('do not use chiefmo_diagnose_marketing'). This gives strong, actionable guidance for tool 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?

With no annotations, the description carries the full behavioral burden, and it explicitly discloses 'Cheap, no side effects.' It also describes what will be returned (operator menu, workspace state, next action), giving the agent a clear model of 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 three sentences, front-loaded with the critical 'FIRST TOOL' instruction, and every sentence adds value: when to use, what it returns, side-effect profile, and next-step alternatives. 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?

For a zero-parameter, no-output-schema help tool, this description is fully complete. It explains the tool's role, behavior, return contents, and even suggests follow-up tools, which is more than sufficient for an agent to invoke it 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 zero parameters, so the schema provides full coverage. The description appropriately adds no parameter details, and the baseline for zero-parameter tools is 4 because there is nothing to clarify.

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: it returns the operator menu, workspace state, and next action, positioning it as an orientation/help tool. It distinguishes itself from siblings by explicitly being the 'first tool' to call when unsure where to start.

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 explicit when-to-use guidance: 'call before anything else when you don't know what ChiefLab does or where to start.' It also names alternatives for next steps: 'call chieflab_launch_product for a full launch or chieflab_post for a single channel.'

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

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

No annotations are provided, so the description carries the full burden. It adds important behavioral context: scoping to 'THIS workspace', recency ordering, and the default status filter ('default new'). However, it doesn't disclose what constitutes an 'engagement event', whether pagination exists, or any rate limits. 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 sentences, front-loaded with usage triggers, and no filler. Every sentence serves a purpose: trigger phrases, output description, filtering, and pairing. Extremely 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 no output schema and no annotations, the description covers the essentials: purpose, usage triggers, scoping, ordering, filter options, and a workflow recommendation. It could be slightly more explicit about the return format (e.g., list of events with fields), but for a simple list tool it is reasonably 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 75% (workspaceId lacks a description). The description adds meaning to workspaceId by specifying 'for THIS workspace', and it reinforces the status filter values. However, it doesn't elaborate on limit or sinceHours beyond what the schema already says. Since the schema does most of the heavy lifting, 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 clearly states the tool's function: 'Returns engagement events for THIS workspace, ordered by recency.' It provides specific example user queries ('what came in from my launches?', 'show me my replies') that make the purpose unmistakable. The verb 'returns' plus the resource 'engagement events' distinguishes it from sibling tools like chieflab_launch_product or chieflab_draft_reply.

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 opens with 'USE WHEN' and lists exact user phrasings that should trigger this tool, providing clear when-to-use guidance. It also recommends pairing with chieflab_draft_reply for handling the events, which guides the agent on workflow. This is explicit 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?

With no annotations, the description carries the burden. It discloses approval-gated publishActions, signed reviewUrl, 24h measurement queue, and internal composition of post/email. But it lacks details on side effects (e.g., does it send emails or just create drafts?), auth requirements, or rate limits, leaving ambiguity for an agent.

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 packed with hyphenated jargon ('repo-grounded positioning', 'approval-gated publishActions', '24h measurement queue'). It lacks front-loading and is not easily scannable. While it contains useful info, it is not concisely structured for quick agent comprehension.

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 (10 params, no output schema, no annotations), the description is insufficient. It provides no return-value format, no error scenarios, no prerequisites, and no practical explanation of the measurement queue or reviewUrl. An agent would struggle to know what to do with the response or how to validate correctness.

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 has 0% description coverage and 10 optional parameters. The description mentions channel types and image briefs, giving a hint about the 'channels' and 'imagesNeeded' parameters, but does not explain 'goal', 'brand', 'tenantId', 'productUrl', 'webhookUrl', 'repoContext', 'workspaceId', or 'idempotencyKey'. The high-level description does not compensate for the lack of parameter documentation.

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 this as an end-to-end product launch orchestrator, listing the main stages (positioning, channel drafts, image briefs, approval, measurement). It distinguishes from siblings by naming internal composition of chieflab-post and chieflab-email, making the tool's primary role evident.

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 it is the 'primary' operator and mentions a spec-renamed alias, implying it is the main launch tool. However, it gives no explicit when-to-use vs. alternatives, nor exclusions or prerequisites. Sibling tools like chieflab_post or chieflab_email are implicitly alternatives but not clearly contrasted.

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

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

With no annotations, the description carries the transparency burden. It discloses that the tool returns 'kind + label' for each specialist, which clarifies the output structure. As a simple, non-mutating list tool, this is sufficient disclosure for safe invocation.

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 with the action front-loaded ('list the specialist agents') and no filler. The secondary sentence provides use-case context and return-value details, 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 tool is simple (no params, no output schema), and the description covers the purpose, usage triggers, and return format. It gives the caller enough information to decide when to use it and what to expect.

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 the description cannot add parameter-level detail. The baseline for a no-parameter tool is 4, and the description appropriately focuses on the tool's output and purpose.

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 specialist agents ChiefLab can delegate to, enumerating specific categories (design/video/research/outreach/seo/analytics). This uses a specific verb+resource and differentiates from sibling tools like chieflab_request_specialist by framing it as a prerequisite listing action.

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?

Explicit usage triggers are provided: 'USE WHEN the user asks...' and 'before calling chieflab_request_specialist'. While it names a related tool, it doesn't explicitly list exclusions or alternatives beyond that, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden and does well: it discloses the side effects (flips to executed, sets metadata.markedManuallyAt and metadata.executedManually=true, card disappears from Today's Loop). It does not mention reversibility or permission requirements, but for this simple action the core behavior is clearly 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?

Two sentences, with the purpose and usage rule stated upfront. The inclusion of examples and the alternative tool is efficient and directly useful. No filler 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 simple state-change tool with 3 parameters and no output schema, this description is complete. It explains the action's effect, when to use it, and the alternative. The agent can confidently select and invoke it without additional 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?

Schema coverage is 100%, so the schema already describes all three parameters. The description adds the overall context (e.g., note stored in metadata.markedManuallyNote) but doesn't significantly go beyond the schema descriptions. Baseline of 3 is appropriate due to 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 clearly specifies the verb ('mark as completed'), the resource ('next-move action'), and the condition ('when the founder has done the move BUT there's no URL to record'). It also provides concrete examples (reply_to_commenters, dm_engagers) and explicitly distinguishes itself from the sibling tool chieflab_record_manual_publish.

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 (no URL to record) and 'when not to use' with a named alternative (chieflab_record_manual_publish for moves with a URL). It also explains why the alternative is preferred, noting that it records the URL and marks executed simultaneously.

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

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

With no annotations provided, the description carries the full burden and does an excellent job. It discloses side effects (writes to metadata.proof, auto-creates a next-move action based on outcome), idempotency, and authentication requirements (no API key needed). This goes above and beyond what a typical description provides.

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, opening with a clear action statement, then usage guidance, side effects, idempotency, and auth. Every sentence adds value without unnecessary fluff, making it easy to scan and understand quickly.

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

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

Despite no output schema and no annotations, the description covers everything needed: purpose, trigger conditions, process, side effects (including decision tree for trending/engaged/stalled), idempotency, and authentication. It is sufficiently complete for an agent to decide when and how to invoke 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%, so the baseline is 3. The description adds some context by explaining that actionId references a publishedUrl pointing at an HN post and that force bypasses an existing measurement, but it does not provide detailed parameter syntax beyond the schema. It neither fully compensates nor detracts.

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 specific verb+resource: it pulls a Hacker News post's score, comments, and top replies via the public HN API and writes them to metadata.proof. It distinguishes itself from sibling tools like chieflab_measure_reddit by explicitly targeting Hacker News and describing the unique follow-up behavior.

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 explicit guidance on when to use the tool: 'USE WHEN a published Hacker News action is ripe for 24h measurement.' It explains the prerequisite checks (publishedUrl, item id, Firebase API) and mentions idempotency, but does not explicitly name alternative tools or state when not to use it, stopping short of a 5.

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

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

With no annotations provided, the description carries the full burden. It discloses the use of a public API (no auth), the parsing of subreddit/post id from publishedUrl, idempotency (unless force:true), and the side effect of auto-creating next-move actions based on outcome. This is comprehensive 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?

Four sentences, each earning its place. The description is front-loaded with purpose, then usage condition, then mechanism and side effects, ending with idempotency. No fluff 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?

The description covers the API endpoint, data pulled, side effects, and idempotency. It does not describe the return format, but since it writes to metadata.proof and there is no output schema, this is a minor gap. The presence of a sibling measure_hacker_news tool is not explicitly addressed, but the Reddit specificity is clear.

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 meaning beyond the schema by explaining how actionId's publishedUrl is used to derive subreddit and post id, and clarifies the force parameter's effect on idempotency. This extra context justifies a score above 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?

The description clearly states the tool pulls a Reddit post's score, comments, upvote ratio, and top replies, and writes them to metadata.proof. This specific verb+resource combination distinguishes it from sibling tools like measure_hacker_news.

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 specifies when to use it: 'USE WHEN a published Reddit action is ripe for 24h measurement.' This is clear contextual guidance. However, it does not explicitly mention alternatives or when not to use it (e.g., for Hacker News posts), so it only partially meets the 'vs alternatives' criterion.

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

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

No annotations are present, so the description carries the full burden of disclosing behavior. It fully describes the probe behavior, the fallback mechanism, and the return shape with field meanings (e.g., 'tableExists: false' means migration not run). This is highly transparent and goes beyond a simple health-check statement.

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 structured, starting with a terse action phrase ('P91 — verify the persistent stores') followed by use cases and return format. Every sentence adds value, though the 'P91' reference and the return-shape explanation could be slightly tighter. It is not overly verbose, but there is minor redundancy in the use cases.

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 no output schema, the description compensates by explaining the return structure in detail, including the meaning of 'tableExists: false'. It provides strong use-case context and the key behavioral outcomes. However, it omits any explanation of the workspaceId parameter, which is a gap given the simple input schema. Overall, it is complete enough for most scenarios but not flawless.

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 one optional parameter, workspaceId, with no description (0% schema description coverage). The description does not mention workspaceId at all, failing to explain how it affects the check or whether it scopes the verification. The tool's purpose implies workspace-specificity, but the parameter semantics are left entirely to the name.

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: 'verify the persistent stores' and names the exact tables (proof_ledger / publishing_targets / company_profiles) or the in-memory fallback. This clearly distinguishes it from sibling tools like get_publishing_targets or get_company_profile, which retrieve data rather than verify durability.

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 three concrete 'USE WHEN' scenarios: after SQL migrations, before a founder launch, and when debugging disappeared data. This gives clear context for when to use this tool versus alternatives, and the exclusions are implicit by the distinct purpose.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently describes pulling engagement metrics, recommending next steps, and returning per-account analytics and a structured brief. While it does not explicitly state whether data is mutated, the read-only nature is strongly implied by the language used.

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 but information-dense, using a clear trigger–action–output structure. It is slightly long but every clause adds value, and the colon-delimited list of outputs improves readability.

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 the trigger condition, input scope, process, and output components, including the recommendation brief. Given the absence of an output schema, this is fairly complete. It could be more explicit about error conditions or required prior state, but the key prerequisite (≥24h after publish) is clearly stated.

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?

All four parameters have descriptions in the schema, and the tool description adds the origin of runId (from launch_product) and the meaning of outputMode. Since schema coverage is 100%, the description provides marginal added value beyond the schema, but it is consistent and adequate.

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

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

The description clearly states the tool's function: pulls post-launch engagement metrics for posts in a launch run and generates a recommendation brief. It distinguishes itself from siblings by its alias and specific trigger condition, making it uniquely identifiable as the post-launch review tool.

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?

An explicit 'USE WHEN' clause defines the exact conditions (≥24h after publish, user asks about launch performance) and provides example queries. This gives clear, unambiguous guidance on when to invoke this tool over alternatives.

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

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

With no annotations provided, the description fully discloses behavior: returns a draft queue + signed reviewUrl + agentGuide block, each action lands in awaiting_approval, and 'nothing fires without explicit human approval.' Also explains the grounding sources (runId, brand voice, repo facts, channel performance). This is comprehensive behavioral transparency for a mutation tool.

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

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

The description is relatively long but well-structured: trigger condition, function overview, grounding details, and output/approval disclosure. Each sentence provides unique value, and the front-loaded 'USE WHEN' makes the purpose immediately clear. Minor redundancy with schema (e.g., horizon default) but overall efficient for the tool's complexity.

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 4-parameter tool with no output schema and no annotations, the description is exceptionally complete. It covers inputs (runId), process (grounding in company brain), outputs (draft queue, reviewUrl, agentGuide block), safety (requires human approval), and the multi-day planning context. No critical aspects are missing for an agent to invoke and understand the tool's behavior.

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

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

Schema coverage is 100% with descriptions for all four parameters. The description adds semantic enrichment by mapping horizon values to concrete content (day 2 reply post, day 3 case study, day 5 metrics share, day 7 retrospective), which clarifies what planning horizons mean in practice. While the schema already defines defaults, the description's context elevates parameter understanding 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 function: 'turns one launch into a 7-day launch mode: drafts a queue of follow-up actions' with specific examples (day 2 reply post, day 3 case study, etc.). It also distinguishes from siblings by noting it grounds in prior recommendation 'so the next move doesn't repeat the last one' and uses the alias prefix.

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 explicit trigger conditions: 'USE WHEN the user has just published a launch (or ≥24h post-launch) and asks "what's next?"...' This gives clear context for when to use. It does not explicitly mention alternatives or when not to use, but the post-launch condition and the queue-building purpose make it distinguishable from sibling tools like suggest_next_move.

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

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

No annotations are provided, so the description bears the full burden. It discloses the external/system action nature, the strict approval gate with the exact return payload ('requires_approval' with reviewUrl), and the successful result (live platform post URL). It also warns against calling without approval.

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 bit long but well-structured: alias, purpose, explicit trigger, approval behavior, and warning. Every sentence adds value, but it could be tightened without losing meaning.

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 high-stakes external action, the description covers the approval gate, execution result, platform scope, and safety warning. It provides sufficient context for correct invocation without needing an output schema.

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

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

Schema coverage is 100%, so baseline is 3. The description adds crucial context: content is the final rendered post text from the LLM, actionId is specifically from chiefmo_launch_product, and platforms require accountIds from chieflab_list_publish_accounts. This enriches the schema definitions and aids correct invocation.

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 ('Publish') and the resource ('an approved social post') and lists the specific platforms. It distinguishes the tool from siblings like chieflab_send_approved_email by specifying the social publishing rail and the approval gate from chiefmo_launch_product.

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 WHEN' clause explicitly defines the trigger: after the user approves a publishAction on the reviewUrl. It also warns 'never call this without an approved actionId,' providing a clear when-not. However, it does not explicitly name alternative sibling tools (e.g., chieflab_send_approved_email), so it misses the full 'alternatives' component.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses persistence semantics (Supabase-backed vs in-memory fallback) and describes return contents (artifact URLs, channels, execution modes, measurement state). It does not explicitly state read-only behavior, but 'query' implies it; still, a clear 'does not modify data' statement would strengthen this.

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 tool's core purpose, and uses exactly three sentences to convey purpose, usage triggers, return content, and persistence behavior. Every sentence adds value; there is no redundant or filler text.

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 query tool with 5 optional parameters, no output schema, and no annotations, the description covers the main context: what it returns, when to use it, and behavioral persistence. It does not mention result ordering or default limit, but the schema provides default limit and the description gives a solid overall picture, making it largely 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 baseline is 3. The description does not add per-parameter meaning; it merely references the ledger query context. The schema already explains each parameter's purpose, so the description adds little beyond the structured field definitions.

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 ('query') and resource ('persistent proof ledger'), and clearly explains the tool's output with concrete examples of user intents ('what has ChiefLab actually shipped?', 'show me the launch history'). It distinguishes itself from sibling tools by focusing on the ledger of executed publishes/sends/manual-posts rather than actions like checking due measurements.

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 'USE WHEN' scenarios with example user phrasings, making it clear when to invoke the tool. However, it does not explicitly state when not to use it or name alternative tools, so it misses the full 'when-not/alternatives' tier.

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

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

With no annotations, the description carries the full transparency burden. It discloses that it reads metadata.proof.artifactUrl, writes metrics and measuredAt, auto-classifies outcomes using channel-specific thresholds, and creates next-move actions. While it doesn't address failure modes (e.g., missing artifactUrl), the key side effects are clearly 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 dense but well-structured, starting with an identifier and nickname, then use conditions, process steps, and return value. Every sentence adds value, though it could be tightened. The length is justified by the tool's complexity.

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 (4 params, nested object, no output schema), the description covers prerequisites, the exact data flow (read, write, classify, create actions), and the return value (schema for form rendering). It even handles the edge case of invoking without metrics to retrieve the schema, making it highly 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 coverage is 100%, so baseline is 3. The description adds meaning beyond the schema by explaining the per-channel metrics structure (x, linkedin, email, landing_hero, product_hunt) and the special 'call without metrics' behavior to retrieve the schema. It clarifies the purpose of 'force' and the overall workflow.

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 ('record manual metrics') and resource (metric fallback for channels without public-API measurement). It enumerates target channels (X, LinkedIn, Email, landing pages, Product Hunt) and explicitly distinguishes from the hacker_news/reddit auto-measurement siblings.

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

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

Provides explicit 'USE WHEN' conditions: when a channel lacks a public-JSON metrics endpoint AND the founder can paste visible numbers. It also notes the alternative of calling without metrics to retrieve the schema, clarifying when to use that variant. No ambiguity about when this tool applies versus alternatives.

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

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

No annotations are provided, so the description carries full responsibility. It discloses concrete side effects: status flips from 'approved' to 'executed', metadata fields set, proof_asset persistence to P9 brain, and queueing of chiefmo_post_launch_review. It also warns about the outcome of non-use. This is exceptionally transparent for a tool with no structured safety hints.

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-structured paragraph that front-loads the trigger with 'USE WHEN'. Every sentence contributes: condition, action, effects, consequence. It avoids redundancy with the schema and is free of 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?

The description covers trigger, workflow, side effects, and downstream actions. However, it does not describe the return value or any failure modes, which would be useful given there is no output schema. Still, it provides enough context for an agent to decide correctly and invoke the 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?

Schema description coverage is 100%, so the baseline is 3. The description adds workflow context but does not add per-parameter meaning beyond what the schema already provides. For example, actionId is described in schema as being from chieflab_use_manual_fallback, and notes persistence is already implied by schema. No significant extra parameter-level insight is offered.

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 specific verbs: 'Records the URL on the original publishAction', 'persists a proof_asset', and 'queues 24-hour metrics readback'. It distinguishes from sibling tools by explicitly referencing chieflab_use_manual_fallback and warning that without it, manually-posted channels are lost to the measurement loop.

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?

Opens with 'USE WHEN' and precisely defines the trigger: after the user has manually posted to a channel returned by chieflab_use_manual_fallback. It also explains the consequence of not using the tool, providing implicit when-not-to-use. The workflow context (feeding URL back) is clear and differentiates from alternatives.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavioral details: it increments action.metadata.revision, preserves the original brief in metadata.history, and requires the agent to render and commit. It doesn't mention auth or rate limits, but the core side effects are well described.

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 trigger conditions. It follows a logical flow: when to use, what happens, what to do next, and multi-turn behavior. Every sentence provides necessary information 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?

The description fully covers the tool's workflow: pulling the brief, merging instructions, returning the updated brief, and the required follow-up commit. It also explains revision handling for multi-turn coherence. Even without an output schema, the agent knows what to expect and what to do next.

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

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

Schema coverage is 75%, so the description is not required to fully compensate, but it also doesn't add much beyond the schema. It clarifies that actionId refers to the publishAction.id and that instruction is plain-English, but these are already in the schema. The optional 'body' parameter is explained in both places. No value is added for workspaceId.

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 verb ('redraft') and resource ('published draft'), and distinguishes it from siblings by listing specific trigger phrases. It explicitly says what it does: pulls the existing brief, merges the instruction, and returns an updated brief.

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 starts with 'USE WHEN' and gives concrete examples of user requests that should trigger this tool. It also instructs the agent to call chieflab_record_rendered_copy after rendering, providing a clear usage flow and implied exclusions for non-redraft tasks.

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 key behavioral traits: it reads the original brief from run metadata, calls produceVisualAsset, returns a specific asset shape, and notably 'Does NOT auto-persist back to the run.' It also explains that the caller decides whether to swap or treat as a parallel candidate. With no annotations present, this fully carries the transparency 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 dense but highly efficient: each sentence serves a purpose—purpose, trigger, internal behavior, return value, and persistence caveat. The key info is front-loaded, and no words are wasted.

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

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

Given 12 parameters, nested objects, and no output schema, the description adequately covers the full workflow: input lookup, processing, return shape, and side-effect behavior. The return fields are explicitly listed, and the caller's decision point is clarified, making the tool usable without further 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?

Schema coverage is 100% with descriptions for all 12 parameters, so the baseline is 3. The description adds workflow context (e.g., reading the brief from run metadata, calling produceVisualAsset) but does not materially enrich individual parameter semantics beyond what the schema already provides. It mentions 'style / fidelity / headline / model' as regeneration targets, but these are already evident from 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 a specific verb-resource pair: 'regenerate a single visual asset' and lists the exact adjustable dimensions (style, fidelity, headline, model). It also distinguishes this tool from siblings like chieflab_review_visual_asset by explicitly tying it to the 'Regenerate' action in the Launch Room.

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 an explicit trigger: 'USE WHEN a reviewer hits Regenerate on a launch image in the Launch Room.' It lacks an explicit when-not-to-use or alternative tool reference, but the use case is clearly scoped.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that specialists are deterministic stubs today, that each request creates an approval-gated action landing in the Launch Room, and that `runId` grounds output in the originating launch brief. It does not mention auth requirements or exact output envelope details, but the key side effects are covered.

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 and uses a scannable 'USE WHEN' pattern with the kind list. It is slightly longer than necessary due to the 'Future LLM-backed implementations swap in transparently' sentence and some redundancy with the `autoCreateAction` schema description, but still organized and 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?

For a 5-parameter tool with a nested `brief` object and no output schema, the description covers purpose, use cases, deterministic behavior, side effects, and runId grounding. It could more explicitly state the return shape beyond 'structured briefs / plans / drafts' and mention error cases, but the provided information is sufficient for an agent to select and invoke 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%, so the baseline is 3. The description adds meaning by translating the `kind` enum values into concrete real-world artifacts and by explaining the purpose of `runId`—grounding in the launch brief. It relies on the schema for `brief`'s internal structure, but that's acceptable given the schema descriptions are already detailed.

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 explicitly names the resource ('specialist agent') and uses a specific verb ('delegate'), then maps six `kind` values to concrete deliverables (graphic brief, video shot list, research plan, outreach drafts, SEO recommendations, analytics verdict). This clearly distinguishes it from sibling tools like `list_specialists` or `create_work_request` by scoping the purpose to specialist delegation.

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 opens with 'USE WHEN the launch needs more than copy' and enumerates specific scenarios per `kind`, giving an agent clear conditions to invoke the tool. It does not explicitly name alternative tools or provide when-not-to-use guidance, so it lacks full exclusion semantics.

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

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

No annotations are present, so the description carries the full burden. It explains the return behavior (readiness boolean or updated connect path) and clarifies that this is a check, not an execution. However, it does not explicitly state side effects or permissions, though the 're-check' wording implies a read-only 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 front-loaded with the core action, then elaborates on return and usage. Each sentence adds value, though the 'P13' prefix and slightly verbose return explanation could be tightened for better 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 description provides strong context for purpose, usage, and return value. It lacks explicit output schema details and workspaceId explanation, but given the tool's simplicity and the existing schema for actionId, the coverage 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?

ActionId is well described in the schema and reinforced by the description. WorkspaceId has no description in the schema or description, leaving a gap. With 50% schema coverage, the description partially compensates but not fully.

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: re-checking a blocked publishAction's connector readiness. It distinguishes from siblings by focusing on the retry scenario and naming the specific publish tools (chiefmo_publish_approved_post / chiefmo_send_approved_email) to re-fire.

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 explicitly provides a USE WHEN trigger: after the user connects a missing provider. It also names the downstream tools, giving clear context for alternative actions and when this tool should be used before re-firing.

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

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

No annotations are provided, so the description takes on the full burden. It discloses that the tool reads the stored visualAssets list, updates status, persists to run metadata, and affects future loads and channel-media render. It also contrasts with the non-persisting companion, covering side effects well.

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 action and resource, and every phrase adds value (statuses, persistence, companion distinction). No 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?

Given the moderate complexity and no output schema, the description fully covers behavior, persistence, and effects on other systems. It is complete for an agent to decide when and how to invoke.

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 each parameter described. The description does not add extra detail beyond what the schema provides, so 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 clearly states 'approve or reject a single visual asset' with specific asset types, and distinguishes itself as a companion to chieflab_regenerate_visual_asset. This is a specific verb+resource that differentiates from siblings.

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

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

Explicitly includes 'USE WHEN a reviewer hits Approve or Reject' and names the companion tool as an alternative that produces an updated shape without persisting. Provides clear context for when to use vs. regenerating.

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

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

No annotations are provided, so the description carries the burden. It discloses that results are active and ranked by recency, but does not mention read-only nature, authentication, or error behavior. The description gives some helpful behavioral context 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 front-loaded with a clear 'USE WHEN' statement and includes useful examples. The last sentence 'The discovery embryo...' is metaphorical and adds little practical value, but overall the description is 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?

For a search tool with 3 optional parameters and no output schema, the description provides sufficient context: when to use, what it returns, and a complementary tool. It could be more complete by describing result fields, but the combination of description and schema is 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 description coverage is 100%, so all parameters are already documented. The description adds examples of typical queries but does not add significant meaning beyond the schema. Baseline score of 3 is appropriate when schema fully covers 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 it searches for capabilities outside an operator's scope and returns active capability records ranked by recency. It distinguishes from siblings by focusing on capability discovery and providing example queries. The verb 'search' is implied by the tool name and reinforced by the usage scenario.

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?

Explicit 'USE WHEN' guidance is provided with concrete examples, and it pairs with chieflab_create_work_request for the follow-up workflow. However, it does not explicitly mention when not to use this tool versus alternatives like chieflab_get_capability or chieflab_list_specialists.

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

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

With no annotations provided, the description carries full burden. It discloses that this is a 'Money/external-system action — once sent cannot be unsent', requires a verified domain, has a strict approval gate, and enforces recipient limits. This is rich behavioral context beyond what schema/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 dense yet efficient. Every sentence delivers actionable information: purpose, usage trigger, adapter context, domain verification, recipient limit, and irreversibility. 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?

The tool has no output schema and no annotations, but the description covers purpose, usage, constraints, and irreversible consequences. It does not describe the response format, but for a send action that's often acceptable. Overall, it's sufficiently complete for an agent to invoke 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 high (86%), but the description adds critical semantic context: `from` must be on a verified domain at Resend, `to` is limited to ≤50 recipients, and `actionId` is required for the approval gate. These nuances go beyond the schema's field descriptions, enhancing parameter understanding.

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

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

The description opens with a specific verb+resource: 'Send an approved launch email through the email sending rail'. It clearly states what the tool does and distinguishes it from siblings by referencing the approval gate and the alias relationship with chiefmo_send_approved_email.

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 explicit when-to-use: 'USE WHEN the user has approved an email publishAction from chiefmo_launch_product and you need to fire the send.' It also gives a prerequisite (check chieflab_list_email_senders first) and constraints like single recipient or short list (≤50).

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

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

With no annotations, the description discloses key behaviors: the profile is persistent, affects every subsequent launch, and partial updates merge / null removes. This goes beyond the basic setter semantics. It doesn't cover auth or return value, but the core behavioral traits are 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 front-loaded with a clear purpose and then provides contextual background. It is somewhat verbose with the P88/pre-P88 narrative, but every part serves to explain why the tool exists and how to use it. The field list is a useful reference.

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 involves a complex nested profile object, and the description covers the structure and merge semantics without an output schema. It omits the return type (likely void/success), but for a setter this is less critical. The description is sufficient for an agent to invoke it 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?

Although schema coverage is 100%, the description adds value by enumerating the fields the profile consumes (companyName, productType, brandColors, etc.), which the schema does not specify for the 'profile' object. It also reinforces the partial-update behavior for merge/remove, complementing the schema description.

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

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

The description clearly states the tool's function with a specific verb and resource: 'set the workspace's persistent company profile.' It also explains the broader purpose (storing facts once for all future launches) and the P88 context, which distinguishes it from the sibling get_company_profile (a getter vs setter).

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 explains when this is useful (post-P88, for grounding launches without a repo) and gives concrete usage guidance ('Pass partial maps to update specific fields; pass null for a field to remove it'). It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to decide.

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

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

With no annotations provided, the description carries full transparency burden. It discloses key behaviors: encrypted at rest, key never leaves the workspace, the BYOK billing model, and the fallback to ChiefLab's key. This goes far beyond a simple 'store key' statement.

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

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

The description is front-loaded with the core action, then efficiently covers consequences, providers, security, and removal. It is somewhat dense but all information is relevant and well-structured, with no wasted sentences.

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 set-key tool without an output schema, the description covers the essential aspects: purpose, behavior, security, provider list, and how to revoke. It doesn't discuss overwriting behavior or error cases, but overall it is sufficiently complete for effective 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 coverage is 100% and every parameter has a description, but the tool description adds meaningful context for the provider parameter (e.g., 'gemini (image gen)', 'resend (email)') and emphasizes the workspace scoping. This enriches the understanding beyond the bare 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: 'Store a provider API key for THIS workspace.' It distinguishes from sibling tools by explicitly naming chieflab_revoke_provider_key for removal, and the BYOK explanation adds context about the tool's role.

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 explains when to use the tool (to provide your own key for BYOK) and the default behavior without it (ChiefLab uses its own key). It explicitly points to a specific alternative for removal, but doesn't compare with other related tools like connect_provider, so guidance is clear but not exhaustive.

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

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

With no annotations provided, the description fully discloses behavioral traits: partial maps update specific channels, passing null removes a channel, persistence depends on wiring (publishingTargetsStore vs in-process Map), and the return value includes merged targets and storage location. This is exceptionally 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?

A single, dense paragraph that front-loads the primary purpose, then concisely explains usage patterns, persistence, and return value. Every sentence contributes necessary context with 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?

Despite having no output schema, the description covers the return value and storage location. It adequately explains the nested parameter behavior, optional workspaceId, and implications for use with approve_action, making the tool fully self-contained for an agent.

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 adds meaningful semantics beyond the schema by explaining partial updates, null removal, persistence behavior, and return structure—especially valuable for the nested channelTargets object and optional workspaceId.

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 ('set') and resource ('per-workspace publishing target defaults'), clearly distinguishing it from sibling get_publishing_targets. It also explains why this tool exists—to avoid passing platform/recipient IDs on every approve_action call—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?

States this is a 'one-time setup per workspace' and explains how it relates to chiefmo_approve_action, providing clear context for when to use it. While it doesn't explicitly list exclusions or alternatives, the sibling get_publishing_targets is implicitly denoted through the purpose, and the usage scenario 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?

No annotations are provided, so the description carries full burden. It thoroughly discloses the output (apiKey inline), the required post-signup steps (config write, restart), fallback behavior, and security constraints (URL expiry, single-use, IP rate limit, no login form).

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 dense but well-structured: trigger condition, preferred flow, fallback, and security details are clearly delineated. It is longer than strictly necessary but every sentence carries useful information.

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

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

For a tool with no output schema and no annotations, the description fully explains what the tool returns (apiKey), how to use it operationally (config write, restart), and what limits apply (expiry, rate limit). It is complete for an agent to act 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 baseline is 3. The description does not add extra meaning to the parameters themselves (agentName, contactEmail, workspaceLabel), but the schema already documents them adequately.

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 has a specific verb+resource: 'creates a new workspace and returns the API key inline as `apiKey`.' It is explicitly triggered by a 401/authentication error and clearly distinguishes itself from other tools by describing the signup/auth-recovery 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?

Provides an explicit 'USE WHEN' condition ('no ChiefLab API key yet... 401 error'), a preferred flow (write API key to MCP config, ask restart, re-call original tool), and a fallback (deliveryUrl with rate limits). This is definitive when-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?

With no annotations provided, the description carries full behavioral disclosure. It reveals the side effect (flips action to rejected with metadata.skipReason) and explains the feedback loop to the brain. This goes beyond the bare minimum and is genuinely transparent about state changes and future 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 three sentences, each serving a purpose: stating the action, explaining the reason capture, and describing the effect. It is front-loaded and contains no filler.

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

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

The tool is simple (3 params, no output schema), and the description covers its purpose, side effects, and downstream usage. It does not address edge cases like invalid actionId, but given the low complexity, the description 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?

Schema description coverage is 100%, so each parameter already has a description. The tool description adds context for the 'reason' parameter with examples of appropriate reasons, but it doesn't significantly extend the meaning of actionId or workspaceId. 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 states a specific verb ('rejects') and resource ('next-move recommendation'), and clearly differentiates from sibling tools like approve or execute actions. It explicitly notes the action is not done and flips to rejected, leaving no ambiguity about its 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 clearly indicates when to use the tool: when a founder rejects a next-move recommendation. It explains the downstream effect on the generator, which implies the value of capturing reasons. However, it doesn't explicitly name alternatives or state when not to use it, though the context is 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?

No annotations are provided, so the description carries the full burden. It discloses that ChiefLab is 'stateful and re-summonable' and can recover state even after lost conversations or IDE switches. It also details the aggregation of multiple data types and the bootCard structure, providing useful behavioral context beyond a simple status fetch.

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 high-level label 'SESSION-RECOVERY · FIRST CALL' and then provides structured details. It is relatively dense but each sentence contributes: return format, aggregated data, stateful recovery, and a usage decision. No word is wasted, though the length could be trimmed slightly without losing 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?

With no output schema, the description compensates by describing the bootCard structure and its components (headline, priority, cards[], next). It also covers the aggregation list and recovery behavior, plus a decision rule for handling unrelated loops. For a status tool with this complexity, the description is sufficiently complete for an agent to invoke it 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 input schema already describes all three parameters with 100% coverage, so the baseline is 3. The description adds meaning by explaining how projectName and currentRepoContext factor into the recovery decision ('compare boot cards to currentRepoContext/projectName'). This enriches the semantic understanding beyond the schema alone.

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 explicitly identifies this as 'SESSION-RECOVERY · FIRST CALL' and specifies exactly what it returns (a bootCard with headline, priority, cards[], next). It distinguishes from siblings by positioning it as the first call to recover the workspace state. The verb 'recovers' and resource 'ChiefLab workspace business state' confirm a clear 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?

It provides explicit when-to-use guidance: 'FIRST CALL when a session starts and the user mentions launch / users / growth / customers / metrics / revenue / marketing / what next / shipping.' It also gives a when-not condition: 'if the open loop is unrelated, start a fresh launch instead of resuming stale work.' This goes beyond a basic context by offering a decision rule.

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

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

With no annotations, the description carries the full burden. It discloses that the tool is a pure-function with no LLM, deterministic (same input → same output), and lists the emitted suggestion structure. This is strong behavioral transparency, though it doesn't cover potential edge-case 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 front-loaded with the trigger condition, then output shape, purity, and companion tool reference. Every sentence provides necessary information for an agent; no redundant or filler content.

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

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

In the absence of an output schema, the description provides a detailed output structure including kind enum, priority, reasoning, draftBrief fields, and measurementGroundingFacts. It also covers when to use it, inputs, and purity, making it comprehensive for a 4-param nested-object 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 already documents all four parameters with descriptive text (runId's purpose, channel enum, metrics synonyms, workspaceId optional). The description only adds a high-level note about reading 'metrics + the original launch's brief', so it doesn't meaningfully expand 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 uses a specific verb+resource ('Next Move Engine') and explicitly states it reads metrics and the launch brief to emit a deterministic suggestion. It distinguishes from the sibling chieflab_create_next_move_action by noting the pairing for turning suggestions into approval-gated drafts.

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 includes a clear 'USE WHEN' condition: measurement just came in, either automatically via chieflab_post_launch_review at 24h or manual call. It also explicitly says to pair with chieflab_create_next_move_action, giving an alternative/next step.

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

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

With no annotations, the description must fully disclose behavior, and it does. It states the tool returns paste-ready content, checklist, measurement template, and optional upgradePath; that it converts a blocked channel into a human-in-the-loop ship; and crucially that the originating publishAction must be 'approved' before the brief is returned. This gives the agent a clear picture of prerequisites and outcomes.

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 longer than the ideal but every sentence carries substantive guidance. The 'USE WHEN' front-loading immediately sets context, and the later detailed return list is justified because no output schema exists. It is structured and dense rather than redundant, though it could be tightened slightly.

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, the lack of an output schema, and no annotations, the description is remarkably complete. It covers purpose, triggering conditions, channel distinctions, returns, prerequisite approval, and the relationship to provider setup. An agent has enough context to invoke and interpret 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%, so baseline is 3, but the description enriches parameters meaningfully. It explains actionId as coming from chiefmo_launch_product, specifies how to identify fetchable actions via blockedActions[] or manualFallback fields, and clarifies subreddit/discordCommunity tailoring. This goes beyond the schema's bare parameter labels.

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 'USE WHEN any launch action carries a manualFallback brief' and clearly defines the tool as fetching a fallback brief for blocked launch channels. It distinguishes the tool by detailing the exact conditions (manual-only channels vs. unwired automated providers) and the concrete deliverables returned, so it is unambiguous and differentiated from siblings.

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

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

The description provides explicit and context-rich usage guidance: when to use (any action with a manualFallback brief), what type of channels qualify, and the pattern of using the fallback now while connecting the provider later. It lacks an explicit 'do not use' statement or named sibling-tool alternative, so it falls short of a 5 but is far beyond minimal 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?

Despite no annotations, the description discloses the full return shape, defines toolsDiscovered, instructs pasting the summary verbatim, and explains the nextStep behavior when ok is false. This is rich behavioral transparency beyond minimal requirements.

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

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

The description is front-loaded with 'POST-INSTALL HEALTH CHECK' and each sentence earns its place: call timing, return fields, semantic clarification, usage instruction, and failure recovery. It is detailed but not bloated.

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

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

With no output schema and no annotations, the description compensates by specifying all return fields, defining toolsDiscovered, dictating the summary handling, and covering the failure path with nextStep. It is fully complete for an agent to invoke and consume 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 sole optional parameter workspaceId is fully described in the schema ('Optional workspace id; inferred from bearer auth.') with 100% schema coverage. The description adds no additional parameter-specific meaning, 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 opens with 'POST-INSTALL HEALTH CHECK,' giving a specific verb and resource. It further states 'Call this exactly once after the agent has wired ChiefLab into the runtime,' clearly distinguishing this from sibling tools like chieflab_status and chieflab_connector_status.

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

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

Usage is explicitly constrained: 'Call this exactly once after the agent has wired ChiefLab into the runtime' with a link to the bootstrap protocol. It also instructs 'Do NOT list every internal tool — render the summary only,' providing clear behavioral guidelines.

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