arifOS — Constitutional AI Governance

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

No annotations are provided, yet the description omits critical behavioral details implied by the parameters: it does not explain what 'execution' means (given dry_run and allow_execution flags), what the risk tiers affect, or what distinguishes 'forge' from other modes. References to 'F11' and 'F13' in the auth_context schema are cryptic and unexplained.

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

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

The description is brief (two sentences/fragments), but wastes precious space on the cryptic '333_MIND' branding. Listing the modes duplicates information already present in the enum schema; this space could have been used for behavioral context or sibling differentiation. Acceptably concise but not value-optimized.

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 complex 10-parameter tool with nested objects, execution safety controls (risk_tier, allow_execution), and no output schema, the description is severely underspecified. It fails to explain return values, the safety model, or the operational semantics of the different modes, leaving critical gaps for an agent attempting to invoke this tool correctly.

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

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

Schema description coverage is 100%, establishing a baseline of 3. The description adds no semantic clarification beyond the schema (e.g., explaining the functional difference between 'reason', 'reflect', and 'forge' modes, or the relationship between dry_run and allow_execution), but the schema carries the descriptive burden 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?

States it is a 'Core reasoning and synthesis engine' and lists available modes, but the '333_MIND' prefix adds noise rather than clarity. Critically, it fails to distinguish this tool from siblings like 'code_engine', 'math_estimator', or 'search_tool', leaving ambiguity about when to prefer this general reasoning engine over specialized alternatives.

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

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

