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

No annotations are provided, so the description carries the full disclosure burden — and it does substantial work: it reveals git worktree isolation "branching from cwd," post-run checks semantics, memory persistence modes (auto infers an opaque Git checkout identity, explicit requires memory_project, off disables memory), and the privacy guarantee that "Raw prompts are never stored in memory." It also discloses the handoff constraint requiring "a configured, provider-specific quota signature" to rotate agents. Material behaviors remain undisclosed — notably what write=false vs true controls and how background dispatch behaves — so it is strong but not exhaustive.

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?

Tight prose blocks each cover a distinct concern — purpose, agent selection, worktree isolation, checks, memory, on_limit — with the core purpose front-loaded in the first sentence. The length (roughly 150 words) is justified by 16 parameters and zero schema descriptions, and there are no filler sentences. A bulleted layout would improve scannability, but nothing here is wasted.

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

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

The output schema relieves the return-value burden, and the description covers the most behaviorally complex parameters well. But for a 16-parameter tool with no annotations and 0% schema coverage, key semantics are still missing: the default on_limit='stop' behavior, what the write flag controls, background/async execution semantics, and effort/model/agent_name overrides. The description is adequate for an expert caller but incomplete for an agent that must reason correctly about all 16 fields.

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

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

Schema description coverage is 0%, so the description must compensate, and it does for the least obvious parameters: agent selection with capability-based auto default, required_capabilities, exclude_agents, memory_mode with its auto/explicit/off semantics, memory_project overrides, worktree isolation, checks as post-run shell commands, and the on_limit handoff path. However, several parameters (background, write, effort, model, agent_name, prompt) receive no clarification, leaving gaps an agent must infer from parameter names 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 opens with a specific verb+resource+target: "Delegate a task to a headless CLI agent or role." The 'headless' qualifier differentiates this execution-side dispatching from contextual siblings like route_task and the memory tools, though no sibling is named explicitly in the purpose statement. The rest of the description reinforces the purpose by explaining how automatic agent selection delegates to installed workers.

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

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

Gives concrete when-to conditions: pass required_capabilities "when the orchestrator already knows what the task needs," use exclude_agents to keep the human-facing orchestrator out of the worker pool, and opt into on_limit='handoff' only with worktree=True. It also directs the caller to "read their outcome with job_review before spending anything on the job's output," which is a useful follow-up pointer. It never names an alternative tool to choose instead (such as preferring route_task for routing-only decisions), so it stops short of explicit when-not guidance.

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

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

No annotations are provided, so the description must carry the full behavioral disclosure burden. It only lists operation names and does not reveal whether publish persists events, whether poll consumes them, whether subscribe creates a durable subscription, or what ordering and acknowledgement guarantees exist.

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 sentence is concise and front-loaded with the resource, containing no wasteful phrasing. However, for an eight-parameter tool with no annotations, this brevity borders on under-specification and omits operation-critical 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?

Although an output schema reduces the need to document return values, the description is still too sparse for a stateful event bus with required `agent_name`, optional `payload`, and sequence-based polling fields. An agent cannot reliably construct a correct invocation without guessing action values or parameter groupings.

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 text needed to explain the eight parameters, but it only hints at `action` values via 'publish, poll, subscribe'. Parameters such as `since_seq`, `event_types`, `correlation_id`, and `limit` are not linked to any operation mode or given a semantic role.

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

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

The description identifies the resource ('Event bus') and names three concrete operations: publish, poll, and subscribe. This is clear and distinguishes the tool from unrelated siblings, though it does not explicitly state that the required `action` parameter selects among these operations.

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

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

There is no guidance on when to use this tool rather than a sibling, nor when to choose publish versus poll versus subscribe. The event-bus framing implies a general use case, but the agent is left to infer the trigger conditions and 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?

The word 'Read' implies a non-mutating operation, and there are no annotations to contradict that, but the description does not disclose return format, error behavior, or whether any side effects occur. Since no annotations are present, the description alone carries this 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 two short sentences and gets to the point quickly. No unnecessary detail 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?

For a simple read operation, the description is mostly sufficient, but it omits parameter semantics and does not mention what the response contains. This leaves minor but real gaps for a caller.

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

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

