decker

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

With no annotations, the description carries the behavioral disclosure burden. It explains the tool's deterministic nature, how timeframes interact ('Upper TF supplies the target... lower TF supplies the entry'), and the important behavioral rule not to re-decide coordinates. It does not describe data freshness, error cases, or performance constraints, but provides substantial transparency for a decision-making tool.

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

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

The description is front-loaded with the core purpose and then enumerates the output fields in a structured way. It is dense but every sentence contributes meaningful information; however, the long third sentence with many listed elements could be slightly more scannable, so a small deduction is warranted.

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 no output schema is present, the description effectively conveys the return value structure by listing all verdict components (direction, grade with enum values, entry with source TF, stop, target, RR, switch coordinate). It also clarifies the symbol omission behavior. This is complete enough for an agent to use the tool correctly without additional context.

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

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

The schema already provides full coverage of the sole parameter 'symbol', including optionality and alias examples. The description adds only the detail about '14 universe symbols', which is marginally useful but largely redundant with the schema. Therefore, the description does not significantly enhance the parameter semantics beyond what the schema already provides.

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

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

The description clearly states the tool's purpose: 'Multi-timeframe optimal-path assembly per symbol' producing a deterministic machine verdict with a defined set of outputs (direction, grade, entry, stop, target, RR). It distinguishes itself from sibling tools by declaring itself 'the single judgment authority' and instructing to 'not re-decide coordinates', making its role unique.

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

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

The description gives explicit usage context: it is the final judgment authority to be narrated or filtered, and it specifies how to handle the symbol parameter ('Omit symbol for all 14 universe symbols'). It does not explicitly name alternative tools or when not to use it, but the 'single judgment authority' phrasing strongly implies the appropriate use case.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool reads persisted engine emits as-is with zero recompute, that absent fields are null (no filling), and that it returns engine-native vocabulary rather than customer-facing prose. This provides significant transparency about the tool's behavior and limitations.

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 verbose, with a long 'DOMAIN FRAME' section explaining the target-game concept before the tool's actual contract. While informative, it is not concise and requires the agent to parse a large amount of text to extract the essential operational details. The length is not commensurate with the tool's simple parameterization.

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

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

With no output schema, the description compensates by explaining key return fields (game.status, game.target, etc.) and the meaning of action_gate. It also covers null behavior and defines the layer distinction. Although it might descend into excessive domain detail, it covers the essential interpretive context well for a complex tool.

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

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

The description mentions 'for a symbol/timeframe' but adds little beyond the schema's existing parameter info. The schema covers 50% with a symbol example and an enum for timeframe. The description does not elaborate on parameter formats, constraints, or how they affect the response, so it does not significantly enhance schema understanding.

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

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

The description states a clear purpose: retrieving the current engine structural state for a symbol/timeframe, with details like 'latest evaluated bar, persisted engine emit read as-is'. It also distinguishes from siblings by explicitly naming decker.get_view and decker.get_reading as alternatives for human-language views, and decker.validate_intent for order intent.

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

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

Provides explicit alternatives: 'for a human-language view use decker.get_view (with tf) or decker.get_reading' and advises checking intent with decker.validate_intent before orders. It also clarifies that this tool is a market-state reading, not a trade instruction, indicating when it should not be used.

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

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

With no annotations, the description carries the full burden. It discloses that output is in customer-facing language and explicitly states what is NOT exposed (raw fields), which is a key behavioral trait. It doesn't mention side effects or auth, but the read-only nature is implicit and the primary behavioral disclosure is sufficient.

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

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

Two sentences, front-loaded with the main purpose, and every sentence earns its place. The structure is 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?

Despite no output schema, the description lists the exact output components and explains the boundary of what's included. It also directs users to alternative sources for raw data, making the tool's scope fully understandable.

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 67% with descriptions for symbol and include_tfs, and an enum for tf. The description adds context like 'symbol/timeframe' and 'MTF verdict per timeframe', which indirectly maps to parameters but doesn't enrich them significantly. It meets the baseline for moderate schema coverage.

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

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

The description clearly states the tool provides an AI-synthesized market reading for a symbol/timeframe in customer-facing language, listing specific output components. It distinguishes itself from siblings by explicitly noting that engine-native raw fields are not exposed, pointing to alternatives.

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

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

The description gives explicit guidance: use this tool for synthesized, customer-facing readings, and use the REST raw contract or decker.get_market_state when raw fields are needed. This effectively separates it from alternatives.

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

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

