tm-mcp

Server Quality Checklist

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

Latest release: v1.2.1
Disambiguation5/5
Each tool targets a distinct operation (domain management, profile CRUD, run lifecycle, capture analysis/import, variables set management) with no overlapping responsibilities. Even similar tools like tm_verify_domain_dns and tm_verify_domain_http are clearly differentiated by verification method.
Naming Consistency5/5
All tools follow a consistent 'tm_verb_noun' pattern (e.g., tm_add_domain, tm_get_run, tm_delete_variables_set). No mixing of naming conventions, and verbs are appropriately concise.
Tool Count4/5
25 tools is on the higher side but still well-scoped for a comprehensive traffic testing service covering domains, profiles, runs, captures, and variables sets. Each tool has a clear purpose, and no redundancy is apparent.
Completeness4/5
The tool surface covers core CRUD and lifecycle operations for all major entities. Minor gaps exist, such as no tool for updating variables set CSV content or managing alert policies, but these are mentioned as deliberately not exposed.
Average 4.3/5 across 25 of 25 tools scored. Lowest: 3.6/5.
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 Apache 2.0.
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

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide destructiveHint and idempotentHint. The description adds beyond that by specifying the return status when no run is active and explaining the idempotent nature, which helps the agent understand safe 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 concise with two sentences, front-loading the core action. Every sentence adds value, and there is no wasted wording.
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 simple single-parameter tool with no output schema, the description covers purpose, idempotency, and a use case. It lacks detail on what 'pause' entails for run state, but is largely complete for its complexity.
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?
With 0% schema description coverage, the description should compensate but does not. It only mentions the tool's action without explaining the required profile_id parameter, leaving the agent to infer its meaning.
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 it pauses an in-flight run for a profile. It includes idempotent behavior and a use case, but does not explicitly differentiate from siblings like tm_stop_run or tm_resume_run, leaving some ambiguity.
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 provides a specific use case (inspecting intermediate metrics) but does not give when-not-to-use advice or compare to alternatives. The context is clear but lacks 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?
Annotations already provide destructiveHint and idempotentHint. The description adds useful behavioral details: full idempotency, success with status='IDLE', and cancellation of dispatch loops within a tick. These go beyond the annotations.
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?
Three sentences, each with essential information. No redundant text. Highly concise and well-structured.
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 (one required integer param, no output schema, annotations present), the description covers core behavior and idempotency. It does not detail post-stop state or side effects, but is sufficient for a simple stop action.
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?
With 0% schema coverage, the description must explain parameter semantics. It mentions 'for a profile' but does not elaborate on profile_id's meaning or format. The agent must infer its purpose from context.
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 'Stop the in-flight run for a profile', specifying verb and resource. However, it does not explicitly distinguish this from sibling tools like tm_pause_run, though the idempotent and destructive hints imply a different behavior.
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 mentions idempotency and behavior when nothing is running, but does not provide explicit guidance on when to use this tool versus alternatives like tm_pause_run or tm_start_run. Usage context is implied but not explicit.
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?
The description details the return value (name, RPS curve, etc., and run status) and error conditions (400 if not found or not belonging to user). Without annotations, it provides good behavioral context beyond the schema.
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 front-loaded with the main action and efficiently lists return fields and error conditions. While the list of fields is detailed, it is still concise and each 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?
In the absence of an output schema, the description thoroughly explains what is returned and the error scenario. It is complete enough for a simple get operation, though it could mention prerequisites like authentication.
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 explicitly describe the 'profile_id' parameter. It only mentions 'by id' in the purpose, adding minimal additional meaning. The parameter is simple, but the description could have provided more clarity.
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 'Get the full configuration of a single traffic profile by id', using a specific verb and resource. It distinguishes from sibling tools like tm_list_profiles (which lists all profiles) and tm_update_profile.
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 when you have a profile ID, but it does not explicitly state when to use this tool versus alternatives such as tm_list_profiles or tm_update_profile. No guidance on when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds significant behavioral context beyond annotations: profiles preservation, runnability condition, return value format, and error handling as typed ToolError. Annotations only indicate destructive hint and idempotency; description enriches understanding of 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 highly concise: three clear sentences. First sentence states intent. Second explains behavioral nuance. Third details return/error. No wasted words.
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 (one parameter, no output schema), the description is nearly complete. It explains return value and error handling, and the parameter name is self-explanatory. However, a brief note on domain_id acquisition would be helpful.
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 0% description coverage for the single parameter domain_id, and the tool description does not explain what this parameter represents or how to obtain its value. Since schema coverage is low, the description should compensate but fails to do so.
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 'Remove a registered domain' which is a specific verb and resource. It distinguishes from siblings like tm_add_domain and tm_list_domains.
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 explains consequences (profiles remain saved but not runnable) and references tm_list_domains for finding covered hosts. However, it does not explicitly state when to use this tool over alternatives or provide 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?
Description adds significant behavioral context beyond annotations: cancels in-flight runs, retains history rows, returns specific JSON, and handles errors as typed ToolError. Annotations already indicate destructive, so additional context is valuable.
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?
Description is concise with three sentences, front-loaded with the primary action. Every sentence adds value with no fluff.
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?
Covers core deletion behavior, side effects, return format, and error handling. Missing possibly authorization requirements, but annotations cover destructiveness. Adequate for a simple delete tool.
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 single parameter profile_id is not described beyond the schema. Schema coverage is 0%, but the parameter is self-explanatory. Description adds minimal semantic value; baseline 3 is appropriate.
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?
Description clearly states it deletes a profile by ID, distinguishing from sibling tools like create/get/update. It also specifies behavior regarding in-flight runs and history retention, differentiating it further.
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 deleting a profile but does not explicitly state when to use it versus alternatives or provide exclusions. Context of siblings makes it clear, but lacks explicit guidance.
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?
Annotations provide destructiveHint and idempotentHint. The description adds clarity by stating what remains unchanged (CSV, sampling mode, relationships) and describes the return shape, adding value beyond annotations.
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?
Two concise sentences with front-loaded purpose. Every sentence adds value—no 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?
Covers purpose, unchanged attributes, and return shape. No output schema, but description references another tool's return shape. Lacks prerequisites or error conditions, but adequate for a simple rename.
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?
With 0% schema coverage, the description adds some meaning by implying 'name' is the new display name, but does not detail the parameters or their sources (e.g., how to get variables_set_id). Adequate but incomplete.
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 ('Rename a variables set') and specifies what is not modified (CSV content, sampling mode, relationships), which distinguishes it from sibling tools like tm_change_variables_set_mode.
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 when to use (when renaming a variables set) but does not explicitly contrast with alternatives or provide when-not-to-use guidance. It is adequate but lacks explicit 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 full burden. It implies a read-only operation ('Get'), lists all returned data, but does not explicitly state no side effects or authentication needs. Still sufficiently transparent.
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: main purpose first, then a bullet-like list of returned data. It is informative but not overly long; 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?
For a simple one-param tool with no output schema, the description covers the essential information: what it does and what it returns. No missing critical details for an agent to invoke it correctly.
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?
Only one parameter (run_id, integer, required). Schema description coverage is 0%, but the field name and requirement make its purpose obvious. The description adds no additional semantic details beyond what the schema implies.
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 it retrieves one run's full detail, listing the specific metrics returned. It distinguishes from sibling tool tm_compare_runs by noting that tool does a diff for comparison.
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?
Explicitly tells when to use tm_compare_runs instead for side-by-side comparison, providing clear context. Does not specify exclusions but gives practical guidance.
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?
Discloses return fields and omission of raw CSV. With no annotations, the description effectively communicates the tool's behavior as read-only and structured. Doesn't mention error handling but acceptable for a simple get 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?
Two sentences, each informative. No redundancy. Front-loaded with purpose, then details. Highly concise.
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 one required parameter, no output schema, and no annotations, the description adequately covers purpose, return shape, and limitation (no raw CSV). Lacks error or existence info but sufficient for a simple fetch.
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 single parameter variables_set_id is not described beyond the schema. With 0% schema coverage, the description adds no meaning; even a brief clarification would improve scoring.
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 'Get a single variables set's metadata' with a specific verb and resource. It distinguishes from sibling tools like tm_list_variables_sets by focusing on a single item and referencing the return shape.
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 context by comparing return shape to tm_list_variables_sets and advises using the in-app UI for raw CSV inspection, implying when not to use this tool. Could explicitly state alternative use cases but sufficient for guidance.
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?
Annotations already indicate destructive (destructiveHint=true) and non-idempotent (idempotentHint=false) behavior. The description adds specific context: continuation from RPS curve position and SEQUENTIAL variable-set cursors, and clarifies non-idempotency in the no-state case, which adds value beyond annotations.
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 front-loaded with the main action and adds necessary details in a few concise sentences. Minor improvement could be to combine sentences for even tighter structure.
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 description covers purpose and behavior well for a simple tool with one parameter and no output schema, but it lacks parameter explanation and any indication of return values or side effects beyond continuation.
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?
There is one required parameter 'profile_id' with no description in the schema (0% coverage). The description does not explain this parameter, leaving ambiguity about its purpose (e.g., run ID vs profile ID).
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 'Resume a paused run' and the resource, distinguishing it from sibling tools like stop/pause by mentioning continuation from pre-pause position.
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 compares with stop/pause, warns that calling resume without an in-flight or paused run results in a 400 error, and implies the tool is for resuming previously paused runs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden and delivers extensive behavioral details: client-side computation, response shape, regression logic with thresholds, timestamp-based ordering with fallback, and invariants. It fully discloses how the tool behaves and what the AI should expect.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is long and includes a large code block, but it is structured with clear sections (purpose, return shape, invariants). Not every sentence is essential, but the detailed explanation adds value despite lacking conciseness.
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 description is very complete given the complexity: it covers the return shape, invariants, regression logic, and fallback behavior. However, it does not specify error handling for cases like invalid run IDs or cross-profile violations, leaving minor 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?
The schema provides only integer types with no descriptions. The description compensates by explaining the role of run_id and baseline_run_id in the return shape and the ordering logic, but it does not explicitly define the parameters in the input context. Still, the meaning is sufficiently inferable from the tool name and description.
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 purpose as a 'Synthetic side-by-side diff of two runs'. It distinguishes itself from sibling tools by its unique comparison functionality, and the detailed explanation of what it does (compute delta client-side, return leaner response) makes the purpose unmistakable.
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 implicit guidance on when to use this tool versus alternatives (e.g., 'a separate tm_get_run call surfaces the full per-run detail if needed'). It also enforces invariants (same profile, different runs) that constrain usage. However, it does not explicitly state when not to use it or list alternative tools for comparison.
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?
Annotations already provide idempotentHint: true and destructiveHint: true. The description adds valuable behavioral details: the 400 error on miss (deliberate for fast failure), response shape with verified=true, verifiedAt, verificationMethod='DNS', and specific code references. This goes beyond annotations.
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 with clear sections and bullet points. It is longer than necessary but each sentence adds value, including error handling details and response shape. Could be slightly more concise, but effective.
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 one parameter, no output schema, and annotations, the description covers the verification process, error conditions, response details, and integration with other tools (tm_add_domain, tm_list_domains). It is fully complete for an AI agent to use correctly.
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%, so description must compensate. It explains the domain must be previously added via tm_add_domain and implies domain_id is the identifier, but does not explicitly describe the parameter's meaning or constraints beyond that. It adds marginal value over the schema's 'integer' type.
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 it 'Run the DNS-TXT verification check on a previously-added domain.' It uses specific verb ('verify') and resource ('domain'), and explicitly distinguishes from sibling tm_verify_domain_http by specifying DNS method.
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 context: run after tm_add_domain, and pair with tm_list_domains to confirm. It explains the 400 error behavior for CI flows. However, it does not explicitly state when not to use this tool or compare with alternatives beyond naming tm_verify_domain_http as a sibling.
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?
Annotations already provide destructiveHint, idempotentHint, and openWorldHint. The description adds valuable context: returns a verification token and pre-formatted instructions for two verification methods, explains idempotent behavior, and shows the response shape. No contradiction with annotations.
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 detailed but well-structured with bullet points, a code block, and clear sections. It front-loads the purpose and is mostly efficient, though some sentences (like the idempotency note) could be more concise.
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 (verification process, two methods), the description covers purpose, token usage, response shape, and idempotency. It lacks explicit prerequisites (e.g., domain ownership) but provides enough context for an AI agent to understand the workflow.
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?
With only one parameter (domain) and 0% schema description coverage, the description compensates by showing the domain in the example response and linking it to verification. It clearly implies what the domain string represents, though it does not explicitly reiterate the parameter's meaning.
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 purpose: 'Register a new domain for verification.' It specifies the verb (register), resource (domain), and distinguishes from sibling tools like tm_delete_domain, tm_verify_domain_dns, and tm_verify_domain_http by positioning this as the prerequisite step.
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 explains when to use this tool: before verification is required, calling it 'the gate that prevents arbitrary abuse-as-a-service.' It also notes idempotency for repeat calls. However, it does not explicitly state when not to use it or compare with alternatives like listing domains.
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 full burden. It explains the tool behavior: listing runs with filters, pagination with size cap at 100, and returns a paginated envelope. However, it does not disclose sorting order, behavior on empty results, or potential side effects (though likely none).
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 (around 15 lines) and well-structured with a header, example, and bullet-pointed filter list. Every sentence adds value without redundancy. Front-loaded with purpose and key use case.
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 9 parameters and no output schema, the description provides the return format (pagination envelope) and covers all filters. It lacks detail on the contents of each run summary, but overall it is sufficiently complete for an agent to use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/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 adds detailed explanations for all 9 parameters, including allowed values for triggered_by, auto_verdict, format for timestamps, the reason for 'from_' underscore, and pagination defaults and cap. This is comprehensive beyond the 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 'List past runs with optional filters' and provides a specific use case (CI-failure triage) with an example. It distinguishes from sibling tools like tm_get_run (single run) and tm_compare_runs (comparison) by focusing on listing with filters.
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 gives a concrete use case and explains that filters are AND-combined, but does not explicitly state when not to use this tool or mention alternative tools. The example implicitly guides usage, but lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations destructiveHint and idempotentHint are present, but the description adds significant context: internal read-merge-write, rename uniqueness check with GET pre-flight, preservation of unexposed fields, and return value. No contradictions.
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?
Well-structured with clear paragraphs and front-loaded purpose. Slightly verbose but every sentence adds value, including examples and caveats.
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?
Covers internal behavior, rename uniqueness check, and return value. Missing details on error scenarios (e.g., when profile_id not found) but sufficient for an update tool with 9 params and no output schema.
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?
With 0% schema coverage, the description partially compensates by explaining key parameters via examples (profile_id, duration_seconds, target_url, points, name). However, not all 9 parameters are documented (e.g., http_method, request_body, request_headers, loop are unmentioned).
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 'Update an existing profile by id' and explains partial update semantics. It distinguishes from siblings like tm_create_profile (creation) and tm_delete_profile (deletion).
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?
Explicitly says 'Use this when you know the profile's id' and provides examples. Lacks explicit exclusions (e.g., 'do not use to create') but context makes it clear.
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?
Annotations include destructiveHint, idempotentHint, openWorldHint. Description adds that the server re-derives analysis on commit, and that empty groups is a no-op. No contradiction with annotations.
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?
Well-structured with workflow and parameter details in a clear order. Uses a block diagram for selections. Slightly verbose but each part adds value.
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 complex import workflow and no output schema, the description covers the entire process, parameter details, and return value shape (createdProfiles, etc.). Complete guidance.
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 description thoroughly explains both parameters: capture_path must be same JSONL file with security checks; selections shape is given with detailed fields and constraints (exact match, optional profileName, empty allowed).
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 it imports groups from an analysed JSONL capture as real traffic profiles, distinguishing itself from tm_analyse_capture which only analyses and returns groups.
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 explicitly prescribes a workflow: call tm_analyse_capture first, then pass selections. It also explains constraints like using the same JSONL file and path resolution. Lacks explicit 'when not to use' but the workflow is clear.
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?
Discloses return format (id, name, createdAt), ordering behavior (server-default, no sort), and ownership scope. No annotations provided, but description adequately covers behavior for a read-only list 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?
Three sentences, front-loaded with purpose, no superfluous text. Every sentence adds critical information (purpose, return format, sibling reference, ordering constraint).
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 zero parameters and the presence of an output schema, the description fully covers what the agent needs: purpose, output structure, ordering, and guidance for more detail. No gaps.
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?
No parameters exist; schema coverage is 100%. Description adds value by explaining return structure and ordering, meeting the baseline expectation for zero-parameter 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?
Description clearly states 'List all traffic profiles owned by the authenticated user', specifying verb, resource, and scope. Distinguishes from sibling tm_get_profile by noting it returns lightweight summaries vs full config.
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?
Explicitly directs to tm_get_profile for full details, implying when to use this tool for summaries. Does not state when not to use but provides clear context and a practical alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes far beyond the annotation hints (destructive, not idempotent) by detailing the two execution modes, polling behavior, race window handling, run-correlation defenses, and fail-closed logic. This provides a transparent view of internal workings and 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very detailed with multiple paragraphs and code blocks. While well-structured with sections, the length may overwhelm an AI agent looking for quick clarity. Tighter phrasing could improve conciseness without losing critical detail.
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?
The description covers all aspects: purpose, modes, return shapes (both modes), parameter behaviors, error handling, and run-correlation defenses. There is no output schema, so the detailed return shape documentation is essential and fully provided. Edge cases like unknown tokens and run-id mismatch are addressed.
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?
With 0% schema coverage, the description compensates by explaining most parameters: wait (fire-and-return vs blocking), fail_on_verdict (list of verdict tokens, requires wait, unknown tokens cause error), poll_interval_seconds and verdict_timeout_seconds (used in wait flow). However, wait_timeout_seconds is not explained, leaving a minor gap.
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 starts a traffic run for a given profile. It distinguishes two modes (fire-and-return vs wait) and explains the resource and action. This differentiates it from sibling tools like tm_stop_run or tm_get_run by focusing on initiation.
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 explicitly explains when to use each mode: fire-and-return for UI flows and wait for CI-gate shapes. It also details when fail_on_verdict is applicable and that it requires wait=True. However, it does not explicitly compare with sibling tools like tm_stop_run or tm_pause_run, though the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds significant context beyond annotations: explains server re-parses CSV and returns 400 on incompatibility, and that it returns updated metadata. No contradiction with annotations.
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?
Well-structured with a clear main sentence followed by bullet-pointed use cases. Slightly verbose but each sentence adds value; could tighten bullet phrasing.
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 low schema coverage and no output schema, the description fully explains behavior, error conditions, and return value, making it complete for an agent to use correctly.
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?
With 0% schema description coverage, the description compensates by listing allowed modes (ROW, COLUMN, SEQUENTIAL) and explaining their semantics with examples. Does not detail variables_set_id format but provides enough context.
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 'Switch' and the resource 'sampling mode on an existing set', distinguishing it from sibling tools which all have different purposes (e.g., create, delete, list).
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 concrete use cases (flipping modes for ordered replay or uncorrelated combinations) and mentions error recovery, but does not compare to alternatives like creating a new set or staying in current mode.
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?
Discloses that only metadata is returned and raw CSV content is excluded, which is important behavioral context. No annotations exist, so description provides necessary transparency. Could mention read-only nature explicitly but implied.
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?
Front-loaded with main action. Two paragraphs without wasteful content. Could be slightly tighter but still efficient.
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 no parameters, no annotations, and the description covers purpose, usage guidelines, behavioral details, and output content, it is complete for a list tool. Output schema exists but description already lists returned fields.
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?
No parameters in schema (0 params, 100% coverage), so baseline 4 is appropriate. Description adds no param info but none needed; it focuses on the tool's purpose and output.
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?
Clear verb and resource: 'List all variables sets owned by the authenticated user.' The description explicitly distinguishes from sibling tools like tm_get_variables_set by noting the scope difference.
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?
Provides explicit use case: answering 'what variables sets do I have available to attach to a profile?' during load test setup. Also clarifies when not to use (for CSV content) and directs to tm_get_variables_set for full metadata.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses behavioral traits: it reads plain text only, rejects certain paths with security rationale, returns per-endpoint analysis, and does not persist state. This is comprehensive.
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 informative but slightly verbose, with code formatting and a reference to a module docstring. It front-loads the purpose and is well-structured, though could be trimmed slightly without losing meaning.
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 simplicity (single parameter, no output schema, no annotations), the description is complete: it covers input constraints, return value (per-endpoint analysis), side effects (none), and next steps. No gaps remain.
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 no description (0% coverage), but the description adds extensive meaning: file format (.jsonl), allowed location under $TM_MCP_CAPTURE_ROOT, unsupported compressed forms, and path validation rules. This fully compensates for the schema's lack of detail.
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 analyses a JSONL traffic capture and returns a proposed profile structure. It uses specific verbs ('analyse', 'returns') and distinguishes from siblings by mentioning pairing with tm_import_capture.
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 specifies that the capture_path must be a .jsonl file under a specific root, and that compressed forms, symlinks, path traversal are not supported. It suggests pairing with tm_import_capture for profile creation, but could be more explicit about alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description reveals that each entry includes 'id, domain, verified flag, and the DNS / HTTP challenge tokens that are still in play.' This goes beyond the output schema by explaining the meaning of tokens. With no annotations provided, the description fully compensates by disclosing return structure and purpose.
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 short paragraphs with no redundant words. The first sentence states the core purpose, and the second adds helpful context. Every sentence contributes value.
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 presence of an output schema, the description provides sufficient context: it describes the returned fields and their significance. No gaps remain for an agent to understand the tool's function.
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 no parameters, so schema description coverage is 100% by default. The description does not need to add parameter info. The baseline score of 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 explicitly states 'List all domains registered by the authenticated user with their verification status.' It clearly identifies the resource (domains), action (list), and scope (by user), distinguishing it from sibling tools like tm_add_domain or tm_verify_domain_dns.
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 usage context: 'Useful for answering "what domains am I allowed to load-test?" and for walking a user through verification.' While it does not list explicit exclusions or alternatives, the purpose is clear enough for the agent to infer when to use this tool over others.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Provides detailed behavioral information: fetches file from .well-known, fallback to HTTP, matches token, flips verified, error response format, success response shape. Adds value beyond annotations.
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?
Well-structured with clear paragraphs. Each sentence provides necessary information without redundancy. Front-loaded with the main action.
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?
Covers purpose, process, alternatives, error handling, and response format. Despite no output schema, description makes usage clear. Sufficient for a verification tool.
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?
Even though schema coverage is 0% and only one parameter (domain_id), the description adds context on how the parameter is used in the verification process. Minimal but sufficient.
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?
Clearly states the tool verifies a domain via HTTP token check. Distinguishes from sibling tm_verify_domain_dns by explicit alternative.
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?
Describes when to use this tool as alternative to DNS verification for users who can serve a static file. Does not provide explicit exclusions but gives clear context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructive and non-idempotent. Description adds extensive context: fail-fast on collision to prevent data loss, server-side normalization details, concurrency race condition, return value description. No contradictions with annotations.
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?
Though lengthy, the description is well-structured with clear sections (minimum viable, optional knobs, name-collision, concurrency). Every sentence adds value, but could be tightened without losing clarity.
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 tool with 8 params, no output schema, and many siblings, the description covers all critical aspects: return type, upsert semantics, error handling, normalization, concurrency, and unsupported features. 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.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by explaining each parameter: minimum viable set, points format with example, defaults for http_method and loop, request_headers must be string, and optional knobs. Adds meaning well beyond the 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 tool creates a new traffic profile with upsert behavior. It explicitly distinguishes from siblings like tm_update_profile, which modifies existing profiles while preserving advanced fields, and explains the name-collision fail-fast behavior.
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?
Provides explicit guidance on when to use this tool (create fresh profile) vs tm_update_profile (modify existing). Details name-collision behavior, concurrency caveat, and recommends ASCII names. Also lists advanced features not exposed, directing to web UI/REST API.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds extensive behavioral context beyond annotations: describes validation rejection, quota errors, duplicate name errors, mode-specific behavior (ROW/COLUMN/SEQUENTIAL), return value metadata, and 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with paragraphs, examples, and clear sections, but slightly long; each section adds value so a 4 is appropriate.
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?
Covers creation tool comprehensively: input format, validation, errors, quotas, modes, return metadata, and links to subsequent steps (profile attachment). No output schema but description fills the gap.
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?
Compensates for 0% schema coverage by thoroughly explaining 'name' (uniqueness), 'csv_content' (format, headers, data rows, placeholder mapping), and 'mode' (default, options, requirements) with examples.
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?
Explicitly states 'Create a new variables set from inline CSV content', explains CSV format and placeholder substitution, and distinguishes from sibling tools like tm_rename_variables_set and tm_delete_variables_set.
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?
Provides detailed when-to-use guidance including note about attaching via tm_update_profile, explains quota limits and duplicate name handling, and describes mode options with their behavior.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds value beyond the `destructiveHint` annotation by explaining that it does not auto-detach, including the error message format, and the success response. No contradiction with annotations.
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 well-structured with the main action and crucial constraint first, followed by error details, recovery, and response. Every sentence is informative and necessary.
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 a single required parameter and no output schema, the description is thorough: it covers the constraint, error behavior, recovery path, and success output, making the tool fully understandable.
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?
With 0% schema description coverage, the description carries full burden. It implies the parameter is the ID of the set to delete, but does not explicitly state it. However, for a single required integer parameter, the meaning is clear from context.
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 it deletes a variables set and distinguishes from siblings by detailing a specific constraint (fails if attached to a profile). The verb 'Delete' and resource 'variables set' are explicit.
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?
Provides explicit when-not to use (if set is attached to a profile) and gives recovery steps: call tm_update_profile to detach first. Also notes error handling and alternative action via `tm_update_profile`.
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:

[![tm-mcp MCP server](https://glama.ai/mcp/servers/trafficmorph-gif/tm-mcp/badges/card.svg)](https://glama.ai/mcp/servers/trafficmorph-gif/tm-mcp)

Score Badge

Copy to your README.md:

[![tm-mcp MCP server](https://glama.ai/mcp/servers/trafficmorph-gif/tm-mcp/badges/score.svg)](https://glama.ai/mcp/servers/trafficmorph-gif/tm-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/trafficmorph-gif/tm-mcp'

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