The schema has one parameter, agent_name, but the description does not explain its meaning or expected values. The title and default value provide only minimal hints, leaving the parameter underspecified.

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

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

States a specific action ('Read automatic delegation policy') and identifies the resource, so the core purpose is clear. The phrase 'or offer it' is slightly ambiguous but does not obscure the main function.

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 a usage cue ('Call when deciding whether to delegate or offer it') but does not explicitly state when not to use it or name alternative tools. Sibling tools like delegate_task and route_task exist, yet the description does not contrast with them.

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 carry behavioral disclosure. It reveals the offline-first behavior and optional remote pull. However, it does not state whether the tool modifies local state, what happens on error (beyond returning local data), or any permission or side effects.

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

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

Two sentences with no filler. The first sentence states the primary action, and the second adds a critical qualifier. Every word is meaningful and front-loaded.

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

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

Given the presence of an output schema (which presumably documents return values), the description covers the essential behavior and key constraints. It is sufficient for an agent to understand the tool's role, though terms like 'local session state' and 'compiled truth' could be clarified further.

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%, so the description should compensate. It only hints at the 'refresh_remote' parameter ('Optionally pull remote truth first'), but provides no context for 'agent_name' or 'project_name'. Only one of three parameters receives any semantic value.

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

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

The description clearly states the tool loads local session state and compiled truth, with optional remote pull. The verb 'load' and resources 'session state' and 'compiled truth' are specific, and the offline-first behavior distinguishes it from related tools like pull_truth.

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

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

The description implies use for offline-first scenarios ('always returns local data') but does not explicitly state when to use this tool versus siblings like pull_truth or sync_offline_facts. No guidance on when not to use or prerequisites.

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

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

With no annotations, the description must carry the burden. 'Report' implies a read operation, and the listed outputs provide some transparency. However, it doesn't explicitly state read-only nature or potential side effects.

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

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

Single sentence with no redundant words. Efficiently communicates the key report contents.

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?

Although an output schema exists, the description lacks important context about parameter purpose and usage scenarios. For a simple health tool, it is incomplete, especially given the lack of annotations.

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

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

Schema description coverage is 0%, and the description fails to explain the 'agent_name' parameter. Its default 'system' suggests filtering, but no such explanation is given, leaving the agent without guidance on parameter usage.

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 reports health metrics: 'local paths, queue depth, and remote reachability.' The verb 'Report' and specific resources make the purpose unambiguous and distinct 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?

No guidance on when to use this tool versus alternatives like get_sync_context or queue_durable_fact. No context about prerequisites or intended scenarios.

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 behavioral disclosure. It does not explain whether 'cancel' is destructive, whether 'wait' blocks or requires a timeout, whether 'status' and 'result' are read-only, or what side effects any action may have. The word 'lifecycle' hints at state changes, but concrete behavioral details are missing.

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

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

The description is extremely short and front-loads the resource and action names, which is efficient. However, the brevity crosses into under-specification for a tool with multiple parameterized actions. It is concise but not sufficiently informative for the complexity of the tool.

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

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

For a tool with five parameters, no annotations, no parameter descriptions, and no action enum, this description is materially incomplete. An output schema exists but does not compensate for the missing guidance on how to invoke each action and which parameters are relevant. The agent would need outside knowledge to use this tool reliably.

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

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

Schema coverage is 0% and the description does not map the five parameters to their purpose or to specific actions. While the description implies that 'action' accepts values like status/wait/result/review/cancel, it does not explain how job_id, agent_name, timeout_seconds, or poll_interval_seconds should be used across those actions. The agent cannot reliably construct a valid call without additional inference.

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

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

The description identifies the resource ('job') and enumerates the operations it supports ('status, wait, result, review, or cancel'), making it clear this is a job lifecycle tool. It does not explicitly state a single verb like 'manage' or 'retrieve', but the action list communicates the tool's scope effectively. It is differentiated from generic siblings by naming concrete job lifecycle actions.

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

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

No guidance is provided about when to use this tool versus alternatives such as 'list', 'events', or 'delegate_task'. The action list implies usage scenarios, but there is no explicit statement of prerequisites, when to choose a particular action, or when a sibling tool would be more appropriate.

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, but it merely labels the resource a 'catalog'. It does not state that the operation is read-only, what it returns, whether it filters by kind, or whether agent/agent_name alter the result. The read-only nature is only implied by the tool name.

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 very short and free of fluff, with a compact colon structure. However, it is so terse that it becomes under-specified rather than deliberately concise; there is no verb, no usage context, and no clarification of behavior.

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

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

