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

With no annotations, the description carries the full burden and does well: '[WRITE ACTION]' flags mutation, 'Appends to existing mistakes' clarifies non-destructive additive semantics, and it notes the lesson can be optionally updated and that the full updated trade record is returned. It omits auth/permission requirements and whether appended tags can later be removed.

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 write-action flag and core behavior are front-loaded in the first sentence, followed by illustrative examples. Slightly long with three examples for a short description, but each example illustrates a distinct usage path (single tag, multi-tag + lesson, bare tag).

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 6-parameter write tool with no annotations and no output schema, the description covers mutation intent, append semantics, optional lesson update, and return payload ('full updated trade record'). Missing only permission/error behavior, which is a mild gap.

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

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

Schema description coverage is 100%, so each parameter is already documented in the schema; per the rubric the baseline is 3. The description reinforces that mistakes are appended (not replaced) and that lesson learning is optional, but adds little syntax or format detail 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?

States a specific verb (tag/add) and resource (execution discipline mistakes on a trade), and enumerates concrete examples of mistake tags. It is clearly distinguishable from read-only siblings like get_mistake_audit.

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?

Three example questions show realistic invocation contexts, including the optional lesson_learned and multi-mistake cases. However, it never states when not to use this tool or points to an alternative sibling (e.g. update_trade) for other edits.

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 disclosure burden. It usefully flags '[WRITE ACTION]' and states it 'Returns full created strategy and updated playbook catalog,' which is real value since there is no output schema. But it says nothing about duplicate-name handling, required permissions, validation failures, or whether existing playbook entries are modified.

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 purpose and write-action marker are front-loaded in the first sentence, and the example block is compact and invocation-focused. Slightly long for what it conveys, but no sentence is pure 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 10-parameter mutation tool with no output schema, the description covers the effect and the return payload, which is what an agent most needs to decide and confirm a call. Remaining gaps (permissions, idempotency) are minor relative to the schema's thorough parameter docs.

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

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

Schema description coverage is 100%, so all ten parameters (including r, wins, total baselines) are already documented in the schema. The description adds only a loose enumeration of field categories (rules, description, timeframes, markets) and no format or semantic detail beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Add a new trading setup or strategy to your TradeZylo Playbook') and enumerates the fields carried (rules, description, timeframes, markets). This clearly separates it from read-only siblings like get_playbook and get_strategy_stats without needing the schema.

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

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

The three example prompts give concrete invocation contexts (naming a strategy, attaching rules, specifying timeframe/market), which makes the intended use clear. However, it never explicitly excludes alternatives or says when not to use it (e.g. versus logging a trade with a strategy), so it stops short of full routing guidance.

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

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

With no annotations, the description carries the full burden and does well: it flags '[WRITE ACTION]', discloses server-side side effects (realized PnL $/%, actual R:R, account balance update) and states the return payload. It omits reversibility and any permission/account-state prerequisites (e.g. frozen account).

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?

Front-loaded with the write-action flag, then effect, then return, then illustrative examples. Efficient overall, though the third example's embedded instruction ('mark it closed with notes') is slightly verbose relative to the rest.

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 mutation tool with no output schema, the description covers action, side effects, return shape, and realistic invocation examples. It lacks only guard conditions (auth, irreversible close semantics) and any mention of related tools for correcting a mis-closed trade.

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

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

Schema description coverage is 100%, so every one of the 8 parameters is already documented in the schema, including trade_id-vs-instrument fallback logic. The description adds behavioral outcome context but no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb+resource: 'Close an open trade in TradeZylo journal by recording the exit price.' It is distinguishable from siblings like log_trade and update_trade by the 'close an open trade' scope, though it never names those alternatives 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 example questions ('Close my open EUR/USD trade at 1.0890', 'Close trade <trade_id> at exit price 65200') clearly demonstrate invocation contexts, including using trade_id vs instrument. No explicit when-not-to-use or alternative tool guidance is 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, the description must carry the behavioral burden, and it does disclose the mutation nature via '[WRITE ACTION]' and states that the full created record is returned. It does not mention side effects such as whether creating an account affects the active account, permission requirements, or any limits, so disclosure is partial.

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 write-action marker and core purpose are front-loaded, and the example questions add practical value without bloating the text. The examples are somewhat verbose and partly restate the purpose, keeping it short of a 5.

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 six-parameter creation tool with no output schema, the description covers what it does, the fields it consumes, and that it returns the full created record. The remaining gap is behavioral detail (permissions, effect on the active account), which is not covered anywhere.

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

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

Schema coverage is 100%, so all six parameters are already documented, including enum values, defaults, and constraints. The description restates a few fields (balance, broker, market) but adds no syntax or format meaning beyond the schema, making the baseline 3 appropriate.

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

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

States a specific verb and resource ('Create a new trading account in TradeZylo') plus the account varieties it covers (funded challenge, personal live broker, demo), and even names the return value. Against siblings like get_accounts or switch_account, an agent can immediately tell this is the creation 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?

The three example questions show concrete intended uses, which implies when to reach for this tool. However, there is no explicit when-not guidance and no alternative named (e.g., update_limits or switch_account for modifying an existing account), so routing is left largely to inference.

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

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

With no annotations, the description carries the full burden and does so well by disclosing the write action, the exact mutation ('Locks daily allowed trades to 0 in risk limits'), optional account deactivation, and the journal logging side effect. It also mentions the return of freeze status. It omits permission requirements and whether the action is reversible (though unfreeze_trading implies it), keeping it from a 5.

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 an action tag and a dense purpose sentence, followed by three illustrative examples. Every part serves a purpose, though the examples could be seen as slightly verbose; overall it is well structured and efficient.

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

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

For a mutating tool with no annotations and no output schema, the description is largely complete: it explains what changes, optional account deactivation, and that it returns full freeze status. Missing details about permissions, reversibility, and interaction with open trades prevent a perfect score.

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

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