With no annotations provided, the description fully carries the transparency burden. It discloses key behaviors: Skill Overlay affects displayed coordinates, risk_reward_ratio is computed on displayed coordinates, turn-retention policy retains aged signals, and action_gate is a stance not an order command. This is rich, non-obvious context that helps avoid misuse.

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 densely packed with essential caveats, and each sentence earns its place. It is front-loaded with the core purpose, then elaborates on output shape, risk_reward caveat, retention policy, filters, and safety guard. While slightly lengthy, the complexity justifies the length.

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

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

Despite no output schema and no annotations, the description covers the output shape, key fields, filters, freshness handling, retention policy, overlay effects, and a cross-tool safety reference to validate_intent. This is sufficient context for an agent to invoke the tool correctly and interpret results.

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

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

Schema descriptions already cover 80% of parameters (symbols, timeframe, action_gate, min_progress) with meaningful semantics. The description adds no new parameter-level detail; it only restates filter names and adds context about overlay affecting displayed coordinates, which relates more to output than to parameter syntax. Baseline 3 is appropriate.

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

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

The description explicitly states the tool returns 'Active trading signals for the current user (with Skill Overlay applied)', enumerates the key output fields, and clearly distinguishes it from sibling tools like get_view or get_market_state by focusing on signals, freshness, and intent validation.

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

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

Provides explicit when-to-use guidance: it instructs to 'check the intent with decker.validate_intent' before placing orders, and advises reading freshness_state before treating aged PENDING rows as current. Also mentions filtering options (symbols/min_progress/action_gate), giving clear operational context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It transparently explains that bars are ascending by bar_ts, that gaps are honest (absent bars, no filling), and that each item carries a slim game tag rather than the full game block. It also indicates the tool is a read operation (no side effects implied). It does not mention pagination or error behavior, but these are less critical for a read-only timeline. No contradiction with annotations (none provided).

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

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

The description is a single dense sentence but well-structured: main purpose first, then schema difference, then intent, then ordering and gap behavior. Every clause carries meaning; no fluff. It could be split into two sentences for readability, but it earns its length.

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

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

The tool has no output schema, so the description must convey the response shape and semantics. It references the sibling's schema and clarifies the divergence (slim game tag), explains ordering, gaps, and the transition history use case. It doesn't explicitly define the time range covered or how 'limit' interacts with 'since', but for a timeline tool this is largely self-evident. Given the complexity, it is reasonably complete.

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

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

Schema description coverage is 50% (symbol and timeframe have descriptions). The description does not add new parameter-specific semantics; it merely mentions bar_ts ordering, which relates to the 'since' parameter but doesn't go beyond the schema's own description of 'ISO8601 lower bound on bar_ts'. It doesn't explain 'limit' beyond the schema defaults/constraints. This is adequate given partial schema coverage, but not exemplary.

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

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

The description clearly states the tool provides a per-bar state timeline for a symbol/timeframe, with a specific comparison to decker.get_market_state (slim game tag vs full block). It names the exact use case: reading status transitions across bars (forming → testing → resolved/failed). This distinguishes it from siblings, especially get_market_state.

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 the per-bar timeline with slim game tags to trace game progression, versus get_market_state which likely returns the full game block for a single state. It does not explicitly say 'use this instead of X when...', but the contrast with the sibling and the stated purpose provide clear context. Missing explicit exclusions, but adequate.

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

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

The description discloses the return content (3 base skills and selected one) which is helpful. However, it does not mention side effects, read-only nature, or behavior when no skill is selected. Since no annotations are provided, the description carries the transparency burden and only partially fulfills it.

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

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

The description is two concise sentences, front-loaded with the tool's purpose and directly naming the three expected skill IDs. No filler or redundant phrasing. It earns its place with specific details.

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 simple nature (no parameters, no output schema), the description is fairly complete. It names the exact return items and clarifies the 'catalog + overlay' structure. However, it could be slightly more complete by noting whether the selected skill can be null or how to handle multiple users, but for this simple getter it is adequate.

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

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

There are no parameters, so the schema fully covers parameter information. The description adds meaning by explaining what the tool returns (the skill catalog and active overlay), which compensates for the lack of parameters. The baseline for zero parameters is 4, and no further parameter detail is needed.

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

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

The description clearly states what the tool returns: the trading skill catalog and the user's currently active overlay, including the three named base skills. It distinguishes from sibling tools by explicitly scoping to 'this user' and mentioning the active overlay, which sets it apart from other getters and the setter 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?