Although an output schema exists so return values need not be described, the required 'kind' parameter is only loosely explained and the optional parameters are not addressed at all. With no annotations and a 0% schema description coverage, this description leaves too many practical calling details to inference.

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 needed to explain all parameters. 'Agents, models, or roles' gives some meaning to the required 'kind' parameter, but optional parameters 'agent' and 'agent_name' are left entirely unexplained. This only partially compensates for the schematic gap.

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

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

The tool name 'list' combined with 'Orchestrator catalog: agents, models, or roles' makes the primary purpose reasonably clear: list catalog entries scoped to these categories. It lacks an explicit verb and does not differentiate from siblings, so it stops short of a 5.

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

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

There is no guidance about when to use this tool versus siblings like get_orchestration_policy, route_task, or get_sync_context. The word 'catalog' hints at a read/listing use case, but no explicit conditions or exclusions are provided.

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

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

No annotations are provided, so the description carries the full burden. It discloses the prioritizing behavior ('open and recent sessions') but doesn't explain what happens with the budget_chars parameter, whether context is truncated, or what the return format looks like. The description provides minimal behavioral insight beyond a basic read 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 a single, concise sentence that is front-loaded with the main action and resource. It is appropriately sized, though it could include a brief note on budget_chars or usage without becoming 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?

Given the tool has an output schema (which likely describes the returned context) and simple parameters, the description is somewhat minimal. It doesn't explain what 'bounded' means or how budget_chars affects the result. For a tool that likely aggregates memory, more context about the scope and prioritization would help an agent 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?

Schema description coverage is 0%, so the description should compensate. The description does not mention any parameters, relying entirely on the schema. With 0% coverage, this is a gap, but the parameter names (agent_name, project_key, budget_chars) are fairly self-explanatory. The description adds no explanatory value for 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 states a clear verb ('Retrieve') and specific resource ('bounded project context'), with an explicit prioritization ('open and recent sessions'). It could be slightly more specific about what constitutes 'project context', but it is clearly distinguishable from siblings like get_sync_context or list_agents.

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

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

The description implies when to use this tool (when you need a bounded, prioritized view of project context) but does not explicitly state when not to use it or mention alternatives. Given the sibling tools like get_sync_context and pull_truth, there is no guidance to help an agent choose between them.

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. 'apply' and 'undo' reveal a mutation/rollback pair, and 'preview' suggests a dry-run, providing some transparency. However, it does not say what applying does to facts, whether undo is always available, or what side effects occur, which is concerning for a tool that can alter memory data.

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 efficient sentence, with the resource front-loaded and the action list immediately useful for the required `action` parameter. There is no fluff, and the structure is easy to parse. However, for a 10-parameter, title-less tool, the terseness borders on under-specification.

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

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

An output schema exists, so documenting return values is less critical, but the description still omits usage guidance, parameter semantics for most optional parameters, and side-effect behavior. The tool sits among many memory-related siblings, and the description does not provide enough for an agent to choose correct arguments confidently. The action list prevents it from being a 1.

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

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

Schema description coverage is 0%, and the only parameter meaning added is that `action` likely maps to preview/apply/undo/list. No guidance is provided for `fact_id`, `proposal_id`, `min_similarity`, `embedding_model`, `consolidation_model`, `status`, `limit`, or `project_key`. With ten parameters, most of the invocation surface is undocumented.

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

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

The description identifies the resource ('Fact consolidation') and lists the supported operations ('preview, apply, undo, or list'), making the tool's role clear. It is distinguishable from siblings like memory_recall because it is explicitly about consolidation rather than recall. It stops short of explaining what 'consolidation' actually does, so not a 5.

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

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

There is no explicit guidance on when to use this tool versus alternatives like memory_recall, pull_truth, or queue_durable_fact. The action list implies preview/list for inspection and apply/undo for mutation, but the description never states conditions, prerequisites, or exclusions. Usage must be inferred.

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

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