Schema description coverage is 100%, so the input schema already documents all four parameters thoroughly. The description adds only contextual examples (e.g., 'Freeze trading for 24 hours') but no new semantic details beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description uses a specific verb and resource ('freeze trading', 'trading freeze / cooldown') and states the tool's effects: locking daily trades to 0, optionally deactivating an account, and logging a journal reflection. It distinguishes itself from siblings like pause_account by explicitly describing a psychological disciplinary freeze and risk-limit lock, though it does not name the alternative directly.

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?

Three concrete example questions clearly illustrate when to use the tool: after consecutive losses, after breaching a daily limit, or to prevent revenge trading. However, it does not name alternative tools (e.g., pause_account) or state explicit exclusions, so it falls short of the top score.

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

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

With no annotations, the description carries the full burden, and it does disclose that the operation spans ALL accounts and returns comparative metrics. However, it never states that this is a read-only/non-mutating operation, nor any cost, caching, or result-shape behavior — meaningful gaps for a tool with zero annotation coverage.

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 purpose is front-loaded in the first clause, and the metric list plus example questions are efficient. The three examples are slightly redundant with one another (all illustrate the same comparison intent), costing a little tightness.

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

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

With no output schema and no annotations, the description usefully compensates by naming the exact metrics returned (win rate, PnL, closed trades, profit factor, return %) and the comparison framing. It stops short of describing the return structure (e.g. one row per account) or any preconditions.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The description's mention of comparing 'between different accounts' correctly signals there are no filter inputs to supply, which is consistent with the empty schema.

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

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

The description states a specific verb and resource — a side-by-side performance comparison of accounts — and enumerates the metrics compared (win rate, PnL, closed trades, profit factor, return %). It implicitly distinguishes itself from get_accounts (which lists) and get_overview_stats (single-account), though it never explicitly names those 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 three example questions clearly establish when to reach for this tool (comparing two named accounts, ranking accounts by a metric, or comparing all accounts at once). There are no explicit exclusions telling the agent when to prefer get_overview_stats or get_strategy_stats instead, so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the shape of the returned data (field list) and is implicitly read-only via 'List', but says nothing about auth requirements, pagination, ordering, or rate limits. Adequate but not rich.

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

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

The core purpose and the returned-field list are front-loaded in the first sentence, with filtering and examples following. Efficient, though the enumerated field list and three examples make it longer than strictly necessary.

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

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

With no output schema and no annotations, the description compensates by naming the returned fields and giving concrete usage examples. For a simple one-optional-parameter read tool this is nearly complete; only the return ordering/pagination behavior is unstated.

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

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

Schema coverage is 100% and the single optional 'account' parameter is fully documented in the schema (name or ID). The description only restates this with 'Can filter for a specific account', adding no format or matching-semantics detail beyond the schema, so baseline 3 applies.

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

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

Specific verb+resource: 'List all linked trading accounts in TradeZylo', followed by an explicit enumeration of the returned fields (name, broker, balance, PnL, win rate, etc.). An agent can immediately tell this is a read-only listing of accounts. It does not explicitly distinguish itself from siblings like get_active_account or get_account_comparison, which keeps it from a 5.

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

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

The three example questions give clear context for when to reach for this tool (listing accounts and balances, viewing configured accounts). However, there is no explicit statement of when NOT to use it or which sibling (e.g., get_active_account, get_account_comparison, switch_account) to prefer for adjacent needs.

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 disclosure burden. It implies a safe read via 'Get details' and enumerates the returned values, but says nothing about behavior when no account is selected, permission requirements, or rate limits. Adequate but thin for zero annotation coverage.

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 core statement is front-loaded in a single sentence, with the example questions serving as a clearly separated usage aid. No sentence is wasted and every element aids selection or invocation.

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 listing the key returned fields (balance, equity, win rate, PnL, broker), which is enough for an agent to know what it gets back. It stops short of describing the full response shape or edge cases, but it is complete for a parameterless read 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 input schema has zero parameters, so the baseline of 4 applies. The description correctly implies no arguments are needed by framing the call as retrieving the already-selected account, and it adds meaning by naming the fields the implicit result contains.

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

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

The description names a specific verb and resource ('Get details of the currently active/selected trading account') and enumerates the returned fields (balance, equity, win rate, PnL, broker). The 'currently active/selected' qualifier distinguishes it from sibling tools such as get_accounts or get_account_comparison, so an agent can route correctly without opening a schema.

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

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

The example questions ('Which trading account is currently active?', 'Am I currently using my funded or personal account?') give concrete context for when this tool applies. However, no explicit alternatives or exclusions are stated — it never says to use get_accounts for the full list or switch_account to change selection — so the guidance is clear but not exhaustive.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the qualitative/narrative nature of the output and the conceptual categories returned, which is useful context beyond the schema. However, it does not state permissions, rate limits, cost/latency of AI analysis, or whether results are computed on-demand or cached.

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?

Front-loads the bracketed purpose tag, then best-for/not-for, then example questions. Well structured and mostly tight, though the four example questions are somewhat redundant with the 'Best for' section and add length without much new information.

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

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

With no output schema, the description responsibly sketches the return categories (tendencies, leaks, correlations, recommendations), giving the agent enough to know what comes back. The main gap is behavioral context for an AI compute-backed tool with no annotations, but for a read-only analytics query the definition is close to complete.

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

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

Schema description coverage is 100%, so all five parameters (account, account_id, date_from, date_to, market_type) are already fully documented in the schema. The description adds no parameter syntax, format, or interaction details (e.g., account vs account_id precedence), so baseline 3 applies.

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

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

States a specific verb and resource ('Get algorithmic and AI-detected pattern observations') and enumerates the output categories (behavioral tendencies, session leaks, duration correlations, recommendations). It explicitly distinguishes itself from siblings by name (get_edge_by_direction, get_edge_by_market), so an agent can tell what this tool returns vs adjacent analytics 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?

Provides an explicit 'Best for' list and a 'NOT for' clause that names the two alternative tools for the excluded use cases. The decision boundary between qualitative AI coaching insights and raw numeric edge breakdowns is unambiguous.

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

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

