Tapp Exchange MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation5/5
Every tool has a clearly distinct purpose with no ambiguity. The tools are organized by specific actions (add, create, get, remove, swap) and pool types (AMM, CLMM, Stable), making it easy to differentiate between them. For example, 'tapp_add_amm_liquidity' and 'tapp_swap_amm' target different operations on the same pool type, preventing misselection.
Naming Consistency5/5
Tool names follow a highly consistent pattern throughout: all use snake_case with a 'tapp_' prefix, followed by a verb (e.g., add, create, get, remove, swap) and a noun phrase specifying the action and pool type. This predictability makes the set easy to navigate and understand at a glance.
Tool Count4/5
With 21 tools, the count is slightly high but reasonable for a comprehensive DeFi exchange server covering multiple pool types and operations. It provides detailed coverage for AMM, CLMM, and Stable pools, though it might feel heavy compared to simpler servers. The tools are well-scoped, with each serving a specific function.
Completeness5/5
The tool surface offers complete CRUD/lifecycle coverage for liquidity management and swapping on Tapp Exchange. It includes creation, addition, removal, fee collection, information retrieval, and swapping for all pool types, with no obvious gaps. Agents can perform end-to-end operations without dead ends.
Average 2.9/5 across 21 of 21 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
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 full burden. It mentions 'Remove liquidity' which implies a destructive write operation, but fails to disclose critical behavioral traits such as required permissions, transaction costs, irreversible effects, or error handling, leaving significant gaps for safe agent use.
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, efficient sentence with zero wasted words. It is front-loaded with the core action and target, making it easy to parse quickly, though it could benefit from more detail given the tool's complexity.
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 tool's destructive nature (implied by 'Remove'), lack of annotations, no output schema, and complex parameters involving financial transactions, the description is incomplete. It doesn't address safety, return values, or operational context, making it inadequate for informed agent use.
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 100%, so the schema already documents both parameters ('poolId' and 'positions') and their nested fields. The description adds no additional meaning beyond the schema, such as explaining the relationship between parameters or providing usage examples, meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the action ('Remove liquidity') and target ('multiple AMM positions'), which is clear but basic. It doesn't distinguish itself from sibling tools like 'tapp_remove_multiple_clmm_liquidity' or 'tapp_remove_single_amm_liquidity' beyond the 'multiple AMM' phrasing, leaving ambiguity about when to choose this over alternatives.
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 on when to use this tool versus alternatives. With siblings like 'tapp_remove_single_amm_liquidity' and other 'remove_multiple_*' variants, the description lacks context on prerequisites, use cases, or comparisons, offering no help in tool selection.
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 burden. It states this is an 'add' operation (implying mutation/write), but doesn't disclose critical behavioral traits: whether this requires specific permissions, if it's irreversible, what happens to existing liquidity, potential fees, rate limits, or what the response looks like. For a financial transaction tool with zero annotation coverage, this is inadequate.
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, efficient sentence with zero wasted words. It's appropriately sized for a tool with three parameters and gets straight to the point without unnecessary elaboration.
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 this is a financial transaction tool with no annotations and no output schema, the description is incomplete. It doesn't explain what happens after adding liquidity (e.g., receipt of LP tokens, position updates), doesn't mention error conditions, and provides minimal behavioral context. For a tool that modifies financial positions, this leaves significant 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 description coverage is 100%, with clear parameter descriptions in the schema itself. The tool description adds no additional parameter semantics beyond what's already documented in the schema (poolId, amountA, amountB). This meets the baseline expectation when schema coverage is complete.
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 action ('Add liquidity') and target ('to an existing AMM pool'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'tapp_create_amm_pool_and_add_liquidity' which creates a new pool versus adding to an existing one, or from other liquidity addition tools for different pool types (CLMM, stable).
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing pool), when to choose AMM over CLMM or stable pools, or when to use this versus the 'create_and_add' variants. Without this context, agents must infer usage from tool names alone.
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?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Add liquidity' implies a write/mutation operation, the description doesn't disclose critical behavioral aspects like required permissions, whether this is a transaction that costs gas/fees, potential for slippage, or what happens to existing liquidity positions. For a financial operation with 7 required parameters, this is a significant gap.
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, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized and front-loaded with the essential information, making every word earn its place.
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 complex financial operation with 7 required parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'adding liquidity' means operationally, what the tool returns, potential risks, or how it differs from similar sibling tools. The context demands more comprehensive guidance for safe and correct usage.
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 100%, so the schema already documents all 7 parameters thoroughly. The description doesn't add any parameter semantics beyond what's in the schema - it doesn't explain relationships between parameters (e.g., how minPrice/maxPrice define the range, how isMaxAmountB affects amountB calculation, or how fee relates to pool selection). Baseline 3 is appropriate when schema does the heavy lifting.
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 action ('Add liquidity') and target resource ('existing CLMM pool'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate this tool from its sibling 'tapp_create_clmm_pool_and_add_liquidity' which suggests a similar function but with pool creation included.
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?
The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools for adding liquidity (CLMM, AMM, stable) and creating pools with liquidity, there's no indication of when this specific tool is appropriate versus 'tapp_create_clmm_pool_and_add_liquidity' or other liquidity addition methods.
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 burden. It states the action is to 'Add liquidity,' implying a write/mutation operation, but lacks details on permissions, side effects (e.g., token transfers, fees), rate limits, or what happens on failure. This is a significant gap for a financial tool with potential risks.
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, clear sentence with zero wasted words. It is front-loaded with the core action and resource, making it highly efficient and easy to parse for an agent.
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 complexity of a financial liquidity operation, no annotations, and no output schema, the description is incomplete. It lacks critical behavioral details (e.g., transaction implications, error handling) and doesn't guide usage relative to siblings, leaving the agent under-informed for safe and effective tool invocation.
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 100%, so the schema already documents both parameters ('poolId' and 'amounts') adequately. The description adds no additional meaning beyond implying 'amounts' correspond to tokens in the pool, but doesn't specify format (e.g., order matching pool tokens) or constraints, meeting the baseline for high schema coverage.
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 action ('Add liquidity') and target ('to an existing stable pool'), which is specific and distinguishes it from creation tools. However, it doesn't explicitly differentiate from other liquidity addition tools like 'tapp_add_amm_liquidity' or 'tapp_add_clmm_liquidity' beyond the 'stable' qualifier, which is implied but not contrasted.
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?
The description provides no guidance on when to use this tool versus alternatives. It mentions 'existing stable pool' but doesn't specify prerequisites (e.g., pool must exist) or compare to sibling tools like 'tapp_create_stable_pool_and_add_liquidity' for new pools, leaving the agent to infer usage context.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('collect fees') which implies a transaction/mutation, but doesn't disclose critical traits like whether this requires gas fees, changes on-chain state, has rate limits, returns collected amounts, or handles errors. The description is minimal and leaves key behavioral aspects unspecified.
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, efficient sentence that directly states the tool's purpose without any wasted words. It's appropriately sized and front-loaded with the core action, making it easy to parse quickly.
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 complexity of a DeFi fee collection operation with no annotations and no output schema, the description is insufficient. It doesn't explain what 'collecting fees' entails operationally, what happens after collection, error conditions, or return values. For a financial transaction tool, this leaves too many contextual 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 description coverage is 100%, with clear descriptions for both parameters (poolId as 'address of the pool', positionAddr as 'address of the liquidity position'). The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline of 3 for high schema coverage.
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 action ('collect fees') and target ('from a specific liquidity position in a given pool'), which distinguishes it from sibling tools that focus on adding/removing liquidity, creating pools, or swapping. However, it doesn't explicitly differentiate from other fee-related tools (none exist in siblings), so it's not a perfect 5.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing position with accrued fees), exclusions, or how it relates to sibling tools like tapp_get_positions for checking fee status. Usage is implied but not explicitly stated.
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 burden. It states the tool creates a pool and adds liquidity, implying a write/mutation operation, but doesn't disclose critical behavioral traits like permissions needed, transaction costs, irreversible changes, rate limits, or what happens on failure. For a complex financial operation with no annotation coverage, this is inadequate.
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?
Extremely concise single sentence with zero waste. It's front-loaded with the core action and efficiently communicates the dual purpose without unnecessary elaboration.
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 complex financial tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns, error conditions, or important behavioral context. Given the sibling tools involve different pool types (AMM/CLMM/stable) and this is a mutation operation, more guidance is needed.
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 100%, so parameters are fully documented in the schema. The description doesn't add any meaning beyond what the schema provides (e.g., no clarification on token address format, fee units, or amount precision). 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create an AMM pool and add initial liquidity') with a specific verb and resource. It distinguishes from siblings like 'tapp_create_clmm_pool_and_add_liquidity' by specifying 'AMM' type, but doesn't explicitly differentiate from other pool creation tools beyond the naming convention.
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 on when to use this tool versus alternatives like 'tapp_create_clmm_pool_and_add_liquidity' or 'tapp_create_stable_pool_and_add_liquidity'. The description implies it's for initial pool setup with liquidity, but lacks explicit context about AMM vs CLMM vs stable pool types or prerequisites.
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?
With no annotations provided, the description carries full burden but offers minimal behavioral information. It doesn't disclose whether this is a write operation (implied by 'create' but not explicit), what permissions are needed, potential costs/gas fees, whether the operation is reversible, or what happens on failure. For a complex financial operation with 7 required parameters, this is inadequate.
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, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized and front-loaded with the essential information.
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 complex financial tool with 7 required parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what CLMM means, doesn't provide usage context versus sibling tools, and offers no behavioral transparency about this being a write operation with potential financial implications.
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 100%, so the schema already documents all parameters thoroughly. The description adds no additional parameter context beyond what's in the schema. The baseline of 3 is appropriate when the schema does all the parameter documentation work.
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 action ('Create a CLMM pool and add initial liquidity'), specifying both pool creation and liquidity addition. It distinguishes this from sibling tools like 'tapp_create_amm_pool_and_add_liquidity' by specifying CLMM type, but doesn't explain what CLMM means or how it differs from AMM/stable pools.
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 about when to use this tool versus alternatives. With sibling tools like 'tapp_create_amm_pool_and_add_liquidity' and 'tapp_create_stable_pool_and_add_liquidity', the description should explain when CLMM is appropriate versus AMM or stable pools, but it offers no such context.
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?
With no annotations provided, the description carries full burden but reveals little behavioral information. It implies a write operation (creation and liquidity addition) but doesn't disclose permission requirements, gas costs, irreversible nature, transaction confirmation details, or potential errors. For a complex DeFi operation with financial implications, this is a significant gap.
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, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately front-loaded with the core action and doesn't include unnecessary elaboration.
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 complex financial transaction tool with 5 parameters, no annotations, and no output schema, the description is inadequate. It doesn't cover behavioral aspects (permissions, costs, irreversibility), doesn't explain relationships between parameters, provides no usage guidance versus siblings, and offers no information about return values or potential errors.
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 100%, so parameters are well-documented in the schema itself. The description adds no additional parameter context beyond what's in the schema (e.g., doesn't explain relationships between tokenAddress and amounts arrays, typical amplification factor ranges, or fee implications). Baseline 3 is appropriate when schema does the heavy lifting.
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 action ('Create a Stable pool and add initial liquidity'), specifying both the resource type (Stable pool) and the operation (create and add liquidity). It distinguishes from siblings like 'tapp_create_amm_pool_and_add_liquidity' by specifying 'Stable' pool type, but doesn't explicitly differentiate from 'tapp_create_clmm_pool_and_add_liquidity' beyond the pool type name.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., token approvals), when this is appropriate versus using separate create and add-liquidity tools, or any constraints (e.g., minimum liquidity amounts). Sibling tools like 'tapp_add_stable_liquidity' exist for adding liquidity to existing pools, but no comparison is provided.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states it 'gets' information, implying a read-only operation, but does not specify aspects like authentication needs, rate limits, error handling, or what 'detailed information' entails, leaving significant gaps in behavioral 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, direct sentence with no wasted words, efficiently conveying the core action and resource. It is appropriately sized and front-loaded, making it easy to parse quickly.
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 complexity implied by sibling tools (e.g., liquidity management, swaps) and the lack of annotations and output schema, the description is insufficient. It does not explain what 'detailed information' includes, potential return values, or operational constraints, making it incomplete for effective tool use in this context.
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 input schema has 100% description coverage, with the parameter 'poolId' documented as 'The pool ID to get information for'. The description adds no additional meaning beyond this, such as format examples or constraints, so it meets the baseline for high schema coverage without enhancing parameter understanding.
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 verb ('Get') and resource ('detailed information about a specific pool'), making the purpose evident. However, it does not explicitly differentiate from its sibling 'tapp_get_pools', which likely lists multiple pools, leaving some ambiguity in sibling distinction.
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?
The description provides no guidance on when to use this tool versus alternatives, such as 'tapp_get_pools' for listing pools or other tools for pool operations. It lacks context on prerequisites or exclusions, offering minimal usage direction.
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 the full burden of behavioral disclosure. It mentions 'optimal route information' but doesn't clarify if this is a read-only operation, what data it returns (e.g., paths, costs, slippage), or any constraints like rate limits or authentication needs. This leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without any unnecessary words. It is front-loaded and wastes no space, making it easy to parse quickly.
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 complexity of swap routing in DeFi and the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'optimal route information' entails, how results are structured, or any prerequisites, which could lead to misuse or confusion by an AI agent in a real-world context.
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 input schema has 100% description coverage, clearly documenting both parameters as token addresses. The description adds no additional meaning beyond this, such as token format or validation rules, but since the schema is comprehensive, a baseline score of 3 is appropriate as it doesn't detract from the existing documentation.
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's purpose with a specific verb ('Get') and resource ('optimal route information between two tokens'), making it easy to understand what it does. However, it doesn't explicitly differentiate from sibling tools like 'tapp_get_swap_estimate' or the various swap tools, which might have overlapping functionality for routing or estimation.
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?
The description provides no guidance on when to use this tool versus alternatives. Given the sibling tools include multiple swap-related tools (e.g., tapp_get_swap_estimate, tapp_swap_amm), there is no indication of whether this is for planning vs. execution, or how it differs in context, leaving the agent to infer 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?
With no annotations, the description carries full burden but only states the action without behavioral details. It doesn't disclose that this is a destructive write operation (implied by 'Remove'), potential transaction costs, authorization needs, or what happens to the removed liquidity. More context on risks or outcomes is needed.
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, efficient sentence with zero waste—it directly states the tool's purpose without fluff. It's appropriately sized and front-loaded, making it easy to parse quickly.
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 tool with no annotations and no output schema, the description is incomplete. It lacks crucial context like what 'remove liquidity' entails (e.g., burning shares, receiving tokens), potential side effects, or error conditions. More detail is needed given the complexity and risk involved.
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 100%, so parameters are well-documented in the schema. The description adds no additional meaning beyond implying 'multiple positions' via the tool name, but doesn't explain parameter relationships or usage. Baseline 3 is appropriate as the schema handles documentation.
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 action ('Remove liquidity') and target ('from multiple CLMM positions'), which is specific and distinguishes it from single-position removal tools. However, it doesn't explicitly differentiate from 'tapp_remove_multiple_amm_liquidity' or 'tapp_remove_multiple_stable_liquidity' beyond the CLMM specification in the name.
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 on when to use this tool versus alternatives like 'tapp_remove_single_clmm_liquidity' or other removal tools. The description lacks context about prerequisites, such as needing existing positions, or when batch removal is preferred over single operations.
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 burden. It states the action ('Remove liquidity') but doesn't disclose critical behavioral traits such as whether this is a destructive/write operation, permission requirements, transaction implications, gas costs, or error conditions. For a financial operation with no annotation coverage, this is a significant gap.
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, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse quickly.
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 complexity of a financial liquidity removal operation with no annotations and no output schema, the description is incomplete. It lacks information on behavioral aspects, return values, error handling, and differentiation from sibling tools, leaving significant gaps for an AI agent to understand proper usage.
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 100%, so the schema already documents both parameters (poolId and positions array with nested objects). The description adds no additional meaning beyond what's in the schema—it doesn't explain parameter relationships, constraints, or practical usage examples. Baseline 3 is appropriate when schema does the heavy lifting.
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 action ('Remove liquidity') and specifies the resource type ('multiple STABLE positions'), which distinguishes it from single-position removal tools. However, it doesn't explicitly differentiate from other 'remove_multiple' tools for different pool types (AMM/CLMM), though the 'STABLE' qualifier helps.
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 on when to use this tool versus alternatives like tapp_remove_single_stable_liquidity or other pool-type removal tools. The description lacks context about prerequisites, timing, or comparison with sibling tools.
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?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the action is a removal but doesn't disclose critical traits like whether it's destructive (likely yes, but unconfirmed), requires authentication, involves transaction fees, or has rate limits. The description lacks context on outcomes or risks.
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, efficient sentence with zero wasted words. It's front-loaded with the core action and target, making it easy to parse quickly. Every word earns its place without 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?
For a tool with 5 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects (e.g., mutation effects, error conditions) or provide usage context, leaving significant gaps for an AI agent to understand how and when to invoke it safely.
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 100%, providing clear parameter definitions. The description adds no additional meaning beyond the schema, such as explaining parameter relationships (e.g., how 'mintedShare' relates to liquidity) or usage nuances. Baseline score of 3 applies since the schema does the heavy lifting.
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 action ('Remove liquidity') and target ('from a single AMM position'), distinguishing it from sibling tools like 'tapp_remove_multiple_amm_liquidity' by specifying 'single'. However, it doesn't fully differentiate from other single-removal tools like 'tapp_remove_single_clmm_liquidity' beyond mentioning 'AMM'.
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 on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing an existing position), contrast with 'tapp_remove_multiple_amm_liquidity' for bulk operations, or explain why 'single' removal might be preferred over other methods.
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?
With no annotations provided, the description carries full burden but only states the basic action. It doesn't disclose critical behavioral traits such as whether this is a destructive operation (likely yes, given 'remove'), what permissions or authentication are needed, potential rate limits, or what happens to the removed liquidity (e.g., returned to user wallet).
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, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly.
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 no annotations and no output schema, the description is incomplete for a tool that performs a likely destructive financial operation. It lacks information on behavioral context, error conditions, return values, and differentiation from sibling tools, leaving significant gaps for an AI agent to understand proper usage.
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 100%, so parameters are well-documented in the schema itself. The description adds no additional meaning about parameters beyond implying they relate to a 'single CLMM position', which aligns with schema fields like 'positionAddr'. Baseline 3 is appropriate as the schema does the heavy lifting.
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 action ('Remove liquidity') and specifies the resource type ('from a single CLMM position'), which distinguishes it from stable or AMM variants. However, it doesn't explicitly differentiate from 'tapp_remove_multiple_clmm_liquidity' or explain what 'single' means operationally.
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 on when to use this tool versus alternatives like 'tapp_remove_multiple_clmm_liquidity' or 'tapp_remove_single_amm_liquidity'. The description mentions 'single' but doesn't clarify whether this refers to removing from one position versus multiple positions or other contextual differences.
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?
With no annotations provided, the description carries full burden but only states the action without behavioral details. It doesn't disclose that this is a destructive/write operation (implied by 'Remove'), potential transaction costs, authorization needs, rate limits, or what happens to the removed liquidity (e.g., tokens returned to user). For a financial transaction tool, this is a significant gap in safety and operational 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, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized for a simple action and front-loaded with the core verb and resource.
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 complexity of a DeFi liquidity removal operation with no annotations and no output schema, the description is insufficient. It lacks critical context about transaction behavior, return values (what tokens are received), error conditions, or how this differs from sibling tools. For a tool that likely involves financial risk and blockchain interactions, more completeness is needed.
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 100%, so parameters are well-documented in the schema itself. The description adds no additional meaning beyond the action name—it doesn't explain what 'poolId' or 'position' represent in context, or clarify the relationship between 'mintedShare' and 'amounts'. Baseline 3 is appropriate since the schema does the heavy lifting.
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 action ('Remove liquidity') and specifies the resource type ('from a single STABLE position'), which distinguishes it from other removal tools that handle AMM or CLMM positions. However, it doesn't explicitly differentiate from 'tapp_remove_multiple_stable_liquidity' beyond the 'single' vs 'multiple' naming, which is implied but not stated in the description itself.
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?
The description provides no guidance on when to use this tool versus alternatives like 'tapp_remove_multiple_stable_liquidity' or other liquidity removal tools. It doesn't mention prerequisites, such as needing an existing position, or contextual factors like gas costs or slippage considerations that might influence tool selection.
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 burden for behavioral disclosure. While 'Execute a swap' implies a write/mutation operation, the description doesn't disclose critical behavioral aspects like authentication requirements, rate limits, whether the swap is atomic/irreversible, gas costs, slippage considerations, or what happens on failure. This leaves significant gaps for a financial transaction 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 a single, efficient sentence with zero wasted words. It's appropriately sized for a tool with good schema documentation and gets straight to the point without unnecessary elaboration.
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 financial swap operation with no annotations and no output schema, the description is incomplete. It doesn't address critical context like transaction outcomes, error conditions, return values, or how this differs from other swap tools. The combination of a mutation tool with zero annotation coverage and minimal description creates significant gaps for safe and effective use.
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 100%, so the schema already documents all parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain relationships between parameters (e.g., how amount0 and amount1 interact with a2b and fixedAmountIn) or provide usage examples. Baseline 3 is appropriate when schema does the heavy lifting.
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 action ('Execute a swap') and the resource ('on an AMM pool'), which is specific and unambiguous. However, it doesn't explicitly differentiate this tool from its siblings like 'tapp_swap_clmm' or 'tapp_swap_stable', which appear to be alternative swap implementations for different pool types.
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?
The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools for different swap types (AMM, CLMM, stable) and related tools like 'tapp_get_swap_estimate' or 'tapp_get_swap_route', there's no indication of when this specific AMM swap is appropriate versus other swap methods or preparatory tools.
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?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the action ('Execute a swap') which implies a write operation, but doesn't disclose critical traits like transaction costs, slippage risks, authorization requirements, or what happens on failure. For a financial tool with potential irreversible effects, this is inadequate.
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, efficient sentence that immediately conveys the core function without any wasted words. It's perfectly front-loaded and appropriately sized for the tool's complexity.
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 complexity of a financial swap operation with no annotations and no output schema, the description is insufficient. It doesn't explain what the tool returns, error conditions, or important behavioral context like gas costs or confirmation requirements. The 100% schema coverage helps with parameters but doesn't compensate for missing operational context.
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 100%, providing clear documentation for all 6 parameters. The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting without compensating for any gaps.
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 action ('Execute a swap') and the target resource ('on a CLMM pool'), making the purpose immediately understandable. It distinguishes from sibling tools like 'tapp_swap_amm' and 'tapp_swap_stable' by specifying CLMM, but doesn't explicitly differentiate beyond the pool type.
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 on when to use this tool versus alternatives. While the description specifies CLMM, it doesn't mention when to choose CLMM over AMM or stable swaps, nor does it reference related tools like 'tapp_get_swap_estimate' for planning or 'tapp_get_pool_info' for pool details.
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 burden. 'Execute a swap' implies a write/mutation operation, but it doesn't disclose critical behavioral traits such as transaction costs, slippage risks, authorization requirements, or irreversible effects. This is inadequate for a financial tool with no 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse quickly.
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 complexity of a swap operation (financial transaction with risks), no annotations, and no output schema, the description is incomplete. It lacks details on execution behavior, error handling, or return values, which are crucial for safe tool invocation in this context.
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 100%, so parameters are well-documented in the schema. The description adds no additional meaning beyond implying a swap operation, which is already clear from the tool name. Baseline 3 is appropriate as the schema does the heavy lifting.
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 action ('Execute a swap') and the resource ('on a Stable pool'), which is specific and unambiguous. However, it doesn't differentiate from sibling tools like 'tapp_swap_amm' or 'tapp_swap_clmm' beyond specifying 'Stable pool', leaving some ambiguity about when to choose this specific swap tool over others.
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?
The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'tapp_swap_amm', 'tapp_swap_clmm', and 'tapp_get_swap_estimate', there's no indication of context, prerequisites, or trade-offs, leaving the agent to infer usage based on names alone.
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?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Get a paginated list' implies a read-only operation, it doesn't specify authentication requirements, rate limits, error conditions, or what constitutes a 'liquidity position' in this context. The pagination behavior is mentioned but lacks details about maximum page sizes or total count availability.
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, well-structured sentence that efficiently conveys the core functionality. It's front-loaded with the main purpose and includes the key constraint (paginated) without unnecessary elaboration. Every word earns its place in this compact description.
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 read-only tool with 100% schema coverage but no output schema, the description adequately covers the basic operation. However, without annotations or output schema, it should ideally provide more context about what information the positions contain, how they're structured, or what the pagination response looks like to be fully complete.
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 100%, so the schema already fully documents all three parameters with their types, descriptions, and defaults. The description adds no additional parameter semantics beyond what's in the schema, meeting the baseline expectation but not providing extra value.
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 action ('Get a paginated list') and resource ('liquidity positions for a user address'), making the purpose immediately understandable. However, it doesn't differentiate this read-only tool from its many sibling tools that involve adding, removing, or swapping liquidity, which would require explicit comparison to achieve a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With 18 sibling tools including various pool creation, liquidity management, and swap operations, there's no indication whether this is for monitoring positions versus taking actions, or how it relates to tools like 'tapp_get_pool_info' or 'tapp_get_pools'.
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?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this is an estimation tool but doesn't clarify whether it's read-only, whether it requires authentication, rate limits, or what the estimation is based on (current pool state, slippage assumptions, etc.). For a financial estimation tool with zero annotation coverage, this is insufficient behavioral 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, efficient sentence that directly states the tool's purpose. It's appropriately sized for an estimation tool and wastes no words. The structure is front-loaded with the core functionality immediately clear.
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 5-parameter estimation tool with no annotations and no output schema, the description is minimally adequate. It identifies the domain (Tapp Exchange swaps) and estimation purpose, but doesn't explain what the estimation returns, error conditions, or how it relates to actual swap execution. Given the complexity of DeFi swaps and rich sibling toolset, more context would be helpful.
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 description mentions 'amount received or needed' which hints at the bidirectional nature of estimation, but doesn't explicitly connect to the 'field' parameter's input/output options. With 100% schema description coverage, the schema already documents all 5 parameters thoroughly. The description adds minimal value beyond what's in the schema, meeting the baseline for high coverage.
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's purpose: estimating swap amounts on Tapp Exchange. It specifies the verb 'estimate' and resource 'swap', but doesn't differentiate from sibling tools like tapp_get_swap_route or the various swap execution tools (tapp_swap_amm, etc.). The description is specific about what's being estimated but lacks sibling distinction.
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?
The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools including tapp_get_swap_route and various swap execution tools, there's no indication whether this is for preliminary estimation before executing a swap, or how it differs from route calculation. No context about prerequisites or when-not-to-use is provided.
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 the full burden. It mentions pagination and optional filtering/sorting, which is useful, but lacks critical behavioral details: it doesn't specify if this is a read-only operation (implied by 'Get' but not explicit), what authentication might be required, rate limits, error conditions, or the structure of returned data. For a tool with no annotation coverage, this leaves significant gaps in understanding its 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, efficient sentence that front-loads the core purpose ('Get a paginated list of available pools') and includes key modifiers ('optionally filtered by type and sorted by TVL'). There's zero waste—every word contributes to understanding the tool's scope and capabilities without redundancy.
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 tool's moderate complexity (4 parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the basic purpose and parameter hints but lacks details on behavioral aspects (e.g., read-only nature, authentication, rate limits) and output structure. Without annotations or output schema, the agent must infer these from context, leaving gaps in operational understanding.
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 100%, with all parameters well-documented in the schema (page, size, sortBy, type with defaults and options). The description adds minimal value beyond the schema by mentioning filtering by type and sorting by TVL, but doesn't provide additional semantics like parameter interactions or usage examples. Baseline 3 is appropriate as the schema does the heavy lifting.
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 action ('Get a paginated list') and resource ('available pools on Tapp Exchange'), which is specific and unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'tapp_get_pool_info' (which likely gets details for a single pool) or 'tapp_get_positions' (which might focus on user positions rather than all pools). The purpose is clear but lacks sibling differentiation.
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 context through 'optionally filtered by type and sorted by TVL,' suggesting this tool is for browsing pools with filtering/sorting capabilities. However, it doesn't explicitly state when to use this versus alternatives like 'tapp_get_pool_info' (for single pool details) or 'tapp_get_positions' (for user-specific data). No explicit when-not-to-use guidance or named alternatives are provided.
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:

[![tapp-exchange-mcp MCP server](https://glama.ai/mcp/servers/tamago-labs/tapp-exchange-mcp/badges/card.svg)](https://glama.ai/mcp/servers/tamago-labs/tapp-exchange-mcp)

Score Badge

Copy to your README.md:

[![tapp-exchange-mcp MCP server](https://glama.ai/mcp/servers/tamago-labs/tapp-exchange-mcp/badges/score.svg)](https://glama.ai/mcp/servers/tamago-labs/tapp-exchange-mcp)

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/tamago-labs/tapp-exchange-mcp'

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