With no annotations provided, the description carries the full burden, and it offers exactly one behavioral trait: the embedding model is 'loopback-only,' implying local/offline inference rather than an external API call — a genuinely useful privacy/architecture disclosure. It does not state whether the operation is read-only, how min_similarity affects result filtering, what happens on no match, or latency/failure characteristics. The single trait earns some credit but far short of the burden for an unannotated 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?

A single front-loaded sentence with no filler — the verb 'Recall' leads immediately and every word contributes. The 'loopback-only embedding model' clause is compressed jargon that trades clarity for brevity, and the description is terse to the point of under-specification for a 6-parameter tool, so it is efficient but not perfectly calibrated.

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 6 parameters, 3 required, zero annotations, and 0% schema description coverage, a single sentence is not enough — the output schema covers return values, but parameter semantics and selection guidance are entirely absent. An agent would need sibling descriptions or trial-and-error to know how to populate agent_name, project_key, and min_similarity 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 0%, so the description must compensate by explaining the six parameters, but it names none of them. The phrase 'recall related project facts' only weakly implies that query is the lookup text and that results are scoped to project facts. agent_name, project_key, limit, model, and min_similarity remain semantically undefined in both the schema and the description.

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

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

States a specific verb and resource ('Recall related project facts') plus the method ('loopback-only embedding model'), making the semantic-search read intent clear. The embedding detail distinguishes it from write-style siblings like queue_durable_fact, sync_offline_facts, and memory_consolidation. However, it does not fully differentiate from read-style siblings like pull_truth, get_sync_context, or list, which could also plausibly return project facts.

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

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

There is no statement of when to use this tool versus any of the 15 siblings. Several siblings overlap in domain (memory_bootstrap, memory_consolidation, pull_truth, get_sync_context, list), and the description provides no selection criterion such as 'use for semantic similarity recall vs. enumerated listing' or 'do not use for writes.' An agent must infer the use case from the tool name alone.

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

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

With no annotations provided, the description must fully disclose behavior. It implies a read operation (pull from remote) but does not mention side effects, error conditions, or required permissions. Adequate but not thorough.

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

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

Description is a single, efficient sentence with no redundancy. Every word contributes meaning, making it highly concise.

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 simplicity (1 parameter, no nested objects, output schema present), the description provides minimal context. It does not explain what 'compiled-truth markdown' is or how it fits into the system, but it is not misleading.

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%. The single required parameter 'agent_name' is not described in the description, so the tool adds no semantic value beyond the schema. This is a significant gap.

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

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

The description clearly states the action (pull), the resource (compiled-truth markdown), and the direction (remote to local). It is specific and distinct from sibling tools which focus on sync, health, queuing, etc., but does not explicitly differentiate.

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

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

No guidance on when to use this tool versus alternatives like get_sync_context or sync_offline_facts. The description lacks any context about prerequisites or typical use cases.

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 the two modes of operation (remote write vs. local queue) and mentions later flush, but it lacks details on queue flush triggers, error handling, idempotency, or side effects. With no annotations, more transparency would be beneficial.

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

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

The description is extremely concise with one front-loaded sentence. While efficient, it sacrifices necessary detail on parameters and complex behavior, making it slightly under-specified.

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 complexity (5 parameters, conditional logic, no annotations, and 0% schema coverage), the description is incomplete. It lacks parameter definitions, output details, and offline queue behavior specifics, leaving significant gaps for an AI 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 description provides no information about the five parameters (agent_name, entity, attribute, text, confidence). With 0% schema description coverage, the agent has no guidance on how to fill these fields, making the tool hard to use correctly.

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: writing a durable fact with conditional behavior based on online status. It distinguishes from siblings like sync_offline_facts by specifying the remote vs. local queue logic, though it could contrast more explicitly.

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

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

The description implies when to use (when online, write remotely; when offline, queue locally), but it does not provide explicit guidance on when not to use or how it compares to alternatives like sync_offline_facts or direct writes.

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 behavioral disclosure burden. It clearly communicates that the tool is non-committal (preview only, no job launch), which is a key safety trait. Yet it omits other behavioral facets such as side effects (e.g., logging, state changes), authentication needs, or any rate limiting considerations.

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 sentence that front-loads the core action ('Preview automatic worker selection') and immediately qualifies the scope ('without launching a job'). Every word earns its place, with no 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?