No annotations are provided, so the description carries the full burden, and it does disclose what the tool compares and computes. However, it says nothing about permissions, whether the analysis is read-only, time-range defaults, or what the returned structure looks like – gaps that matter for a 3-param analysis tool with zero annotation coverage.

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 purpose statement is front-loaded and the example questions are compact and directly useful for intent matching. Four examples is slightly redundant but each anchors a distinct phrasing, so little 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?

There is no output schema, so the description shoulders the burden of explaining return content, and it does so adequately by stating the comparison (win rate and PnL by checklist state). It is reasonably complete for a read-only analytics tool, missing only detail on output shape and defaults.

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 account, date_from, and date_to each documented in the schema, so the schema does the heavy lifting. The description adds no additional parameter meaning (e.g., defaults for the optional date range or multi-account handling), so the baseline 3 applies.

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

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

The description opens with a specific verb and resource: 'Evaluate pre-trade checklist discipline versus trade outcome,' and clarifies the comparison basis (win rate and PnL, checklist completed vs skipped). This clearly distinguishes it from sibling analytics tools like get_emotion_pnl or get_mistake_audit, though it never names a sibling 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 four example questions map directly onto the situations in which an agent should call this tool (checklist effectiveness, skip-performance, discipline score, adherence rate). This gives clear context for invocation but offers no exclusionary guidance or named alternatives for related analyses.

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 behavioral burden. 'Fetch' implies a read-only operation and the description scopes the content to journal-style notes, but it says nothing about what is returned when no note exists for the date, whether the note is free text or structured, or any permissions/account scoping.

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 purpose sentence is front-loaded and efficient. The three illustrative questions take space but are functional for disambiguating the tool's intent, so little is wasted overall.

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 single-parameter read tool with full schema coverage and no output schema, the description supplies enough to call it correctly. The main gap is the absence of any sibling routing guidance and of empty-result behavior.

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

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

Schema description coverage is 100% and the only parameter's format (ISO YYYY-MM-DD) is already documented in the schema. The description's phrase 'for a specific date' adds no syntax or constraint beyond that, so the baseline of 3 applies.

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

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

The description states a specific verb and resource ('Fetch the overall daily journal note written in TradeZylo') and enumerates the content types covered (reflections, pre-market prep, mindset observations). It does not, however, distinguish itself from nearby siblings such as search_notebook or save_daily_review, so an agent must infer the boundary.

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 example questions imply the intended usage ('What did I write in my daily journal for today?'), which is decent context, but there is no explicit statement of when to use this versus search_notebook or the save-side siblings, and no exclusions 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?

No annotations are provided, so the description carries the full burden. It discloses the computed outputs and that filtering is optional, which is useful, but says nothing about read-only semantics, whether inactive accounts are included, performance/caching, or whether 'recovery status' is a boolean or a value. Adequate but incomplete for a zero-annotation 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 core capability is front-loaded in the first sentence, with the filter note second and examples third. Nothing is wasted, though the four example questions are somewhat space-heavy for a single-parameter read 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 one-param, read-only stats tool with no output schema, the description compensates well by enumerating the exact metrics returned, so an agent knows what to expect. Minor residual gaps (units/timeframe, whether stats span all accounts or just active ones) keep it from 5.

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?

Only one parameter with 100% schema description coverage, so the schema already documents 'account' fully. The description's 'Can filter for a specific account' merely restates the schema and adds no format or naming guidance. Baseline 3 is appropriate.

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

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

States a specific verb ('Calculate') and resource ('equity peak and drawdown statistics'), then enumerates the exact metrics returned: peak equity, current drawdown in dollars/percent, all-time max drawdown, recovery status. This is well beyond a tautology. It stops short of distinguishing itself from risk-oriented siblings like get_risk_check or get_risk_limits, which also concern drawdown.

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 four example questions give concrete, realistic triggers for invoking the tool, including the account-filtering case. That is clear usage context, but there is no explicit when-not or routing to the overlapping siblings (get_overview_stats, get_risk_check), so it lands at 4 rather than 5.

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

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

No annotations are provided, so the description carries the full behavioral-disclosure burden. It does explain the analytical outputs and bias-detection purpose, but it does not explicitly state that the tool is read-only, whether it has side effects, or how data scope defaults are handled.

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 scope and metrics, then structured into Best for, NOT for, and examples. The example block is somewhat long with five examples, but it is still useful for query matching and does not bury the core purpose.

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

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

Given no output schema and no annotations, the description lists the key returned metrics and the analytical purpose, which is enough for an agent to understand what the tool returns. It is slightly incomplete on default date/account behavior and exact response shape, but the parameter schema covers filtering inputs.

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

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

Schema description coverage is 100%, so the five parameters are fully documented in the schema. The description adds no parameter-level meaning beyond what the schema already provides, making the baseline score of 3 appropriate.

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

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

The description states a specific comparison task: LONG vs SHORT trade performance, with named metrics (win rate, average PnL, profit factor, total count). It also explicitly distinguishes itself from a sibling by saying it is long/short only and not for asset-class comparisons.

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

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

It gives explicit 'Best for' guidance, an explicit 'NOT for' exclusion, and names the alternative tool to use instead: get_edge_by_market. The example questions further anchor when to select this tool.

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

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

No annotations are provided, so the description carries the full behavioral burden; it does disclose the return fields (win rate, average PnL, profit factor, trade count). However, it omits any auth/permission notes, whether the read is scoped to an account by default, or how multi-account aggregation behaves, leaving meaningful gaps for a no-annotation 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 header plus 'Best for/NOT for' structure is well front-loaded, but five example questions (including one in Hindi/Urdu) are surplus and border on padding. Core content is efficient; the example block is bloated.

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

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

With no output schema, the description appropriately enumerates the returned metrics and all parameters are optional/covered, so an agent can call it correctly. It lacks only minor details such as default date-window behavior when date_from/date_to are omitted.

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

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

Schema description coverage is 100%, so the five parameters are already documented in the schema, establishing a baseline of 3. The description adds little parameter-level meaning, and its market list ('PSX') even diverges from the schema enum values (FOREX, CRYPTO, STOCKS, FUTURES), a minor inconsistency.

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 ('Compare trading edge and profitability') and resource ('broken down by market type: Forex vs Crypto vs Stocks vs Futures vs PSX'), then names returned metrics. It explicitly differentiates itself from the sibling get_edge_by_direction.

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 'Best for' and 'NOT for' sections, routing the agent to get_edge_by_direction for trade-direction questions. The when-to-use vs when-not-to-use distinction is unambiguous.

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

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

