CMP-server Pocket Option 2026

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation5/5
Each tool has a clearly distinct purpose: market data (get_candles, get_price), trading (place_trade, check_result), account/trade history (get_balance, open_positions, trade_history), memory (strategies vs skills), and communication (opinions vs messages). No two tools overlap enough to cause misselection.
Naming Consistency3/5
Naming is readable but mixes patterns: get_* and list_* for retrieval, save_*/delete_* for memory, plus noun-only names like performance, trade_history, and open_positions. The inconsistent use of get vs list and the non-verb names prevent a higher score, though the verbs are descriptive.
Tool Count3/5
24 tools falls in the 16-25 'heavy' range, but the scope includes three distinct domains (trading, persistent memory, agent communication), so each cluster earns its place. It is slightly over a typical well-scoped server but not excessive.
Completeness4/5
The trading lifecycle is well covered: market data, balance, trade placement, result checking, open positions, and history. Memory and communication are also complete with CRUD for strategies/skills and send/read for opinions/messages. Minor gaps exist (e.g., no individual opinion deletion, no market news), but core workflows have no dead ends.
Average 4/5 across 24 of 24 tools scored. Lowest: 3.2/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 4 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action without mentioning whether deletion is permanent, if any confirmation is required, or what happens if the skill does not exist. This is a significant gap for a deletion tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that is easy to parse and front-loads the verb. It contains no unnecessary words, though it is brief enough that it could arguably be more informative without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple nature of the tool, the description conveys the basic purpose, but it omits critical operational details like permanence, error behavior, and parameter identification. Since there is no output schema or annotations to compensate, the description is not fully complete for an agent to invoke the tool confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not reference the 'name' parameter at all. Although the single parameter named 'name' might be self-explanatory, the description adds no meaning beyond the schema, failing to clarify that the name identifies the skill to delete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and the resource ('a saved skill/rule'), with a specific condition ('no longer useful'). This distinguishes it from sibling tools like save_skill and get_skill, and even differentiates from delete_strategy by resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'no longer useful' implies when to use the tool, giving a conditional context. However, it does not explicitly discuss when not to use it or mention alternatives, so guidance is limited to implied usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It does mention session scope ('trades seen this session'), but it does not state whether the operation is read-only, whether it has side effects, or how the data is computed or updated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that is front-loaded with the key information. No filler words or redundant details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple parameterless tool, the description conveys the primary output (win rate, net profit) and scope (session trades). However, the return format (e.g., percentages, decimal values) is not clarified, and there is no explicit note about read-only behavior, leaving some ambiguity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline score is 4. The description adds meaning by specifying the metrics returned, which is sufficient for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides win rate and net profit, which are performance metrics. It is distinct from sibling tools like get_balance or trade_history, though it lacks an explicit verb such as 'get' or 'retrieve'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus alternatives like trade_history or open_positions. The intended use is only implied by the name and description, with no explicit context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose side effects. It only says 'Delete a saved strategy,' implying destructive action but not stating permanence, irreversibility, or any associated effects. The note about unreliability is a guideline, not a behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, front-loaded with the action verb and object. Every word earns its place; the 'proven unreliable' clause adds meaningful usage guidance without verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive mutation tool with no annotations and no output schema, the description is too thin. It fails to cover irreversibility, prerequisites, or outcomes. While the tool is simple, the agent still needs to know that deletion is permanent and what the response might be.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one parameter 'name' with no description, and the tool description provides no parameter-level detail. Schema description coverage is 0%, so the description was expected to compensate but does not mention how to specify the strategy. The parameter meaning is left entirely to the schema field name.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'delete' and resource 'saved strategy', clearly distinguishing it from sibling tools like delete_skill or save_strategy. The phrase 'that has proven unreliable' adds usage context but does not obscure the core purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear usage condition—only delete strategies that have proven unreliable—which guides the agent on when to invoke. However, it does not explicitly mention when not to use or name alternative tools, stopping short of a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must carry the behavioral burden. It implies a read operation ('get') but does not explicitly state that it is read-only, safe, or free of side effects. It also does not mention authentication requirements or return format details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that directly states the tool's function. There is no redundancy, fluff, or unnecessary detail, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema, the description adequately covers what it returns (balance and demo/live status). It lacks explicit detail on return formatting (e.g., data types, units), but given the simplicity, it is mostly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema covers everything (100%). Since there are no parameters to explain, the baseline is 4, and the description adds no parameter-specific value but does not need to.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets the account balance and demo/live status, with a specific verb and resource. It does not explicitly distinguish from sibling tools, but no sibling appears to overlap with balance retrieval, so the purpose is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided regarding when to use this tool versus alternatives, prerequisites, or exclusions. The description only states what it does, leaving usage inferable but not explicitly addressed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the transparency burden. It does disclose that the tool 'subscribes and waits for a tick', which warns the agent of a potentially blocking call. However, it does not state read-only status, required permissions, or any side effects of the subscription.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that front-loads the main action and includes a brief, informative parenthetical. Every word earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool lacks an output schema, so the description should explain what the tool returns and what values are acceptable for 'asset'. It does neither, making the tool incomplete for an agent to invoke correctly. The subscription/waiting detail is helpful but not sufficient for full comprehension.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter 'asset' has no schema description (0% coverage), and the description adds no meaning beyond the property name. It does not specify required format (e.g., ticker symbol, UUID), supported asset types, or examples, leaving the agent without the necessary information to supply valid input.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Get' and resource 'current live price for an asset', clearly distinguishing it from siblings like get_candles (historical) and get_asset_info (metadata). The parenthetical 'subscribes and waits for a tick' adds a unique behavioral detail that reinforces its purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for real-time price retrieval but does not explicitly state when to use this tool over alternatives. It does not mention that get_candles would be for historical data or that get_asset_info is for metadata, so guidance is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the behavioral burden. It only says 'get' which implies a read operation, but does not disclose what happens if the skill is not found, whether it returns the full skill or metadata, or any access requirements. This is insufficient for transparent behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence, front-loaded with the key verb and resource, and no superfluous words. Every word contributes to the purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (one parameter, no output schema), and the description covers the basic operation. However, with no annotations or output schema, the description could have noted return format or error behavior to be fully complete. It is minimally adequate but has gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description clarifies that the 'name' parameter is the identifier used to retrieve the skill/rule. This adds meaning beyond the schema's bare 'Name' title, yet provides no further detail on allowed patterns or formats.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get'), the resource ('saved skill/rule'), and the scope ('by its name'), distinguishing it from siblings like list_skills, save_skill, and delete_skill.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. Although siblings (list_skills, save_skill) exist, the description does not explicitly compare or provide use-case exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It indicates a read operation (get) and lists the returned fields, which is useful. However, it does not disclose error handling, authentication needs, or the full scope of 'details' (whether the list is exhaustive).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that is front-loaded with the purpose and enumerates key return details. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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 partially compensates by naming three specific return fields. For a simple getter, this is adequate, but it lacks information on error conditions, the certainty of the field list, and any rate limits or permissions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter, 'symbol', has no description in the schema (0% coverage). The description mentions 'one asset' but does not explicitly state that a symbol is required or provide any format validation. It adds minimal value beyond the parameter name.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns details for one asset, listing specific fields (payout, open status, allowed expirations). This distinguishes it from siblings like list_assets (multiple assets) and get_price (single price point).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The context is clear—use for a single asset—but there is no explicit guidance on when to prefer this over related tools like get_price or get_candles. The description implies usage but does not mention alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the ordering (most recent first) and the included data (win/loss and profit), which are meaningful behavioral traits. However, it does not mention the limit parameter or any pagination behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no redundant words. It efficiently captures the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional param and no output schema, the description covers the primary purpose and return content. However, it lacks any mention of the 'limit' parameter's effect on the result count, and does not explain the exact structure or interpretation of 'win/loss' beyond the words themselves.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter, 'limit', has no description in the schema and the description does not mention it. With 0% schema description coverage, the description fails to compensate for this gap, leaving the parameter's purpose undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns recent closed trades, sorted most recent first, and includes win/loss and profit. This is specific and distinguishable from sibling tools like open_positions, which handles open trades.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for viewing closed trade history but does not explicitly mention when to use this tool versus alternatives such as open_positions or performance. No exclusions or alternatives are named.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden for behavioral disclosure. The verb 'list' implies a read-only operation, but no further detail is given about return format, authentication, or potential side effects (though likely none). It meets the minimum but lacks rich context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with ten words, front-loaded with the verb and resource. Every word earns its place, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, no output schema, no annotations), the description sufficiently communicates its core function. It could optionally clarify what 'open' means (e.g., pending vs. active), but the current text is adequate for typical usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the description does not need to explain any. Per the rubric, 0 params gives a baseline of 4. The description adds no parameter information but none is required.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'List trades currently open on the account' uses a specific verb ('list') and resource ('trades currently open'), which clearly distinguishes it from siblings like trade_history (historical trades) and get_balance (balance). It is unambiguous and well-scoped.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for viewing current open positions but provides no explicit guidance on when to use it versus alternatives like trade_history. No exclusions or alternative recommendations are given, so usage context is only inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing behavior. 'Get' implies a read-only operation with no side effects, but the description does not mention what happens if the name is not found, whether the match is case-sensitive, or what the response contains. It is minimally transparent for a simple getter.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that fully communicates the tool's purpose. Every word earns its place, with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low complexity (one parameter, no output schema), the description is adequate but not rich. It explains what the tool does and the key parameter, but does not describe the return value or error behavior, which could be important for an agent to plan its next steps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema only provides 'name' as a required string. The description adds meaning by stating the name is the lookup key, which is essential for using the parameter correctly. However, it does not provide format details or boundary conditions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get'), the resource ('saved strategy'), and the selection criterion ('by its name'). This distinguishes it from sibling tools like list_strategies (which fetches multiple) and save_strategy/delete_strategy (which modify strategies).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool should be used when you need a specific saved strategy identified by a known name. It does not explicitly mention alternatives or exclusions, but the context is clear for a simple lookup tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses a key behavioral trait—blocking until expiration passes—and states that it returns win/loss and profit. However, it does not mention error handling (e.g., invalid request_id), potential timeouts, or whether the operation is read-only. The blocking behavior is important but could be elaborated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded. The first sentence states the core purpose, and the second gives the practical usage. Every sentence earns its place with no unnecessary filler or repetition of schema fields.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema and no annotations, the description is quite complete. It covers the action, the parameter, and the blocking behavior, and even mentions the output type. However, it could be more explicit about potential risks (e.g., indefinite blocking if the trade never closes) or the structure of the returned result.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one parameter, request_id, with no description. The description compensates by explaining its origin and meaning: 'Pass the request_id returned by place_trade.' This gives the agent the necessary context to supply the correct value, going beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('wait for a placed trade to close') and the resource ('trade') plus the output ('win/loss and profit'). It distinguishes from sibling tools like place_trade (placing) and open_positions (current positions) by focusing on awaiting closure and returning results.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool: after placing a trade, by passing the request_id returned from place_trade. It also explains the blocking behavior, implying it is for checking outcomes, not for listing or history. However, it does not explicitly mention when not to use it or name alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. 'Wipe' indicates a destructive operation, but it does not disclose whether the action is irreversible, whether it affects all users, or any permission requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
One concise sentence with an example, no waste. The description is appropriately sized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple, parameterless tool, the description covers purpose and a usage scenario. It lacks explicit statements about reversibility, but that is more behavioral transparency. Given simplicity, it is largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the description does not need to explain parameter meaning. Baseline 4 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses 'Wipe' as a specific verb and 'shared opinion board' as the resource, clearly distinguishing it from sibling read/post tools. The example 'starting a new session' adds context for the tool's purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides an explicit use case ('starting a new session') that signals when to use it, but does not explicitly mention alternatives or exclusions. It is clear that this is for clearing, not for reading or posting.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and adds meaningful behavioral detail: it discloses the return order (oldest-first), the exact fields (time/open/high/low/close/volume), and how to interpret the timeframe parameter. It doesn't cover edge cases like current forming candles or rate limits, but this is a solid disclosure for a simple read tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: the first sentence states the tool's purpose, followed by two sentences that add essential detail without waste. Every sentence earns its place, and the formatting of the timeframe mappings is easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (3 params, no output schema, no annotations), the description covers purpose, timeframe semantics, output format, and a usage note. It omits count-related behavior and any explicit alternatives, but it is sufficiently complete for an agent to invoke this tool effectively in most cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains the timeframe parameter with a helpful mapping (60=M1, 300=M5, etc.), but it does not explain the 'count' parameter or its default behavior. Asset is self-explanatory. Partial compensation for the key parameter but not all.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with 'Fetch OHLCV candles for analysis,' which clearly states the verb (fetch), resource (OHLCV candles), and intended purpose (analysis). This distinguishes it from siblings like get_price, which likely returns current price data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides a clear usage hint: 'Call this for several timeframes to analyse multiple horizons at once.' While it doesn't explicitly name alternatives or when-not-to-use, the context implies this is the tool for historical candle data versus price snapshots.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing behavioral traits. It discloses that the tool returns the opened trade including request_id, that real-money orders are refused unless PO_ALLOW_REAL=1, and implies a mutation action. However, it does not mention error conditions, margin requirements, or potential losses. This is acceptable but not deeply comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and well-organized: a one-sentence summary, parameter explanations in backticks, return value, and a caveat. Every sentence adds value, and the format is easy to scan. No redundant or vague language.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity, no output schema, and no annotations, the description covers the essential aspects: it specifies required parameters, return value with request_id, how to use it with check_result, and the real-money restriction. It omits details about error handling or the asset parameter's source, but overall it is sufficiently complete for an agent to understand the tool's operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains direction ('call'/'up' or 'put'/'down'), amount (stake in account currency), and expiration (duration in seconds, with examples and a pointer to get_asset_info). The only parameter not elaborated is 'asset', which likely requires reference to list_assets/get_asset_info. This is strong compensation given the low schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description begins with a clear verb and resource: 'Open a binary-options trade.' It specifies the action and distinguishes itself from sibling tools like check_result (which checks outcome) and list_assets (which lists available assets). The reference to request_id and check_result further clarifies its distinct role in the trade lifecycle.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage context: it tells the user to check get_asset_info for allowed expiration values and to pass the returned request_id to check_result for win/loss. This gives clear guidance on how the tool fits with related tools, though it does not explicitly state when not to use this tool (e.g., for reading trade history). Still, the context is strong enough for an agent to select correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 sorting (by payout), a limit cap, and that the output includes payout and expiration values. It does not explicitly state that the call is read-only (though 'list' suggests it), nor does it describe pagination or error behavior. For a simple read operation, this is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: the main purpose is stated in the first sentence, followed by a compact filter list and output notes. No filler or redundancy; every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description provides key return details (payout and expirations) and the ordering behavior. It does not fully specify the response structure (e.g., array of objects, exact field names), but for a list tool this is sufficient. The lack of annotations is partially mitigated by the description's coverage of parameters and behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% parameter descriptions, but the description explains every parameter in plain language: active_only (open for trading), otc_only (synthetic pairs), asset_type with allowed values, search as a substring, and limit as the cap. This fully compensates for the missing schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'List tradeable assets' – a specific verb and resource. It immediately distinguishes from sibling tools like get_asset_info (single asset) and get_price (current price) by focusing on the list/overview function. The inclusion of filters and output fields (payout, expirations) further clarifies its scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description establishes a clear use case: retrieving a list of tradeable assets with filtering options. It does not explicitly name alternatives or exclusion criteria, but the context is clear enough for an agent to decide when to invoke it. Sibling tool names like get_asset_info imply the alternative, though not stated in the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It explains persistence, field-level updates (only fields passed), and the statistical caveat about sample size. It could mention return values or error scenarios, but the provided behaviors are transparent and comprehensive for a save operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: a main purpose sentence, parameter guidance, and a usage caution. It is longer than a one-liner but appropriate for a tool with 9 parameters, and every sentence contributes actionable information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description covers purpose, parameter semantics, update behavior, and usage criteria. It does not describe return values, but that is less critical for a save operation. Overall, it provides a complete picture for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning to most parameters: it explains entry_rules (exact condition), assets and timeframe suitability, trades/wins/net_profit as observed results, and notes (including sample size). However, it does not mention the 'description' parameter, and with 0% schema coverage, a small gap remains. Overall, it substantially compensates for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Save or update a trading strategy in persistent memory to reuse later.' It specifies a verb (save/update) and resource (trading strategy), and distinguishes itself from sibling strategy tools (list_strategies, get_strategy, delete_strategy) by emphasizing persistence and update semantics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to save: 'only after it has shown genuinely good results over a meaningful number of trades — not after one or two lucky wins.' It also clarifies the update behavior for existing names. It does not explicitly name alternatives, but the context is sufficient for an AI to decide when to invoke this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the opinion is shared with 'other connected agents', which is a key behavioral trait. However, it does not mention persistence, overwrite behavior, or failure modes, but the core sharing behavior is transparent enough for an agent to understand the impact.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences plus a compact parameter example list. It is front-loaded with the main purpose and every sentence adds value—no fluff. The structure is clear and scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is relatively simple with 5 params and no output schema. The description covers the core purpose, key parameters, usage timing, and complementary tools. It lacks details on return value and agent_name semantics, but for a posting action, the provided context is sufficient for an agent to use it correctly in a typical workflow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, so the description must compensate. It explains three parameters (view, reasoning, confidence) with examples, but leaves 'asset' only implicitly clear from the phrase 'on an asset' and does not explain 'agent_name' at all. This partial coverage is helpful but not complete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'share' with resource 'asset' and clearly distinguishes the tool from its sibling 'read_opinions' by focusing on the act of posting. It also names the key fields, making the tool's purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use the tool ('before important entries when other agents are connected') and provides a complementary follow-up action ('then call read_opinions to see theirs and compare'). This gives clear contextual guidance and references an alternative/sibling tool for the subsequent step.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully carries the transparency burden. It discloses what messages are included (sent to you, broadcast, your own) and mentions other_agents_seen, providing useful behavioral context. It's clear this is a read-only operation, even though some details like return format are not specified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with three sentences covering purpose, filtering, and usage timing. It is front-loaded and every sentence adds value, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read tool with one optional parameter and no output schema, the description is nearly complete. It explains what the tool does, how to filter, and when to use it. The only gap is a precise return structure, but the description suffices for selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It explains that 'from_agent' filters to one conversation, which is meaningful beyond the schema's bare parameter definition. The sole parameter is adequately described.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Read recent messages') and the scope ('sent to you or broadcast to everyone, plus your own'), which distinguishes it from other tools like send_message or read_opinions. The verb+resource pairing is specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides concrete guidance on when to use the tool: 'at the start of a session and before important decisions when other agents are connected.' It also explains how to filter via from_agent. While it doesn't explicitly name alternatives, the usage timing is clear and contextual.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses useful behavioral details: the output includes 'other_agents_seen' and its meaning. It also notes that the tool includes the agent's own opinions. This goes beyond a simple read and helps interpret results.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the primary purpose. It then provides usage guidance and a parameter tip without any wasteful words. Each sentence contributes value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read tool with one optional parameter, the description covers purpose, when to use, output interpretation, and parameter usage. It doesn't fully describe the shape of individual opinions, but overall it is sufficient given the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description compensates by explaining the only parameter: 'Filter to one asset with ``asset``.' This adds practical meaning to the schema, which only provides a default value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Read recent opinions') with a clear resource ('opinions from other connected agents (and your own)'). It differentiates well from sibling tools like post_opinion and clear_opinions by focusing on the read operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit context: 'If other agents are running, use this to compare views before deciding.' It also implies when not to use it ('if it's empty, you're likely trading solo'). Does not name alternatives directly but gives clear usage conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals the privacy scoping ('keyed by AGENT_NAME; you never see other models' strategies here') and describes the content of each entry ('entry logic, asset/timeframe, recorded results'), which adds significant context beyond a mere 'list' operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is four sentences, each earning its place: purpose, privacy scoping, usage timing, and result contents. It is front-loaded with the core action and avoids any fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with zero parameters and no output schema, the description is complete. It covers what the tool does, the data it returns, its privacy boundary, and when to invoke it. The value proposition ('build on past experience') is also clear.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero properties, so the baseline is 4. The description does not need to explain parameters since there are none, and no additional parameter details are required for this simple parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the action ('List the trading strategies YOU saved') and clarifies the scope ('your own file only'), making it distinct from sibling tools like get_strategy, save_strategy, and delete_strategy. The verb is specific and the resource is clearly identified.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides a clear when-to-use directive: 'Call this at the START of a session to build on past experience instead of starting blank.' It does not explicitly name alternative tools for specific cases, but the context implies the difference between listing all strategies and retrieving a single one via get_strategy.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses key behaviors: messages expire after TTL, the ability to broadcast or target a specific agent, and how to find agent names via other_agents_seen from read_opinions/read_messages. This is good coverage for a simple messaging tool, though it omits any potential delivery guarantees or failure modes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise: three sentences, each earning its place. The first sentence states the purpose, the second explains addressing, and the third provides usage examples and TTL warning. No fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with only 2 parameters and no output schema, the description covers all essential aspects: what it does, how to use addressing, when to use it, and behavioral nuances like TTL. It leverages context from sibling tools without needing to restate return values or complex behaviors.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It thoroughly explains the 'to' parameter (empty for broadcast, set to an agent's name) and how to discover valid agent names. The 'text' parameter is not explicitly described, but its meaning is obvious from the tool's purpose, making this adequate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb (send), resource (message), and audience (other connected agents), distinguishing it from sibling tools like read_messages (for reading) and post_opinion (for opinions). It also specifies broadcast vs. direct addressing, adding precision.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage context ('Use this to actually coordinate') with concrete examples (ask a question, flag a setup, hand off) and explains when to broadcast vs. direct. However, it does not explicitly name alternatives or describe when not to use the tool, but the context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the file is persistent and private, and that saving an existing name performs a partial update. This gives agents an accurate mental model, though it stops short of detailing error conditions or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured with the purpose first, followed by usage examples and parameter guidance. Every sentence contributes to understanding without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity, the description covers the intended use, parameter roles, and update semantics comprehensively. The sibling context reinforces the need for clarity, which this description satisfies.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description explains each parameter: 'name' (short, unique), 'rule' (the rule itself), 'category' (grouping), and 'notes'. It also clarifies the optional nature and the update behavior, providing essential meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Save or update a rule/skill') and the resource ('persistent, private skills file'), distinguishing it from sibling tools like list_skills, get_skill, and delete_skill. The update semantics are also specified, making the scope unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage context: 'Use this for durable lessons and rules you want to follow in future sessions' and gives concrete examples. It doesn't explicitly mention alternatives or exclusions, but the context is clear enough to differentiate from similar tools like save_strategy.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description serves as the primary transparency source. It discloses the tool is informational and enumerates the topics it covers (platform mechanics, freedoms, OTC vs real, data, workflow). It does not mention output format or length, but the presence of an output schema mitigates the need to describe return values.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact yet information-dense. It front-loads the critical instruction 'READ THIS FIRST' and uses the rest of the sentence to enumerate covered topics without unnecessary fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool is a manual, the description thoroughly outlines what the user will learn, covering platform, trading mechanics, tool inventory, constraints, and workflow. The existing output schema covers return format, so no further detail is necessary.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so no parameter documentation is needed. The description correctly focuses on content rather than arguments, earning the baseline score for parameterless tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the explicit verb 'Explains' and clearly identifies the resource as the platform operating manual. It lists specific content areas (PocketOption, binary options, tools, freedoms, OTC, data sourcing, workflow), which distinguishes it from sibling trading tools that perform actions rather than provide guidance.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs 'READ THIS FIRST' and 'Read it once before doing anything else,' establishing a clear when-to-use directive. It doesn't name alternative tools, but for a manual tool there are no direct alternatives; the instruction is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the private, model-specific nature of the data and the intended session-start usage. However, it does not explicitly affirm read-only behavior (though listing implies it), so a slight deduction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three concise sentences: function, usage guidance, and scope limitation. Each sentence serves a distinct purpose, with the core action front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple zero-parameter list tool, the description provides purpose, usage timing, and data scope. It also references the companion tool list_strategies to clarify relationship. Return format isn't needed without an output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and the schema covers 100% (empty). The description adds context about the content being listed but needs no parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists the model's own previously written rules/skills, with an explicit scope of 'your own private file only.' This distinguishes it from sibling tools like list_strategies (which likely lists strategies) and get_skill/save_skill.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly instructs to read this at the START of every session alongside list_strategies, providing a clear usage trigger. It also clarifies that it never shows another model's skills, preventing misuse.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![CMP-server_Pocket-option-2026 MCP server](https://glama.ai/mcp/servers/Rufus011/CMP-server_Pocket-option-2026/badges/card.svg)](https://glama.ai/mcp/servers/Rufus011/CMP-server_Pocket-option-2026)

Score Badge

Copy to your README.md:

[![CMP-server_Pocket-option-2026 MCP server](https://glama.ai/mcp/servers/Rufus011/CMP-server_Pocket-option-2026/badges/score.svg)](https://glama.ai/mcp/servers/Rufus011/CMP-server_Pocket-option-2026)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Rufus011/CMP-server_Pocket-option-2026'

If you have feedback or need assistance with the MCP directory API, please join our Discord server