Although the output schema exists, the description does not explain how the four input parameters influence worker selection or how to use this preview effectively. Given the presence of many sibling tools and no annotations, the description is too sparse to fully orient an agent, especially regarding parameter roles and expected behavior beyond the preview itself.

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 provides zero description coverage (0%) and the tool description offers no explanation of what each parameter does. The parameters 'prompt', 'agent_name', 'exclude_agents', and 'required_capabilities' remain opaque, leaving the agent with no semantic guidance for constructing valid 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 uses a specific verb ('Preview') and resource ('automatic worker selection'), immediately clarifying the tool's function. The qualifier 'without launching a job' strongly distinguishes it from delegation tasks, such as the sibling 'delegate_task', making the purpose unambiguous.

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

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

The phrase 'without launching a job' implies a preview-before-execution workflow, offering some contextual guidance. However, it does not explicitly name any alternative tools or state when to use this tool versus actually launching a job, leaving the routing decision partially inferred.

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, but it only names high-level actions. It does not disclose whether starting, checkpointing, or ending a session mutates or deletes state, whether operations are reversible, or what persistence guarantees exist.

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 economical, front-loaded, and free of filler. However, for a tool with 14 parameters, the single short clause is under-sized and omits critical operational 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 14-parameter tool with no annotations and 0% schema coverage, this description is far from complete. An agent cannot determine required parameter combinations per action, the lifecycle semantics, or the meaning of most optional fields.

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

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

Schema description coverage is 0%, so the description needs to compensate, but it only clarifies the `action` parameter by listing start/checkpoint/end values. The other 13 parameters, such as session_id, project_key, durable_facts, files_changed, and blockers, receive no semantic explanation.

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

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

The description identifies a specific resource, 'local memory session', and the lifecycle actions 'start, checkpoint, or end', so an agent can distinguish it from generic operations. It lacks an explicit contrast with sibling memory tools, so it falls just short of full differentiation.

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

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

The description gives no guidance on when to use this tool versus alternatives like memory_bootstrap, memory_recall, or memory_consolidation, nor does it explain when each action should be invoked. The action verbs imply a lifecycle, but no selection criteria are stated.

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 disclose behavioral traits. It indicates flushing (likely destructive to the queue) and optional consolidation, but does not explain side effects (e.g., deletion of local queue, network requirements, 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 single-sentence and concise, but it sacrifices completeness. It could be expanded without losing conciseness.

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

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

Given the presence of an output schema (not shown) and 2 parameters with 0% schema coverage, the description is far from complete. It fails to explain agent_name, consolidation details, or behavioral implications, leaving significant gaps for an AI 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 0%. The description only hints at the 'consolidate' parameter ('optionally consolidate'), but does not mention the required 'agent_name' parameter or explain its purpose. This is inadequate for tool usability.

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 flushes the offline queue to remote, with optional consolidation and pulling truth. It distinguishes from siblings like pull_truth (which likely pulls without flushing) and queue_durable_fact (which enqueues). However, the phrase 'consolidate + pull compiled truth' is somewhat vague.

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

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

No explicit guidance on when to use this tool versus alternatives like pull_truth or queue_durable_fact. No prerequisites or exclusions mentioned.

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 partially discloses the warning behavior but omits other important aspects such as irreversibility, permission requirements, error states, and what happens to existing focus data.

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, clear sentence that front-loads the primary action. However, it is somewhat under-specified; conciseness is achieved at the expense of completeness.

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 5 parameters (4 required) and no parameter descriptions, the description is far too sparse. While an output schema exists, the lack of parameter semantics and behavioral details leaves the agent underinformed.

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 contains 5 parameters with 0% schema description coverage, and the description provides no explanations for any parameter (e.g., what 'focus' is, structure of 'paths', constraints on 'agent_name'). An agent would have to guess parameter meaning.

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

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

The description clearly states the action ('Update this agent's focus') and the specific resource, including a unique behavior ('warn on overlaps with other non-stale agents'). This distinguishes it from sibling tools, which are mostly concerned with facts, events, and jobs.

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

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

No guidance is given on when to use this tool versus alternatives, nor are any preconditions or exclusion criteria mentioned. An agent must infer usage from the name and description alone.

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