No annotations are provided, so the description carries the full burden. It discloses the output grain (average PnL and win rate per mindset) and the grouping key (entry emotion), which is useful, but says nothing about permissions, whether data is scoped to the active account, or any latency/limit 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?

Purpose is front-loaded in the first sentence, the grouping behavior follows immediately, and the example questions are set off compactly with no redundant prose. Every element earns its place.

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

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

With no output schema, the description must convey return semantics, and it does by stating average PnL and win rate per emotion. The lack of any note on account scoping or empty-result behavior is a minor gap, but an agent has enough to call 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 100% with all three parameters (account, date_from, date_to) documented in the schema itself. The description only indirectly touches dates via the "for this month" example and adds no syntax or filtering nuance beyond the schema, so baseline 3 applies.

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

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

States a concrete analytical operation: measuring how entry emotions (Fear, FOMO, Confident, Greedy, Calm, Anxious, Impatient) affect PnL and win rate by grouping trades by entry emotion. This clearly separates it from siblings like get_overview_stats, get_mistake_audit, and get_edge_by_market.

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 example questions give strong, concrete triggers ("Which emotion costs me the most money?", "Show my emotion PnL breakdown for this month") that map user intent directly to this tool. It does not, however, name an alternative tool or state when not to use 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses what is computed and how it is grouped, but never states that this is a read-only/non-mutating operation, nor anything about permissions, default windows, or result size. Adequate disclosure of intent, but missing the safety/behavioral framing an unannotated tool needs.

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?

Front-loaded with a bracketed category tag, then purpose, then 'Best for', then examples — a sensible priority order. The example questions are somewhat repetitive but each maps to a distinct use case, so little 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?

With no output schema and no annotations, the description needs to carry the load, and it does state the computed dimensions (commissions, swap, slippage, spread by instrument and market). It omits default date-range behavior and return shape, which are the remaining gaps for a fully self-contained definition.

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

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

Schema coverage is 100%, so all five filters are documented in the schema, making 3 the baseline. The description only echoes the market-type grouping dimension and adds nothing about the account vs. account_id distinction or date-window defaults.

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 (audit) and resource (trading cost leakage: commissions, swap fees, slippage, spread), plus the aggregation scope ('across all trades, broken down by instrument and market type'). This clearly separates it from sibling analytics tools like get_edge_by_market or get_mistake_audit.

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?

'Best for: Identifying fee drag, broker costs, swap penalties, and spread leakage' gives clear intended-use context, reinforced by four example questions. It stops short of naming which sibling to use instead (e.g., vs. get_overview_stats for general PnL), so it is strong context without explicit alternatives.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the analytical semantics of the output (excursion depth, exit efficiency framing), which is real added context, but it never states that this is a read-only computation, whether it touches live account state, or how heavy the call is. Adequate but leaving an avoidable gap.

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

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

Front-loaded with a bracketed tag and the core definition, then cleanly sectioned into best-for / not-for / examples. The four example questions are slightly redundant against the 'Best for' line but they earn their place as retrieval anchors; nothing else is wasteful.

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

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

For an analytical read tool with no output schema and full schema coverage on inputs, the description covers purpose, alternatives, and interpretation. The remaining gap is operational: no default date window or guidance on what happens when all optional filters are omitted.

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% across all 5 optional parameters, so the schema already documents account, account_id, date_from, date_to, and market_type. The description adds no filtering syntax, default-window, or precedence detail (e.g. account vs account_id), so the baseline 3 is correct.

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 analysis resource and expands the jargon inline (MAE = drawdown while trade was active, MFE = peak unrealized profit before exit), then frames the interpretation ('leave money on the table' vs 'let drawdowns run too deep'). It explicitly names the siblings it is not (get_edge_by_direction, get_overview_stats), so an agent can route without opening any schema.

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

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

Ships an explicit 'Best for' block and a 'NOT for' block that names the two alternative tools and the conditions that select them. The four example questions map directly to likely user phrasings, which is unusually actionable routing 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 carries the full burden. It discloses that it aggregates tags and derives frequency, financial damage, and win-rate-when-mistake-occurs, which is meaningful behavioral context. It does not state the return format, whether an empty result means no mistakes, or any pagination/limit behavior, leaving gaps for a zero-annotation 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?

Purpose is front-loaded in the first sentence, followed by the metrics computed, then example questions. Every element earns its place, though the four examples are somewhat redundant with the opening enumeration.

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 aggregation tool with three simple filter parameters, no annotations, and no output schema, the description covers what is computed and when to reach for it. It could be slightly stronger by noting the read-only nature and the shape/granularity of the aggregation output.

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

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

Schema description coverage is 100%, so all three parameters (account, date_from, date_to) are already documented in the schema. The description adds no syntax or format detail beyond that, so the baseline of 3 applies.

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

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

Specific verb+resource: it audits recurring execution mistakes and enumerates the concrete mistake categories (Overleveraging, FOMO, Revenge Trading, etc.). It also states the computed outputs (frequency, total financial damage, win rate), which clearly distinguishes it from sibling stats tools like get_emotion_pnl or get_edge_by_market.

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 example questions give clear situational context (auditing discipline, cost of a specific mistake, filtering by account or last 30 days), which routes the agent to the right scenarios. However, it names no explicit alternative or when-not-to-use condition against siblings like get_emotion_pnl, so it stops short of full routing 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 carries the full burden. It implies a read-only analytics operation and lists what metrics are returned, but does not state whether it requires authentication, has rate limits, or how it aggregates across accounts. It gives a reasonable picture but lacks deeper behavioral context like pagination (not applicable) or caching.

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

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

The description is front-loaded with the core purpose, then usage guidelines, then example questions. Every sentence earns its place: the metric list is compact, and the example questions are directly useful for matching user intent. No wasted words.

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

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