Lists the three modes ('reason', 'reflect', 'forge') but provides no guidance on when to use the tool itself versus its numerous siblings, nor when to select each specific mode. No prerequisites, exclusions, or 'when-not-to-use' guidance is provided despite the presence of execution controls (allow_execution, risk_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?

Without annotations, the description must carry full behavioral disclosure but fails significantly. While it notes 'probe' tests 'floors' (corroborated by schema references to F11/F13), it doesn't explain what 'floors' are, what constitutes a 'verdict', side effects of judging/holding, or the implications of 'Final authority'. The execution gating behavior (dry_run vs allow_execution) is undocumented in the description.

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

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

The description is brief and front-loaded with the cryptic '888_JUDGE:' prefix which wastes valuable explanatory space. While the mode list is efficiently presented, the lack of structure (no separation of purpose from capabilities) and reliance on domain jargon ('floors') without explanation reduces clarity.

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 10-parameter tool with nested objects, complex stateful concepts (floors F11/F13, continuity, sovereignty), and execution-gating capabilities, the single-sentence description is grossly inadequate. It omits the behavioral model, return value characteristics, and the critical relationship between modes, payload fields, and the 'floor' architecture.

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

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

With 100% schema description coverage, the baseline is 3. The description adds minor value by mapping 'probe' to 'test floors', but provides no additional semantic context for the complex payload structure, mode-specific requirements (which payload fields apply to which mode), or the risk_tier parameter's impact on behavior.

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 tool as a 'Final authority for verdicts and defense' and lists available modes (judge, rules, validate, etc.), giving a vague sense of governance/security functionality. However, terms like 'verdicts' and 'defense' are abstract without domain context, and the '888_JUDGE:' prefix is noise that doesn't clarify purpose or differentiate from siblings like 'arifOS_kernel' or 'vault_ledger'.

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 enumerates modes but provides no guidance on when to use specific modes versus others, nor does it explain prerequisites (e.g., when 'allow_execution' should be true vs false). There is no mention of alternatives or exclusion criteria.

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

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

With no annotations provided, the description fails to disclose critical behavioral traits: whether modes are idempotent, what 'dry_run' and 'allow_execution' imply about state mutation, what 'risk_tier' controls, or the security model behind 'auth_context'. The presence of execution flags suggests destructive capabilities that remain undocumented.

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

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

Extremely concise at one sentence plus a mode list. Information density is high but results in under-specification for a 10-parameter multi-mode tool. No redundant or filler text, though the brevity compromises 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?

Inadequate for a complex tool with nested objects, 7 distinct modes, risk management ('risk_tier'), and execution control ('allow_execution'). No output schema is present, yet the description doesn't explain return values, success/failure modes, or side effects. The 'F11' and 'F13' references in auth_context suggest domain-specific concepts that are completely unexplained.

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 (meeting baseline), though the 'mode' parameter description is tautological ('Mode selector'). The tool description lists the valid mode values but does not explain their semantics or the payload structure variations required for each mode. It neither compensates for schema weaknesses nor adds usage context beyond enumeration.

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 domain ('Tool and resource discovery + Model Registry') and lists the seven operational modes, but fails to explain what the tool actually does in each mode or how these modes relate to the core purpose. It uses noun phrases rather than specific verbs (e.g., 'register' vs 'Registers a 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?

No guidance provided on when to use this tool versus siblings like 'search_tool', 'vault_ledger', or 'engineering_memory'. No criteria for selecting between the seven modes (e.g., when to use 'model_profile' vs 'model_catalog').

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

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

Annotations provide clear hints: readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=false. The description does not contradict these annotations, as 'Run... check' aligns with a read-only, non-destructive operation. However, it adds minimal context beyond annotations—it mentions 'conformance check' but does not disclose behavioral traits like what the check entails, potential side effects, or rate limits. With annotations covering safety, the description adds some value but lacks depth.

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: 'Maintainer: Run substrate protocol conformance check.' It is front-loaded with the action and avoids unnecessary words. However, the 'Maintainer:' prefix adds minor noise without clarifying the tool's function, slightly reducing 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 tool's complexity (implied by 'substrate protocol' and diagnostic nature), lack of output schema, and low parameter schema coverage, the description is incomplete. It does not explain what the conformance check involves, what results to expect, or how to interpret the 'session_id' parameter. With annotations providing safety hints but no output details, the description should offer more context for effective 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?

The input schema has one parameter ('session_id') with 0% description coverage, meaning the schema provides no semantic details. The description does not mention any parameters or add meaning beyond the schema. For a tool with low schema coverage, the description fails to compensate, leaving the parameter's purpose and usage 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 'Run substrate protocol conformance check' restates the tool name 'arifos_diag_substrate' without adding specificity. It mentions a verb ('Run') and resource ('substrate protocol conformance check'), but fails to distinguish this tool from siblings like 'arifos_probe' or 'arifos_health', which might also perform diagnostic operations. The purpose remains vague about what 'substrate protocol' refers to or what 'conformance check' entails.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, context, or exclusions, and with many sibling tools (e.g., 'arifos_probe', 'arifos_health'), there is no indication of how this tool differs or when it should be selected. Usage is implied only by the generic action 'Run', offering no explicit when/when-not instructions.

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

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

Annotations indicate readOnlyHint=true, openWorldHint=true, idempotentHint=false, and destructiveHint=false, covering safety and idempotency. The description adds value by disclosing the 'F9 Anti-Hantu constitutional filtering' behavior, which modifies content retrieval, and mentions 'redact spiritual cosplay or hallucinatory consciousness claims,' providing context beyond annotations. However, it doesn't detail rate limits, auth needs, or error handling, leaving some behavioral traits uncovered.

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

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

The description is appropriately sized with two sentences that are front-loaded: the first states the core action, and the second adds filtering details. There's minimal waste, but it could be slightly more structured by explicitly separating purpose from behavioral notes. Overall, it's efficient and clear.

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 (fetching with filtering), annotations cover key behavioral aspects (read-only, open-world, non-idempotent, non-destructive), and an output schema exists, reducing the need for return value explanation. The description adds useful context about filtering, but it could benefit from more details on error cases or performance. For a tool with good annotations and output schema, it's mostly 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 67% (2 out of 3 parameters have descriptions). The description adds no specific parameter semantics beyond what the schema provides; it doesn't explain the 'url' parameter's format, 'max_length' implications, or 'session_id' purpose. With moderate schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate for gaps but doesn't detract either.

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 ('Retrieve raw content') and resource ('from a URL'), specifying the substrate ('via mcp_fetch substrate'). It distinguishes from siblings by mentioning 'F9 Anti-Hantu constitutional filtering,' but doesn't explicitly differentiate from other fetch-like tools if any exist in the sibling list. The purpose is specific but could be more distinct regarding 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?

No explicit guidance on when to use this tool versus alternatives is provided. The description mentions filtering for 'spiritual cosplay or hallucinatory consciousness claims,' which implies a context for content moderation, but it doesn't specify prerequisites, exclusions, or name alternative tools for different use cases. Usage is implied rather than clearly 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?

With no annotations provided, the description carries the full burden. It successfully discloses the authorization requirement (SEAL) and governance model ('Preserves separation of powers'), indicating this is part of a multi-step approval flow. However, it omits operational traits like destructiveness, async behavior, or execution guarantees.

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 dense sentences with zero waste. Front-loaded with the core action ('Issue signed execution manifest'), followed by constraint ('Requires judge SEAL'), and architectural context ('Preserves separation of powers'). Every sentence earns its place.

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

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

For an 8-parameter tool with nested objects and an output schema, the description is minimal but adequate. The existence of an output schema compensates for not describing return values, but the description could benefit from clarifying the distinct execution types (shell, vm, container) available in the action enum.

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 88%, establishing a baseline of 3. The description adds semantic value by linking 'judge SEAL' to the judge_verdict and judge_g_star parameters, but does not elaborate on the payload structure or constraints object beyond what the schema already provides.

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

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

The description uses specific verb 'Issue' and resource 'signed execution manifest to AF-FORGE substrate'. It distinguishes from sibling arifos.judge by requiring its 'SEAL' output as a prerequisite, though it could clarify what AF-FORGE specifically does compared to other siblings like heart/mind.

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 states the prerequisite 'Requires judge SEAL', which directly maps to the required parameter 'judge_verdict' and establishes dependency on the sibling arifos.judge tool. However, it lacks explicit 'when not to use' guidance or alternatives for when SEAL isn't available.

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

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

Annotations already indicate read-only, non-destructive, and open-world hints, covering safety and scope. The description adds valuable context beyond annotations by specifying 'F12-hardened' (implying enhanced security) and listing the exact resources retrieved (CPU, Memory, ZRAM, Disk), which helps the agent understand the tool's operational behavior and constraints without contradicting 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 highly concise and front-loaded, consisting of two efficient sentences that directly state the tool's function and access method without any wasted words. Every sentence earns its place by providing essential information about retrieval and security.

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 (telemetry retrieval with security hardening), rich annotations (read-only, open-world), and the presence of an output schema, the description is mostly complete. It specifies what resources are retrieved and the access context, but could benefit from more detail on parameter usage or error handling, though the output schema reduces the need for return value explanation.

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 low at 33%, with only the 'action' parameter having a description. The description does not add meaning beyond the schema, as it mentions no parameters or their semantics. However, with an output schema present, the burden is reduced, and the baseline of 3 is appropriate since the schema provides some documentation, but the description fails to compensate for the coverage 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 tool's purpose with specific verbs ('Retrieve') and resources ('CPU, Memory, ZRAM, and Disk utilization'), distinguishing it from siblings like 'arifos_fetch' or 'arifos_heart' by specifying telemetry retrieval. It explicitly mentions 'F12-hardened read-only access', which further clarifies its security context and operational scope.

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

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

The description provides clear context for usage ('F12-hardened read-only access') and implies it's for telemetry retrieval, but does not explicitly state when to use it versus alternatives like 'arifos_heart' or 'arifos_memory'. It lacks explicit exclusions or named alternatives, though the specificity in resources helps infer appropriate 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 provided, so description carries full disclosure burden. Mentions 'simulate consequences' and evaluation frameworks, indicating it models outcomes rather than executing actions. However, lacks details on statefulness implications of session_id, persistence, or output format despite having an output schema.

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

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

Extremely concise with zero redundancy. Two sentences cover purpose, mechanism, and evaluation criteria. Every token contributes to understanding the tool's scope.

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?

Has output schema (not shown but signaled), so return values needn't be described. However, cryptic references to 'F5, F6, F9' lack context, and session_id's purpose (continuity across calls?) is unexplained despite being stateful infrastructure. Sufficient for basic selection but leaves operational gaps.

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 only 33% (content described; mode and session_id undocumented). Description implies 'content' is the proposal to critique and connects 'simulate' to the mode enum, but provides no semantics for session_id or when to use 'critique' vs 'simulate'. Adds marginal value beyond the schema.

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

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

Defines core action (red-team/simulate/evaluate) and domain (ethical risks). Mentions specific evaluation criteria (F5, F6, F9). Distinguishes from siblings by focusing on ethical risk analysis, though doesn't explicitly contrast with 'judge' or 'mind' 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 explicit guidance on when to use 'critique' vs 'simulate' modes, or when to invoke 'heart' versus sibling tools like 'judge'. The description lists capabilities but offers no decision criteria 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?

Lacking annotations, the description hints at behavioral traits—'identity binding' implies persistent state changes, 'revoke' suggests destructive capability, and 'telemetry seed' implies logging initialization. However, it omits crucial details: persistence guarantees, failure modes, authentication requirements, and side effects of the destructive revoke mode.

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?

Information-dense two-sentence structure front-loads the primary purpose. Efficiently lists modes and elaborates on probe. However, the second sentence packs excessive technical detail that could benefit from slight expansion for clarity given 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?

Despite having an output schema (excusing return value description), the tool has 7 parameters, 6 modes, no annotations, and extremely poor schema coverage. The description inadequately covers the parameter space and operational complexity, particularly regarding mode-specific parameter requirements.

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

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

With only 14% schema coverage (only 'mode' described in schema), the description compensates minimally by expanding on probe mode functionality. However, it fails to document critical required parameters 'intent' (20k char string) and 'actor_id' (64 char string), leaving their semantics, formats, and validation requirements completely opaque.

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 specific action 'Initialize constitutional session' with key mechanisms 'identity binding' and 'telemetry seed', and enumerates six operational modes. However, uses domain-specific jargon ('constitutional', 'anchor validity') without context, and fails to distinguish from numerous siblings (arifos.forge, arifos.route, etc.).

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?

Lists available modes (init, revoke, refresh, etc.) and briefly describes probe mode functionality, but provides no guidance on when to use this tool versus the 14 sibling tools, nor when to select specific modes over others.

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 disclosure burden but offers only minimal behavioral context. It enumerates four possible output states but fails to define what SEAL, PARTIAL, VOID, or HOLD signify, whether outputs are mutually exclusive, or if the tool produces side effects like audit logging.

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

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

The description is efficiently structured with the purpose front-loaded and outputs listed in a second sentence. There is no redundancy or fluff. However, breverity crosses into under-specification given the tool's apparent complexity (4 parameters, nested objects, categorical domain).

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 an output schema (reducing the burden to explain return values), the description remains inadequate. It omits explanations for critical domain concepts ('constitutional'), output semantics, parameter relationships (how risk_tier affects verdicts), and behavioral side effects—significant gaps for a 4-parameter decision tool with nested structures.

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

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

Schema description coverage is 50% (candidate_action and telemetry are described; risk_tier and session_id are not). The description mentions no parameters whatsoever and fails to compensate for uncovered parameters like risk_tier, which clearly modulates verdict severity but lacks 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 uses domain-specific terminology ('constitutional verdict evaluation') and lists specific output categories (SEAL, PARTIAL, VOID, HOLD), which distinguishes it from siblings like forge, heart, or sense. However, 'constitutional' is jargon-heavy and unexplained, leaving the actual scope ambiguous without additional context.

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

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

The description provides absolutely no guidance on when to invoke this tool versus alternatives, prerequisites for use, or workflow positioning. Given the 'Final' modifier and categorical outputs, it likely serves as a terminal decision node, but this is not explicit.

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

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

No annotations provided, so the description carries full disclosure burden. It states requests are routed but fails to specify whether this triggers execution, returns tool selection metadata, modifies session state, or requires authentication.

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 short sentences achieve brevity, but include unhelpful jargon ('metabolic lane', 'rCore') that wastes space without clarifying behavior. The alias declaration is appropriately 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?

Acknowledges the alias relationship which is critical given both arifos.kernel and arifos_kernel exist as siblings, but leaves significant gaps in explaining the mode enum's purpose and the session_id's role despite having 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 low at 33%; only the 'request' parameter has a schema description ('Request to route'). The description adds no semantics for 'mode' (kernel/status enum) or 'session_id', and merely repeats the routing concept for 'request' without clarifying syntax or format.

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

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

Identifies the tool as an 'Alias for arifos.kernel' with a 'Route request' verb, which distinguishes it from specific functional siblings like arifos.forge. However, terms like 'metabolic lane' and 'rCore' are opaque jargon that obscure the actual execution 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?

Mentions routing 'based on risk and task type' which implies selection logic, but provides no explicit guidance on when to use this router versus direct invocation of siblings like arifos.forge or arifos.mind, nor when to use the underscore variant versus the dot variant.

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, yet description fails to disclose critical behavioral traits suggested by parameters: execution risks (risk_tier, allow_execution), reversible vs destructive operations (dry_run), or authentication requirements (auth_context). '000-999 pipe' is unexplained jargon.

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?

Extremely brief (one sentence), but inefficiently structured. Opens with cryptic label '444_ROUTER' and uses unexplained jargon ('metabolic', '000-999 pipe') that obscures rather than clarifies.

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?

Inadequate for tool complexity: 10 parameters including execution controls (risk_tier, allow_execution), nested payload objects, and no output schema. Description's vague metaphors insufficiently explain what the tool actually returns or how it handles the 'critical' risk tier.

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%, providing clear documentation for all 10 parameters including nested payload objects. Description mentions modes but adds no semantic meaning beyond the schema enums; baseline 3 applies per rubric.

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

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

States the tool processes 'complex queries' and lists two modes ('kernel' for reasoning, 'status' for vitals), but relies on opaque metaphors ('metabolic conductor', '000-999 pipe') that don't clarify actual function. Fails to differentiate from siblings like agi_reason or agi_mind.

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 no guidance on when to use 'kernel' versus 'status' mode, nor when to choose this tool over sibling reasoning tools (agi_reason, apex_soul, etc.). No prerequisites or alternative suggestions 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?

With no annotations provided, the description carries the full burden but discloses minimal behavioral traits. While 'vector store' hints at semantic search and 'governed' implies access controls, it fails to explain failure modes, result ranking, or what 'governed' specifically entails (permissions, privacy scopes, versioning).

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 of nine words is appropriately front-loaded with the verb. However, given the complexity (3 parameters, 4-mode enum, no annotations), it may be excessively terse rather than efficiently concise—critical configuration details are omitted.

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

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

Despite having an output schema (covering return values), the description is incomplete for a retrieval tool with complex configuration. It lacks essential context for the 'mode' parameter variations and does not clarify how this integrates with the broader arifos ecosystem.

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

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

Schema description coverage is only 33% (only 'query' described). The description does not compensate: it fails to explain the four distinct 'mode' enum values ('vector_query' vs 'query' vs 'engineer'), nor the purpose of 'session_id', creating significant ambiguity for required configuration.

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?

Provides specific verb 'Retrieve' and clear resource 'governed memory and engineering context' from 'vector store'. However, it does not differentiate from sibling tools like 'arifos.memory' or 'arifos.vault', leaving ambiguity about which memory tool to select.

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?

Contains no guidance on when to use this tool versus alternatives (e.g., arifos.mind, arifos.vault) or prerequisites. The description states what it does but not why or when an agent should invoke it.

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

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

With no annotations provided, the description carries the full burden. It discloses 'uncertainty bands' as an output characteristic and 'multi-source' as an input pattern, but omits critical behavioral details: whether session_id enables persistent state across calls, side effects on arifos_memory/vault, or the functional differences between the three modes.

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

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

Single dense sentence with no filler. However, the heavy jargon ('first-principles', 'uncertainty bands') packed into one statement sacrifices clarity for brevity. Information is front-loaded but requires domain inference to parse.

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

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

Despite having an output schema (reducing description burden for returns), the tool has significant complexity: 4 parameters including a 3-value behavioral mode switch and session management. The description inadequately covers these mechanics, leaving the agent to guess how modes differ or how sessions persist.

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% (2/4 parameters described). The description does not compensate for undocumented parameters: it fails to explain what session_id tracks or how the mode enum values (reason/reflect/forge) alter behavior. It loosely maps 'reasoning' to the query parameter but adds no syntax guidance.

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 the tool performs 'Multi-source synthesis and structured first-principles reasoning,' which identifies the verb (synthesis/reasoning) and methodology. However, it remains abstract ('first-principles') and fails to distinguish from siblings like 'arifos_forge' despite 'forge' being one of the mode options, creating potential confusion about 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?

The description provides no guidance on when to use this tool versus siblings (e.g., arifos_sense, arifos_judge) or when to select specific modes (reason vs. reflect vs. forge). No prerequisites, exclusions, or contextual triggers are 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, placing full burden on the description. While 'Calculate' suggests a read-only/transformative operation, the description fails to disclose whether results are cached, if the operation is idempotent, computational costs, or what the entropy analysis entails behaviorally.

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 zero waste. Front-loaded with verb 'Calculate' and efficiently lists the four calculation domains covered. 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?

Despite having an output schema (reducing description burden for return values), the tool lacks annotations and the description omits behavioral details for a complex domain (thermodynamics/entropy). With 3 parameters and only 33% schema coverage, the description should provide more context to be 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 only 33% (1 of 3 parameters described). The description mentions 'entropy analysis' and 'costs' which map to mode enum values, but doesn't explain the parameter structure, session_id requirements, or that mode selects calculation type. Insufficient compensation for poor schema 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 lists specific calculation targets (costs, thermodynamics, capacity, timing) and mentions entropy analysis, providing clear verbs and resources. However, it fails to differentiate from the numerous arifos_* siblings (forge, heart, judge, etc.), leaving the agent uncertain which tool handles which aspect of the system.

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 provided on when to use this tool versus siblings like arifos_forge or arifos_judge. No mention of when to select specific modes (cost, health, vitals, entropy) or prerequisites for the session_id parameter.

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

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

The annotations already indicate the tool is read-only, non-destructive, and idempotent, which covers key behavioral traits. The description adds value by specifying the types of probes (status, health, metrics) and components (system, memory, vault), providing context beyond the annotations. No contradiction with annotations is present.

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 that front-loads the core purpose with no wasted words. It uses parentheses to include examples without cluttering the main statement, making it highly concise and well-structured.

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

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

Given that the tool has annotations covering safety (read-only, non-destructive) and an output schema exists (which handles return values), the description is reasonably complete. It specifies the probe types and components, but could benefit from more detail on usage context or parameter interactions, though not strictly required due to the structured data.

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 low at 33%, with only one parameter ('target') having a description. The description mentions 'system status or component health' and examples like 'system, memory, vault', which partially clarifies the 'target' parameter but does not address 'probe_type' or 'timeout_ms'. This adds some meaning but does not fully compensate for the coverage gap, aligning with the 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's purpose with a specific verb ('probe') and resource ('system status or component health'), and it provides examples of components (system, memory, vault). However, it does not explicitly differentiate from sibling tools like 'arifos_health' or 'arifos_diag_substrate', which might have overlapping functions, so it falls short of a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as the sibling tools 'arifos_health' or 'arifos_diag_substrate'. It lacks explicit when-to-use or when-not-to-use instructions, leaving the agent to infer usage from the purpose 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?

Annotations provide readOnlyHint=true and destructiveHint=false, indicating a safe operation. The description adds valuable behavioral context beyond annotations: it discloses the internal pipeline stages (memory → sense → mind → heart → ops → judge → [vault/forge]), output envelope types, mandatory output components (TO/CC/TITLE/KEY_CONTEXT header, RACI block, etc.), and specific constraints (888 HOLD blocks forge, F1/F13 triggers require human ratification). This significantly enhances understanding of the tool's 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 information-dense but somewhat verbose and technical. Sentences like 'Composite orchestrator for AGI Reply Protocol v3' and 'Every output includes: TO/CC/TITLE/KEY_CONTEXT header...' are front-loaded and efficient. However, phrases like '888 HOLD blocks forge' and references to external schemas could be clearer, reducing overall conciseness.

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

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

Given the tool's complexity (11 parameters, internal pipeline, multiple outputs) and the presence of annotations and an output schema, the description provides substantial context. It covers the orchestration process, output formats, and key constraints. While it doesn't explain every parameter detail, the combination with structured data makes it largely complete for informed usage.

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

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

With 73% schema description coverage, the schema documents most parameters well. The description adds semantic context by referencing 'session state at arifos://reply/context-pack,' which clarifies the purpose of session_id and prior_state parameters. It also implies depth levels affect processing, though it doesn't detail parameter interactions. This compensates adequately for the schema's gaps.

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 as a 'composite orchestrator for AGI Reply Protocol v3' that runs an internal pipeline and emits specific envelope types. It distinguishes itself from siblings by focusing on orchestration rather than individual components like arifos_memory or arifos_sense. However, it doesn't explicitly contrast with other composite tools like agi_mind or apex_soul.

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

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

The description implies usage context through mentions of 'Session state at arifos://reply/context-pack' and 'F1/F13 triggers require human:arif ratification,' suggesting it's for session-based interactions with human oversight. However, it lacks explicit guidance on when to use this tool versus alternatives like agi_mind or arifos_forge, and doesn't specify prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, covering safety and scope. The description adds valuable context about 'constitutional path whitelisting' which suggests security/access restrictions beyond what annotations provide, though it doesn't detail rate limits or specific behavioral traits like output format.

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 that front-loads the core functionality ('Check git status, diffs, and log') and adds important constraint information ('with constitutional path whitelisting'). 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?

Given the tool has annotations covering read-only/non-destructive behavior and an output schema exists, the description provides adequate context about what the tool does and its security constraints. However, it could benefit from more explicit guidance on when to use it versus sibling tools for a more complete picture.

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

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

With 0% schema description coverage for the single parameter 'path', the description doesn't add any parameter-specific information beyond what's implied by 'constitutional path whitelisting'. The baseline is 3 since schema coverage is low but the tool has only one parameter with a default value, making it manageable.

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 specific verbs ('Check git status, diffs, and log') and identifies the resource (git repository). It distinguishes from siblings like 'arifos_repo_seal' by focusing on read operations, but doesn't explicitly contrast with other repo tools like 'arifos_fetch' or 'arifos_forge'.

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

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

The description implies usage for git repository inspection with 'constitutional path whitelisting' suggesting security constraints, but doesn't explicitly state when to use this tool versus alternatives like 'arifos_repo_seal' or other git-related siblings. No clear exclusions or prerequisites are provided.

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