Usage context is implied: it is for retrieving a specific user's skills. However, it does not explicitly state when to use it over alternatives (e.g., set_skill_overlay) or provide any exclusion criteria. No exclusions or alternative recommendations are given.

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

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

With no annotations provided, the description carries the full burden. It discloses the operational nature (market-state reading, not a trade instruction), the deterministic composition ('single composer, verbatim'), and outlines the returned content. It lacks explicit safety traits like 'read-only' but strongly implies it. Minor gaps include no mention of auth or side effects, but the intent is clear.

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

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

The description is information-dense, with a clear front-loaded definition of the tool's core purpose, a brief enumeration of contained elements, and then usage guidance. While somewhat long, each sentence earns its place, and the structure is logical rather than rambling.

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 lacking an output schema and annotations, the description thoroughly describes what the tool returns (overall verdict, alignment, narrative, coordinates, receipts) and explains its relationship to other tools. It also provides essential context about the returned card equaling the daily briefing, making it complete for an agent to select and use.

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

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

Schema description coverage is 100%, with both symbol and tf having detailed descriptions including enums and examples. The tool's description adds no additional parameter-level detail beyond that in the schema. Since the schema already provides rich semantics, a baseline of 3 is appropriate.

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

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

The description opens with 'The engine's VIEW for a symbol', clearly identifying the resource (symbol view) and the verb (get/view). It enumerates the card contents and explicitly contrasts with get_market_state ('Prefer this over get_market_state when you want the interpreted view instead of raw engine fields'), distinguishing it from siblings.

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

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

The description provides explicit when-to-use guidance: 'Prefer this over get_market_state' for interpreted views, and 'Before placing any order through any execution tool, check the intent with decker.validate_intent' to alternative execution-related tools. It also excludes trade instruction usage via 'NOT a trade instruction'.

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

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

With no annotations, the description carries the transparency burden. It discloses that the change is immediate and affects downstream channels, which is useful. However, it does not mention whether the change is reversible, if it overrides existing settings, or any permission requirements, leaving gaps.

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

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

Two sentences, front-loaded with the action verb. Every word earns its place; no redundancy or filler.

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

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

For a simple one-parameter setter, the description covers the core function and its immediate consequences. It lacks details about error conditions or prerequisites, but given the simplicity and single parameter, it is nearly complete.

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

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

The schema already provides 100% coverage for the single parameter skill_id, including a description and example. The tool description adds no additional meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'change' and the resource 'active trading skill overlay for this user', which distinguishes it from sibling getters. It is specific and unambiguous.

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

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

The description explains the immediate effect on subsequent get_signals calls, providing clear context for when this tool is relevant. However, it does not explicitly mention alternatives or when-not-to-use scenarios, though the sibling set of getters makes the use case obvious.

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

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

With no annotations, the description carries full behavioral disclosure. It reveals that the tool persists every check to an 'auditable decision ledger (check_id)', explains the semantic of GO/WATCH/HOLD as 'a transition posture, not an order command', and explicitly disclaims that 'the order decision and responsibility remain with the calling agent/user.' This goes well beyond basic safety and sets expectations for side effects.

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

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

The description is a dense but well-organized paragraph. Every sentence adds value—purpose, invocation timing, return semantics, edge case, responsibility, and persistence. It could benefit from bullet points or section breaks for scannability, but the content is efficiently packed without fluff.

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

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

Given there is no output schema and no annotations, the description compensates fully by explaining what the tool returns (stance reading, gate vocabulary + side_alignment), how to interpret covered=false, when to call it, and what side effects exist. It covers all the essential context for a complex pre-trade validation tool.

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

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

Schema description coverage is 100%, and the schema already gives detailed descriptions for every parameter (side enum, symbol alias resolution, timeframe default, order_type informational). The description does not add meaning beyond the schema; it mentions symbol+side and timeframe gate horizon but those are already in the schema. Baseline 3 is appropriate.

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

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

The description opens with 'Pre-trade gate check for a proposed order intent' and specifies it 'Checks the intent (symbol + side) against Decker's deterministic market state.' This clearly names the verb (check/gate) and resource (order intent), and the tool is distinct from sibling getters and set_skill_overlay by being a validation step rather than a state query.

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

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

It explicitly says 'Call this BEFORE placing any order through any execution tool', giving a direct when-to-use instruction. It also provides a when-not-to-use nuance: 'Returns a stance reading, NOT an approval or rejection' and clarifies the covered=false case as 'treat as unknown, not as HOLD.' These exclusions and responsibilities make the usage guidance exceptionally clear.

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