Given no output schema and no annotations, the description is fairly complete for an analytics tool: it specifies the metrics returned and clearly routes to sibling tools. The main gap is lack of behavioral details about how the tool works (e.g., does it require an account context, does it default to a time range?). However, for a read-only summary tool with fully documented parameters, this is sufficient.

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

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

Schema description coverage is 100%, so all five parameters are fully documented in the schema itself. The description adds no additional parameter semantics beyond what the schema provides. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific verb (Get) and resource (high-level trading performance KPIs) and enumerates the exact metrics returned (win rate, PnL, profit factor, etc.). It clearly distinguishes itself from siblings by explicitly naming direction comparison, market comparison, and exit timing as different tools.

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

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

Explicitly says 'Best for: High-level overview or summary scorecard' and 'NOT for: Direction comparison (use get_edge_by_direction), market comparison (use get_edge_by_market), or exit timing (use get_mae_mfe_stats).' This is textbook when/when-not with alternatives named.

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 what the analysis produces (planned vs realized RR, target hit rate, R-multiple distribution), which is useful, but says nothing about permissions, data source, or rate limits. For a low-risk read-only analytical tool this is acceptable but not rich.

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

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

Front-loaded with the core comparison in the first sentence, followed by scope details and examples. The four example questions are slightly repetitive but earn their place by clarifying usage.

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 read-only analytical tool with no output schema, the description explains the metrics returned well enough for an agent to know what to expect. Missing details are minor given the low-risk, non-mutating nature of the tool.

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

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

Schema description coverage is 100%, so account/date_from/date_to are fully documented in the schema. The description adds no syntax, default, or filtering semantics beyond what the schema already states, so baseline 3 applies.

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

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

States a specific verb (compare) and resource (planned R:R vs actual realized R:R), and elaborates on the analytical dimensions covered (target execution, cutting winners early, R-multiple distribution). An agent can distinguish this from get_strategy_stats or get_edge_by_market without opening any schema.

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

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

The example questions give clear context for when to reach for this tool, effectively routing the agent. However, no explicit exclusions or named alternatives are provided, so it falls short of the 5 bar.

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 behavioral burden. It does not state whether this is read-only, whether it requires auth, or the format of results beyond field names. It hints at read behavior with 'Fetch', but no explicit safety or side-effect info is given.

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?

Front-loads the core purpose in the first sentence and lists returned fields. The example questions add context but slightly dilute conciseness; still, structure is clear and mostly efficient.

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

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

For a no-param, no-annotation, no-output-schema tool, the description lists returned fields but does not cover pagination, ordering, or error behavior. It is adequate but leaves several behavioral gaps that would matter to an agent.

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

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

Zero parameters, so baseline is 4. The description does not need to explain parameters, and it correctly leaves them out.

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 (Fetch) and resource (saved playbook setups and trading strategies), and enumerates the fields returned. Distinguishes itself from siblings like get_playbook_rules or get_strategy_stats by scoping to saved playbook setups.

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 example questions that imply when to use it (listing saved setups/strategies), but offers no explicit when-not-to-use guidance or named alternatives. The usage is implied rather than 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?

No annotations are provided, so the description carries the full behavioral burden. 'Get' implies a safe read, and the content categories give a sense of what comes back, but it says nothing about behavior on a non-matching or ambiguous name (the schema's partial match hint notwithstanding), nor about permissions or output shape. Adequate but thin for a zero-annotation 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 definition is front-loaded with the core purpose, then moves to concrete example queries that aid semantic matching. It is compact and each element earns its place, though the three examples are slightly more than strictly needed.

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

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

With no output schema and no annotations, the description compensates by enumerating the returned rule categories (entry, stop-loss, management, exit), which tells the agent what to expect from the call. The main residual gap is the lack of differentiation from get_playbook.

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% for the single required parameter, and the schema already documents the case-insensitive partial-match semantics. The description adds only 'by name', so the baseline of 3 applies.

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

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

The description gives a specific verb+resource ('Get the detailed written rules and execution guidelines for a specific playbook strategy') and enumerates the content types returned (entry criteria, stop-loss, management rules, exit conditions). It is clear on its own, but it never distinguishes itself from the sibling get_playbook, leaving the agent to guess which retrieval tool to pick.

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 example questions imply the usage context (looking up a named strategy's rulebook), which is better than nothing, but there is no explicit when-to-use vs get_playbook, no prerequisites, and no exclusions. Usage is only 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 burden and does state the read-only nature plus the categorical return statuses (OK, CAUTION, WARNING, BREACHED). It omits auth requirements, rate limits, and freshness guarantees, but discloses the essential safety and output-shape traits.

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 [READ-ONLY] tag and the core purpose sentence are front-loaded, which is exactly right. The example-question block is somewhat lengthy but earns its place by supplying usage context the rest of the text lacks.

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

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

There is no output schema, so the description correctly describes return content (loss vs cap, percentage used, status). For a two-parameter read-only tool this is largely complete, though it could note the default-today behavior more clearly.

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

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

Schema description coverage is 100%, so both date and account are already documented with format and defaults. The description adds only that account filtering is possible, which is a marginal restatement of what the schema already says; baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb (Check) and resource (real-time risk exposure) and enumerates what it computes: loss vs cap, percentage used, and warning status. It does not explicitly differentiate itself from sibling get_risk_limits, so an agent must infer where the boundary lies.

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 example questions give concrete, realistic scenarios for when to reach for this tool (pre-trade exposure check, limit-breach check). It lacks any explicit when-not guidance or named alternative such as get_risk_limits or get_drawdown_stats.

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

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

No annotations are provided, so the description carries the full behavioral burden; it does declare '[READ-ONLY]', which is the key safety signal. However, it says nothing about authentication/permission requirements, whether values can be unset, or rate/refresh behavior, all of which matter for a trading-account 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?

Front-loaded with the read-only marker and the core purpose in the first sentence, followed by a compact field enumeration. The example questions are separated cleanly and none of the prose 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?

With no output schema, the description compensates by listing the returned fields, so an agent knows what to expect from the response. It lacks any note about what happens when no limits are configured, but for a zero-parameter read tool this is largely complete.

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

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

The tool takes zero parameters, so per the baseline this dimension defaults to 4. The description correctly implies a no-argument call and directs the account scope implicitly ('for the TradeZylo account'), requiring no parameter 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?

States a specific verb and resource ('Fetch the configured risk management rules and loss thresholds') and enumerates the exact fields returned (daily/weekly/monthly caps, max drawdown, position size, leverage, risk per trade). It is clear what the tool does, but it never names the adjacent sibling get_risk_check, whose scope an agent could plausibly confuse with this one.

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 three example questions map directly onto the user intents this tool serves ('What are my configured risk limits?', 'Show my risk management rules'), which gives the agent clear triggering context. There is no explicit 'when-not' guidance or pointer to alternatives such as get_risk_check or update_limits.

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 supplied, so the description carries the full burden; it does disclose the returned metrics and implies a read-only aggregation, which is genuinely useful. It does not state permission requirements, whether the analysis respects account scoping, or any pagination/result-size 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 core purpose and return values are front-loaded in the first two sentences, followed by a scannable example-question list. The examples add retrieval value but make the entry longer than strictly necessary.

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 does the work of explaining return values, which is the key gap it fills for a stats tool. It is adequate overall, though account-scoping and empty-result behavior remain unstated.

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% for both date_from and date_to, so the schema already documents the ISO date format and analysis window. The description adds no additional meaning about the date range beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Cross-reference playbook strategies with actual trade data') and enumerates exactly what is returned (win rate, average PnL, profit factor, total trades, average actual RR). This clearly separates it from get_playbook (rule definitions) and get_overview_stats (general portfolio stats).

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?

Four example questions give concrete usage triggers ('Which playbook strategy is performing best in live trading?', 'Show win rate by strategy'), making the intended context clear. However, no explicit when-not guidance or named alternatives (e.g., vs. get_overview_stats) 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 burden. It helpfully enumerates the returned per-day metrics (PnL, trade count, win rate, R-multiple), but discloses nothing about read-only nature, permissions, data source, or timezone/date 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 core sentence is front-loaded and efficient. The example questions are somewhat verbose but do earn their place by illustrating the tool's use cases.

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

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

With no output schema, the description's enumeration of return fields is the main source of return-value information and is adequate. Missing only behavioral details (read-only, permissions) that would round out a complete definition.

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

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

Schema description coverage is 100%, so the year/month parameters and their ranges are already documented. The phrase 'for a given month or year' slightly conflicts with the schema requiring both, but adds no format detail beyond the schema, so baseline 3 applies.

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

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

The description names a specific verb and resource ('Get the trading calendar heatmap data') and states scope (a given month or year). It is clearly distinguishable from stats/notes siblings, though it never explicitly contrasts itself with them.

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 example questions imply when the tool is useful (calendar views, per-day PnL, green/red days), which is more than nothing. However, there is no explicit when-to-use vs alternatives (e.g., get_overview_stats or get_daily_notes) and no 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?

No annotations are provided, so the description carries the burden. It does disclose the breadth of returned data (pre-trade notes through risk metrics), implicitly signaling a read-only deep fetch, but says nothing about permissions, rate limits, or behavior when the ID is unknown.

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 core purpose is front-loaded in the first sentence, and the example questions are compact and illustrative rather than filler. Slightly verbose overall, but every line contributes routing value.

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

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

With no output schema, the description must convey what comes back, and it does so by enumerating the returned sections. For a one-parameter read tool this is nearly complete, missing only failure/empty behavior.

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

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

There is a single parameter and schema description coverage is 100%, with the schema itself noting it is a UUID. The description adds no format or validation detail beyond that, so the baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Get ... details of a single trade by ID') and the scope ('complete, deep details'), which cleanly separates it from the sibling list tool get_trades. The enumerated content areas (notes, management, review, lessons, MAE/MFE, risk metrics) make the resource 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 example questions give concrete context for when this tool is the right choice ('Walk me through my worst trade'), which grounds usage well. However, it never names alternatives such as get_trades for lists or get_trade_screenshots for screenshots, so no explicit when-not guidance is present.

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

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

No annotations provided, so the description carries the burden. It discloses pagination and filtering behavior, which is useful. However, it doesn't state authentication requirements, the response shape (no output schema), or how sorting defaults behave. Adequate but not rich.

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

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

Front-loaded with the core purpose, then concise field list, then example questions. The four example questions add real guidance but slightly pad length. Overall efficient.

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

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

For a 12-parameter list tool with no annotations and no output schema, the description is mostly complete: it states return fields and filtering scope, and examples clarify usage. Missing return format details and auth expectations keep it from a 5.

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

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

Schema coverage is 100%, so parameters are fully documented in the schema itself. The description mentions filtering by account name or ID but adds no syntax, defaults, or behavioral nuances beyond the schema. Baseline 3 applies when schema does the heavy lifting.

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

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

Specific verb ('Fetch') and resource ('trades'), plus explicit enumeration of returned fields (PnL, direction, instrument, setup tags, emotions, notes). This distinguishes it from get_trade_detail (single trade), get_overview_stats, and get_trade_screenshots among siblings.

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

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

The example questions concretely demonstrate when to use this tool (listing, filtering by date/instrument/account/outcome). No explicit when-not-to-use guidance versus get_trade_detail or statistical siblings, but the examples are strong contextual signals.

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. 'Get' implies a read-only operation, but it doesn't disclose whether screenshots are paginated, what happens if none exist, or authentication requirements. It adds the useful detail of returning both URLs and attachments, but leaves key behavioral traits unstated.

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

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

The first sentence front-loads the purpose efficiently, and the example questions are compact and helpful. However, including two example questions is slightly verbose for a simple tool, adding marginal value without new information.

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

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

For a simple retrieval tool with no annotations or output schema, the description covers purpose and examples but omits behavioral details like error handling or return structure. It's adequate but leaves gaps an agent might need when invoking it.

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

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

Schema coverage is 100%, so the required trade_id parameter is fully documented with its format (UUID). The description only implies its use through examples and adds no syntax or format details 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?

States a specific verb (Get) and resource (chart screenshot URLs and image attachments) scoped to a specific trade. It's clearly distinguishable from siblings like get_trade_detail or get_trades, which cover broader trade data.

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 example questions ('Show the chart screenshots for trade...', 'Do I have any before/after chart images for this trade?') make the use case clear, and the trade_id scoping implies when to use it. However, it doesn't explicitly contrast with alternatives like get_trade_detail, which might also include screenshots.

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 default account behavior ('If account is omitted, automatically uses your currently active trading account') and the return value ('Returns the full populated trade record'). No annotations are provided, so the description carries the behavioral burden; it could additionally state whether this is a write operation (though '[WRITE ACTION]' implies mutation) or any side effects, but the core behavior 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 front-loaded with the [WRITE ACTION] tag and the core action, followed by default behavior and return value. The example questions, while helpful, could be seen as slightly verbose, but they aid understanding without being excessive.

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 17 parameters, no output schema, and no annotations, the description covers the essential aspects: writable action, account default, and return value. It could be more complete by mentioning required fields or validation, but the examples and parameter details in the schema likely suffice for an agent to use the tool correctly.

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

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

Schema coverage is 100%, meaning every parameter is already documented with descriptions in the schema. The description adds no new parameter-level semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Log a new trade entry into your TradeZylo journal with complete trade parameters.' It clearly distinguishes itself from siblings like update_trade and close_trade by focusing on creation, and from read tools like get_trades.

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?

Three example questions illustrate when to use this tool (logging new trades with various fields), and the account-omission behavior is explained. However, it doesn't explicitly say when not to use this tool (e.g., use update_trade for modifications, close_trade for exits), which would elevate it to a 5.

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

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

No annotations are supplied, so the description carries the full burden, and it does reasonably well: it flags '[WRITE ACTION]', describes the mutation's effect on trade logging and risk checks, and states that an updated account record is returned. It omits reversibility (that resume_account undoes it) and any permission or side-effect caveats.

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?

Front-loaded with the action tag and core behavior, followed by compact examples. The example questions are somewhat repetitive in purpose but remain short and each reinforces an invocation pattern.

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 2-parameter mutation with no output schema, the description covers what it does, when to use it, and what it returns. The missing piece is the relationship to its inverse tool (resume_account) and any permission/reversibility notes.

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

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

Schema description coverage is 100%, so both 'account' and 'reason' are already documented in the schema; baseline 3 applies. The description echoes the account examples but adds no format or matching semantics (name vs ID resolution) beyond what the schema states.

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

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

States a specific verb+resource ('Pause / deactivate a specific trading account in TradeZylo') and enumerates the concrete effects (stops trade logging and active risk checks). It is clearly distinguishable from read-oriented siblings, though it never names its natural inverse, resume_account, which would have sharpened 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?

Gives clear usage context with parenthetical scenarios ('taking a break, challenge passed, drawdown caution') and example questions that map directly to invocation. It does not, however, state when NOT to use it or how it differs from adjacent tools like freeze_trading or resume_account.

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, but the description carries the burden well by labeling this as a WRITE ACTION, explaining that it restores the account to active status, and noting the conditional restoration of daily position limits when they were frozen at 0. It also states that the updated account record is returned, though it does not cover permissions or idempotency.

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 write-action label and core behavior, then uses a short list of example questions to illustrate usage. The examples slightly lengthen the text but remain useful and do not bury the main purpose.

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 two-parameter write tool with no annotations and no output schema, the description covers the action, its main effects, and the return value adequately. It misses differentiation from the closely related unfreeze_trading sibling, which is a minor but real completeness gap.

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

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

Schema description coverage is 100%, so both parameters are already documented in the input schema. The description adds contextual meaning for restore_daily_limit by explaining the frozen-limit scenario, but does not add syntax or format details beyond what the schema provides.

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

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

The description states a clear verb (resume/reactivate) and resource (trading account) with the specific effect of restoring active status. It does not, however, distinguish itself from the sibling tool unfreeze_trading, which appears to cover a very similar action.

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

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

The example questions imply typical use cases such as resuming an FTMO Challenge account or reactivating a Binance Futures account. There is no explicit guidance on when to use this tool versus unfreeze_trading or pause_account, leaving the agent to infer the correct routing.

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

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

With no annotations, the description carries the burden and does well: it flags the write action, discloses append-vs-overwrite behavior, and names the return value (full saved daily journal note). It doesn't cover permissions or overwrite data-loss specifics, keeping it short of a 5.

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?

Front-loaded WRITE ACTION tag and a compact purpose sentence, followed by useful examples. The example block is somewhat long but each line demonstrates a distinct invocation pattern, so it earns its space.

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-param write tool with no annotations and no output schema, the description covers purpose, write nature, append behavior, and return value. It lacks permission/auth notes and conflict handling with existing notes, but is otherwise sufficient.

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

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

Schema coverage is 100%, so all 8 params including append default and date format are already documented. The description adds only implicit guidance (append semantics, rating examples) beyond the schema, matching the baseline 3.

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 (save/append) and resource (daily journal review) with explicit scope fields (morning prep, session notes, psychology, lessons, discipline rating). The [WRITE ACTION] tag and sibling get_daily_notes make read/write distinction immediate.

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?

Example questions demonstrate when to invoke, including the append/date cases, and the WRITE tag contrasts with the read sibling get_daily_notes. No explicit when-not-to-use or mention of nearby create/save alternatives, but context is clear.

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

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

No annotations are provided, so the description carries the burden. It discloses the return shape ('titles and content') and read-only nature inferred from 'search', but says nothing about result limits, pagination, ranking/matching semantics, or empty-result behavior. Adequate but with notable gaps for a search 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 first sentence front-loads the purpose and content scope effectively, but the four example questions occupy most of the description and are repetitive in structure, adding length without proportional new information. Some pruning could tighten it.

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 single-parameter search with no output schema, the description gives a clear purpose, content scope, return format, and usage examples. What's missing is only secondary (match/ranking behavior, limits), which is acceptable at this complexity level.

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?

Only one parameter exists and schema coverage is 100%, so the baseline is high. The description adds practical value by demonstrating with examples what kind of text the query should contain (concepts, personalities, trading phenomena), going slightly beyond the schema's 'keyword or phrase'.

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 (search) and resource (TradeZylo Notebook) and enumerates exactly what the notebook contains (rules, routines, psychology lessons, notes), which clearly distinguishes it from sibling tools like get_playbook and get_daily_notes.

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 four example questions strongly imply when to use this tool (keyword search over free-text notes), including the semantic domain of 'revenge trading' and 'liquidity sweeps'. However, it never explicitly excludes sibling tools or states when not to use 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?

No annotations are provided, so the description carries the full burden. It does disclose the side effect (the account becomes active for future trades and analytics), which is useful, but says nothing about permissions required, reversibility, or what happens to the previously active account.

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 core purpose and effect are front-loaded in the first sentence, and the examples are compact. The example block is slightly redundant but plausibly useful for a non-technical user phrasing an account switch.

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 one-parameter mutation with no output schema, the definition covers purpose, effect, and input format. The main omissions are prerequisites/permissions and behavior toward the prior active account, which are minor for this tool's complexity.

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

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

The single 'account' parameter has 100% schema description coverage including name/UUID formats, so the schema already does the work. The description's 'by name or ID' merely restates it, which matches the baseline 3 for fully documented schemas.

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 concrete verb and resource ('Switch the active trading account'), and clarifies the outcome ('Activates this account for future trades and overview analytics'). This separates it clearly from read-only siblings like get_active_account and get_accounts.

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 example questions imply when to use it, but there is no explicit when-to-use/when-not guidance and no mention of related siblings such as pause_account, resume_account, or freeze_trading that could otherwise be confused with account state changes.

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 bears the full burden and does reasonably well: it flags a WRITE ACTION, spells out the side effects (limit restored, account reactivated, journal note written), and discloses the return payload (updated risk limits and active status). It does not cover permission/auth requirements, reversibility, or behavior when no freeze is currently active.

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 action tag and core purpose are front-loaded, followed by effects and return value in one dense sentence. The three example questions are somewhat padded but earn their place by showing selection cues. No wasted prose.

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

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

With no output schema and no annotations, the description steps in by naming the return values and the journal side effect, which is what an agent needs to call this safely. Residual gaps are auth/permission preconditions and interaction with resume_account.

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

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

Schema description coverage is 100%, so the schema already explains account, reflection, and restore_daily_limit including its default and minimum. The description only echoes the limit ('restore daily limit to 5') and adds nothing new about parameter formats or precedence, so baseline 3 applies.

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

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

The description states a specific verb and resource ('Lift a trading freeze / disciplinary cooldown') and enumerates concrete effects: restoring the daily position limit, reactivating the account, and logging a journal note. It is clearly the inverse of freeze_trading, but it never distinguishes itself from resume_account or pause_account, which plausibly overlap in the sibling set.

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 conveyed only indirectly through example utterances ('my cooldown is over and I am calm', 'I am ready to trade again'), which imply the triggering condition. There is no explicit statement of when not to use this tool, nor any named alternative (e.g. resume_account) for the ambiguous 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?

Without annotations, the description carries the burden and partially meets it: '[WRITE ACTION]' signals mutation, 'Unspecified fields preserve current values' describes update semantics, and 'Returns full updated risk limits record' states the return. It does not disclose permission requirements, reversibility, or side effects on active trading, which would be expected for a mutation tool with zero annotation coverage.

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 write-action flag and tool purpose, followed by a clear behavioral note and three concise, relevant examples. Every sentence earns its place without redundancy.

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

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

For an 8-parameter write tool with no annotations and no output schema, the description provides the essential context: mutation flag, partial-update semantics, return record, and practical examples. It falls short of complete transparency by omitting authorization requirements and any mention of how changes interact with active trading or other risk controls.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds context by grouping the eight parameters into logical categories and clarifying that omitted fields preserve current values, which is meaningful behavioral information beyond the schema's per-field descriptions. However, it does not introduce additional parameter-specific constraints beyond what the schema already documents.

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

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

The description uses a specific verb+resource ('Update configured risk management thresholds in TradeZylo') and enumerates the seven threshold types, making it immediately distinguishable from siblings like get_risk_limits and get_risk_check.

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 examples implicitly show when to use it (changing specific limits), and 'Unspecified fields preserve current values' clarifies partial-update behavior. However, there is no explicit statement of when NOT to use it or which alternatives (e.g., pause_account, freeze_trading) might be more appropriate for risk mitigation, leaving a small gap.

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 present, the description carries the full burden, and it does disclose that this is a [WRITE ACTION] and that it returns the full updated record. However, it omits key mutation semantics: whether it is a partial update (unmentioned fields preserved vs. cleared), permission/auth requirements, and validation or failure behavior for the 15 accepted fields.

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?

Front-loaded with the [WRITE ACTION] tag and the core verb+resource statement before any examples, and the example list is genuinely illustrative rather than filler. It is slightly long, but every sentence serves selection or invocation.

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 15-parameter mutation tool with no annotations and no output schema, the description covers the essentials: write intent, the field territory it operates on, and that the full updated record is returned. The remaining gap is partial-update semantics (what happens to fields not supplied), which matters for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents all 15 parameters including constraints like exclusiveMinimum and the 1-10 rating range. The description's prose restates a subset of the same fields (stop loss, take profit, notes, lessons, rating, mistakes) without adding format, unit, or interaction detail, so it is baseline-adequate rather than additive.

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

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

States a specific verb and resource ("Update fields of an existing trade record in TradeZylo") and enumerates the editable surface: stop loss, take profit, notes, lessons, execution rating, mistake tags. That is enough to separate it from log_trade and close_trade in practice, but the description never names those siblings, so it stops short of explicit 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 four example questions give concrete, unambiguous usage contexts (moving stops, adding notes, tagging mistakes, updating lessons) that map to real field combinations. There is no explicit when-not-to-use guidance or alternative routing, which keeps it below a 5.

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