Treasure Data MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes, but there is some overlap between td_analyze_execution, td_analyze_url, and td_diagnose_workflow, which all involve analyzing workflows or executions. The descriptions help differentiate them, but an agent might occasionally misselect between these three. Other tools like td_find_project and td_get_project_by_name also have overlapping functionality but are clearly distinguished by their use cases.
Naming Consistency5/5
All tool names follow a consistent td_verb_noun pattern, such as td_list_projects, td_get_workflow, and td_analyze_execution. The naming is uniform across all 23 tools, with no mixing of conventions like camelCase or snake_case deviations, making it easy to predict and understand tool purposes.
Tool Count3/5
With 23 tools, the count is borderline high for a single server, as it may feel heavy and potentially overwhelming for agents. However, given the comprehensive domain of Treasure Data workflow and data management, the number is somewhat justified to cover various aspects like analysis, exploration, and monitoring, though it could benefit from consolidation.
Completeness5/5
The tool set provides complete coverage for the Treasure Data domain, including CRUD-like operations (e.g., list, get, find), analysis tools (e.g., diagnose, trace), and exploration features (e.g., download, read). There are no obvious gaps; tools handle projects, workflows, databases, tables, sessions, and attempts, ensuring agents can perform end-to-end tasks without dead ends.
Average 4.4/5 across 23 of 23 tools scored. Lowest: 3.7/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 is passing
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions important behavioral aspects: 'Shows workflows across all projects with their latest execution status,' 'Limit count to avoid token issues,' and 'Set verbose=True for execution history.' However, it doesn't cover critical details like pagination behavior, rate limits, authentication requirements, or what specific data is returned in the response.
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 purpose statement, scope clarification, use case scenarios, and parameter explanations in logical sections. It's appropriately sized for a 5-parameter tool with no annotations. Minor redundancy exists in repeating 'filter options' after listing scenarios, but overall it's efficient and front-loaded with the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters with 0% schema coverage and no output schema, the description does a reasonable job explaining parameter usage and common scenarios. However, for a list/monitoring tool with no annotations, it should ideally mention response format, pagination details, or what specific fields are returned. The absence of output schema means the description should provide more guidance on what data to expect.
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 well by explaining all 5 parameters: it clarifies 'status_filter' with allowed values ('success', 'error', 'running'), explains 'search' is for name filtering, describes 'verbose' provides execution history, mentions 'count' for limiting results, and implies 'include_system' (though not explicitly named). The only gap is not explicitly mentioning the 'include_system' parameter by name.
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: 'List all workflows to monitor executions and find failed jobs.' It specifies the verb ('list') and resource ('workflows') with additional context about monitoring and finding issues. However, it doesn't explicitly differentiate from sibling tools like 'td_list_projects' or 'td_list_sessions' beyond the workflow focus.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage scenarios with specific examples (e.g., 'Check which workflows are failing', 'Monitor currently running workflows'), which effectively guides when to use this tool. It mentions filtering options and common use cases, but doesn't explicitly state when NOT to use it or compare it to alternatives like 'td_find_workflow' or 'td_get_workflow'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that the file is 'temporarily stored on the server,' which is useful behavioral context beyond basic functionality. However, it doesn't mention authentication requirements, rate limits, file size constraints, or how long the temporary storage lasts, leaving gaps for a download operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, followed by details and parameter explanation. It avoids redundancy, but could be slightly more concise by integrating the parameter note into the main flow rather than a separate 'Args' section.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and low schema coverage, the description provides a solid foundation but lacks details on return values (only mentions 'return information about the download' vaguely), error handling, or operational constraints. It's minimally viable but has clear gaps for a tool that involves file downloads and server-side storage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the single parameter 'project_id' by explaining it refers to 'the ID of the workflow project to download,' which clarifies its purpose beyond the schema's minimal title 'Project Id.' With 0% schema description coverage and only one parameter, this compensation is adequate, though not exhaustive.
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 specific action ('download a project's archive') and resource ('Treasure Data workflow project'), distinguishing it from sibling tools like td_list_project_files or td_read_project_file. It specifies the output format (tar.gz) and content (SQL queries, Digdag files, Python scripts, resources).
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 by mentioning it downloads 'the complete archive' for a project, suggesting it's for bulk retrieval rather than individual file access. However, it doesn't explicitly state when to use this tool versus alternatives like td_list_project_files or td_read_project_file, nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the tool's purpose and output (health score, failure patterns, fixes) but lacks details on permissions, rate limits, or side effects. It adds some context like automated troubleshooting and trend analysis, but does not fully cover behavioral traits such as execution time or error handling.
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 a clear purpose statement, usage scenarios, parameter explanations, and return details. It is front-loaded with key information and uses bullet points for scenarios, making it efficient. However, some redundancy exists (e.g., repeating parameter info in 'Args' section), slightly reducing conciseness.
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 complexity (diagnostic analysis with 3 parameters), no annotations, and no output schema, the description is moderately complete. It covers purpose, usage, parameters, and returns, but lacks details on output structure, error cases, or integration with sibling tools. For a diagnostic tool, more behavioral and output specifics would enhance completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains each parameter's semantics: workflow_identifier accepts 'name, ID, or partial match,' time_window specifies periods like '30d,' and diagnostic_level defines 'basic' vs. 'comprehensive.' This adds meaningful context beyond the schema's basic titles, though it could detail format constraints more explicitly.
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 performs health checks for workflows to diagnose failures or slowness, using specific verbs like 'analyzes execution history,' 'identify patterns,' and 'calculate health scores.' It distinguishes itself from siblings like td_get_workflow or td_list_workflows by focusing on diagnostic analysis rather than retrieval or listing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage scenarios (e.g., 'Workflow suddenly failing,' 'Performance degradation') and mentions time windows and diagnostic levels, offering clear context for when to use it. However, it does not explicitly state when not to use it or name specific alternatives among siblings, such as td_analyze_execution, which might overlap in functionality.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that the tool returns 'names/IDs for navigation or verbose=True for details', indicating output behavior, and mentions project contents ('.dig files'). However, it lacks details on permissions, rate limits, pagination (beyond parameters), or error handling, which are important for a list operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose. The 'Common scenarios' section adds value without redundancy, though it could be slightly more streamlined by integrating scenarios into the main flow. Every sentence contributes to understanding the tool's use.
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 5 parameters with 0% schema coverage and no output schema or annotations, the description is incomplete. It covers the tool's purpose and some parameter semantics but lacks details on return format, error cases, or full parameter explanations. For a list tool with multiple parameters, this leaves gaps in operational context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains 'verbose=True for details' and 'exclude system with include_system=False', adding meaning to two parameters. It does not cover 'limit', 'offset', or 'all_results', but the context of listing and discovery implies their use for pagination, partially compensating for the low coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('workflow projects'), specifying they contain 'Digdag workflows, SQL queries, and Python scripts'. It distinguishes from siblings like td_get_project (detailed view) and td_find_project (search-based), making the scope explicit for discovery vs. retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear context for when to use this tool ('Discover available data processing workflows', 'Find specific project by browsing names', 'Get project IDs for detailed exploration'), and hints at exclusions ('exclude system with include_system=False'). However, it does not explicitly name alternatives like td_find_project for targeted searches, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly describes the read-only nature ('extracts and reads', 'returning its contents') and the specific use case, but it does not mention potential limitations like file size constraints, supported file types, error conditions, or authentication requirements. It adds some context but leaves behavioral gaps.
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 appropriately sized and front-loaded, with the core purpose in the first sentence and additional context in subsequent sentences. The Args section is clear but could be integrated more seamlessly. There is minimal waste, though some redundancy exists between the description and Args labels.
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 2 parameters with 0% schema coverage, no annotations, and no output schema, the description is moderately complete. It covers the purpose and parameters adequately but lacks details on return values (e.g., content format, error handling), behavioral constraints, and integration with sibling tools. It meets minimum viability but has clear gaps for a read operation 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?
Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics beyond the schema by explaining that 'archive_path' refers to 'a downloaded project archive (.tar.gz file)' and 'file_path' is 'the path of the file within the archive to read'. This clarifies the purpose and format of both parameters, though it could provide more detail on path syntax or 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?
The description clearly states the specific action ('Read the contents of a specific file') and resource ('from a project archive'), distinguishing it from siblings like td_list_project_files (which lists files) and td_download_project_archive (which downloads the entire archive). It explicitly mentions the tool's unique capability to examine files without fully extracting the archive.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('to examine SQL queries, workflow definitions, and other files without fully extracting the archive'), but it does not explicitly state when not to use it or name specific alternatives. It implies usage after downloading an archive but lacks explicit prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses that the tool 'extracts and lists' content, implying read-only behavior, but doesn't mention performance characteristics, error conditions, or output format details. It adds some behavioral context but leaves gaps about what 'lists' actually returns.
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 appropriately sized with three sentences: purpose statement, elaboration, and parameter explanation. The structure is front-loaded with the core purpose first. Minor improvement possible by integrating parameter info more seamlessly, but overall efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description adequately covers the basic operation and parameter, but doesn't explain what the listing output looks like (structure, format, limitations). For a tool with 1 parameter and simple operation, it's minimally complete but could better address output expectations.
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 (schema has no parameter descriptions), the description fully compensates by explaining the single parameter: 'archive_path: The path to the downloaded project archive (.tar.gz file)'. This adds crucial semantic meaning beyond the bare schema, specifying file type and 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 specific action ('List all files contained in a project archive') and distinguishes it from siblings like td_download_project_archive (which downloads) and td_read_project_file (which reads content). It specifies the resource (project archive files/directories) with precise scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context that this tool operates on 'a previously downloaded project archive', implying it should be used after td_download_project_archive. However, it doesn't explicitly state when NOT to use it or name alternatives for similar operations, missing full sibling differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses behavioral traits like 'Smart analysis tool that accepts URLs from error alerts or IDs' and 'Automatically detects type,' but lacks details on permissions, rate limits, or error handling. It mentions the return includes 'analysis with failures, slow tasks, and actionable recommendations,' which adds some context, but doesn't cover all behavioral aspects for a debugging tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose. It uses bullet points for clarity, but some sentences could be more concise (e.g., 'One-stop debugging for any execution issue' is slightly redundant). Overall, it's efficient with minimal waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and low schema coverage, the description is moderately complete. It covers purpose, usage, and parameter semantics adequately, but lacks details on behavioral aspects like error cases or output structure. For a debugging tool with 1 parameter, it's sufficient but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage. The description compensates by detailing what 'url_or_id' accepts: 'Console URLs (e.g., https://console.../app/sessions/123456), Session IDs (e.g., 123456789), Attempt IDs (e.g., 987654321).' This adds significant meaning beyond the schema, though it doesn't specify format constraints or validation rules.
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: 'Analyze workflow execution from console URL or ID - best for debugging.' It specifies the verb ('analyze'), resource ('workflow execution'), and scope ('from console URL or ID'), distinguishing it from siblings like td_get_session or td_get_attempt which likely fetch raw data rather than provide analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: 'best for debugging' and lists common scenarios such as 'Someone shares a workflow URL in Slack during incident' or 'Quick analysis when you only have an ID from logs.' It also implies alternatives by noting it's for 'comprehensive execution analysis' versus siblings that might retrieve specific data (e.g., td_get_attempt).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes what information is returned (creation time, table count, permissions, protection status) and implies a read-only operation ('Get', 'Shows'), but doesn't specify error handling, rate limits, or authentication requirements. It adds some behavioral context but lacks details on potential failures or constraints.
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 a clear opening sentence, usage guidance, and bullet-pointed scenarios. It's appropriately sized for the tool's complexity, though the bullet points could be slightly condensed. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (1 parameter, no output schema, no annotations), the description is fairly complete. It covers purpose, usage, scenarios, and return values. However, it lacks explicit error handling or performance details, which would be helpful for a tool that queries database metadata.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, and the description doesn't explicitly mention the 'database_name' parameter. However, it implies the parameter through context ('named database', 'specific database'), and with only 1 parameter, the baseline is high. The description adds meaning by clarifying what the parameter represents (a specific database to query), compensating somewhat for the schema 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's purpose with specific verbs ('Get', 'Shows') and resources ('database details', 'information about a named database'). It distinguishes from sibling tools like 'td_list_databases' (which likely lists databases) by focusing on retrieving detailed information for a specific database.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use the tool ('Use when you need to check database properties, understand access permissions, or get table statistics') and provides common scenarios (e.g., verifying existence, checking permissions, auditing). It distinguishes from alternatives by focusing on detailed metadata rather than listing or analyzing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses key behavioral traits: it returns 'workflow IDs, project info, and latest execution status' and explains filtering options. However, it doesn't mention pagination, rate limits, authentication needs, or error handling, leaving gaps for a search tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose. Each sentence adds value: purpose statement, importance, return values, scenarios, and parameter guidance. There's no redundancy, and the bulleted scenarios efficiently convey usage without verbosity.
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 4 parameters, 0% schema coverage, no annotations, and no output schema, the description does a strong job. It explains purpose, usage, parameters, and return values. However, it doesn't fully describe output structure (e.g., format of returned data) or error cases, leaving minor gaps for a tool with no structured support.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds significant meaning: it explains that 'project_name' is optional, 'status' filter accepts specific values ('success', 'error', 'running'), and clarifies 'exact_match' parameter usage ('True for precise names, False for partial matches'). This covers 3 of 4 parameters well, though 'search_term' semantics are implied but not detailed.
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: 'Find workflows by name to get IDs and check execution status.' It specifies the verb ('find'), resource ('workflows'), and distinguishes from siblings like td_list_workflows (which likely lists all workflows) by focusing on search-by-name functionality.
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 provides explicit guidance on when to use this tool: 'Essential for locating specific workflows when you know the name.' It lists five common scenarios (e.g., 'User mentions workflow name, need to find details') and distinguishes from alternatives by emphasizing name-based search rather than listing or analyzing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's read-only nature (implied by 'get' and 'investigate') and specifies what information is returned ('attempt status, timing, retry info, and safe execution parameters'). However, it doesn't mention potential limitations like rate limits, authentication requirements, or error handling for invalid attempt IDs.
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 and front-loaded with the core purpose, followed by usage guidance and scenarios. Every sentence adds value: the first defines the tool, the second explains when to use it, the bullet points illustrate use cases, and the final sentence clarifies return values. There is no wasted text.
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 moderate complexity (single parameter, no annotations, no output schema), the description is largely complete. It covers purpose, usage, and return values adequately. However, without an output schema, it could benefit from more detail on the structure of returned data (e.g., specific fields in 'attempt status' or 'timing'), though the mention of 'safe execution parameters' hints at security considerations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage (no parameter descriptions), but the description compensates by explaining the semantics of the single parameter 'attempt_id'—it's obtained 'from error logs or td_get_session' and used to 'investigate specific execution instance.' This adds meaningful context beyond the schema's basic type information, though it doesn't specify format constraints (e.g., UUID).
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 with specific verbs ('get', 'investigate') and resource ('workflow attempt details'), distinguishing it from siblings like td_get_session (which provides session info) and td_get_attempt_tasks (which focuses on tasks within an attempt). It explicitly defines what an attempt is ('one execution try of a scheduled session'), avoiding tautology.
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 provides explicit guidance on when to use this tool ('when you have an attempt ID from error logs or td_get_session and need execution details') and lists four common scenarios. It also distinguishes from alternatives by referencing td_get_session as a source for attempt IDs, though it doesn't explicitly say 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context: it's a 'shortcut' that 'Combines find + get operations,' requires 'exact name match,' and returns 'full project details' including 'revision/timestamps.' However, it doesn't mention error handling, permissions, or rate limits, leaving some behavioral gaps.
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 and front-loaded with the core purpose. Each sentence adds value: explaining the shortcut benefit, common scenarios, constraints, and alternatives. There's no wasted text, and it efficiently conveys necessary information in a concise manner.
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 moderate complexity (1 parameter, no output schema, no annotations), the description is largely complete. It covers purpose, usage, constraints, and alternatives. However, without annotations or output schema, it could benefit from more detail on return values or error cases, though the mention of 'full project details' and sibling tool equivalence helps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage. The description compensates by explaining the parameter's purpose: 'using exact name' and 'Requires exact name match.' It adds meaning beyond the schema's bare title ('Project Name'), though it doesn't specify format constraints like case sensitivity.
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: 'Get full project details using exact name instead of ID.' It specifies the verb ('Get'), resource ('full project details'), and method ('using exact name'), distinguishing it from sibling tools like td_get_project (which uses ID) and td_find_project (which does fuzzy search).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: 'when you know the exact project name' and 'Common scenarios' like quick metadata lookup. It also provides clear alternatives: 'For fuzzy search use td_find_project' and notes it 'Returns same details as td_get_project but using name lookup,' effectively distinguishing it from siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes the tool as a read operation ('Get') and outlines what information is returned, but it lacks details on error handling, rate limits, or authentication requirements. The behavioral context is adequate but not comprehensive for a 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 well-structured and front-loaded with the core purpose, followed by usage guidelines and common scenarios. Each sentence adds value without redundancy, making it efficient and easy to parse for an AI agent.
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 no annotations and no output schema, the description does a good job covering the tool's purpose, usage, and return values ('Returns session info with workflow name, schedule time, and latest attempt status.'). However, it could be more complete by addressing potential errors or limitations, but it's sufficient for basic understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, so the description must compensate. It explains that the parameter 'session_id' is used to 'Get workflow session details by ID,' adding semantic meaning beyond the schema. However, it doesn't specify format or constraints for the ID, leaving some gaps.
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 with specific verb+resource: 'Get workflow session details by ID to check execution status and timing.' It distinguishes from sibling tools like td_list_sessions (which lists sessions) and td_get_attempt (which gets attempt details), making the scope and differentiation 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?
The description provides explicit guidance on when to use this tool: 'Use when you have a session ID and need to check if it ran successfully, when it was scheduled, or get attempt details.' It also lists common scenarios that clarify the context, such as verifying execution times or getting attempt IDs for investigation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the tool 'Handles large workflow IDs that exceed pagination limits' (a useful behavioral trait) and describes the return content. However, it doesn't cover important aspects like error handling, rate limits, authentication requirements, or whether it's read-only (though implied by 'Get').
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 and front-loaded with the core purpose. Every sentence adds value: the first states the purpose, the second explains usage context, the third describes behavioral capability, the fourth outlines return content, the bulleted scenarios provide concrete examples, and the final section details return values. 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?
For a single-parameter read operation with no output schema, the description provides excellent context about usage scenarios, behavioral capabilities, and return values. The main gap is the lack of error handling or rate limit information, but given the tool's simplicity and the detailed usage guidance, it's mostly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage (no parameter descriptions), but the description compensates well. It explains that 'workflow_id' is a 'numeric ID' used for 'direct workflow lookup' and provides context about where these IDs come from (console URLs, error logs). However, it doesn't specify format constraints (e.g., numeric string vs. integer).
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 with specific verbs ('Get workflow details', 'Direct workflow lookup') and identifies the resource ('workflow details using numeric ID'). It distinguishes from siblings like 'td_list_workflows' (which lists workflows) and 'td_find_workflow' (which likely searches) by emphasizing direct ID-based lookup.
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 provides explicit guidance on when to use this tool: 'Direct workflow lookup when you have the ID' and lists four common scenarios with concrete examples (extracting ID from URLs, error logs, project context, status checking). It implicitly distinguishes from alternatives by focusing on ID-based access rather than listing or searching.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it 'downloads and examines all files' (resource-intensive operation), provides three analysis levels with defaults, specifies focus areas, and describes return content ('file structure, code patterns, issues, and recommendations'). However, it doesn't mention potential limitations like execution time, permission requirements, or data size constraints that would be helpful for a comprehensive analysis tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose in the first sentence. Each subsequent section (common scenarios, analysis levels, focus areas, returns) adds value without redundancy. Minor improvement could be tighter phrasing in the scenarios list, but overall structure is logical and information-dense without wasted sentences.
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 complex analysis tool with 3 parameters, 0% schema coverage, no annotations, and no output schema, the description does remarkably well by covering purpose, usage scenarios, analysis levels, focus areas, and return content. The main gap is lack of output format details (structure of returned analysis) and any error/edge case handling. Given the complexity, it provides substantial context but not complete operational guidance.
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 for 3 parameters, the description compensates well by explaining parameter semantics: it defines three 'analysis levels' (mapping to analysis_depth), lists 'focus areas' with examples, and implies identifier is for project selection. While it doesn't explicitly name each parameter, it provides meaningful context about what they control. The gap is it doesn't explain identifier format or focus_areas array constraints.
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 with specific verbs ('deep-dive', 'analyzes', 'downloads and examines') and resources ('project', 'files'). It distinguishes from siblings by emphasizing comprehensive analysis versus more targeted tools like td_list_project_files or td_read_project_file. The description explicitly answers 'What does this project do?' which directly addresses the core purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool through 'Common scenarios' listing five specific use cases (e.g., 'Onboarding to new codebase', 'Debugging workflow failures'). It also distinguishes from alternatives by positioning this as a 'comprehensive project analyzer' versus more focused sibling tools like td_analyze_execution or td_diagnose_workflow. The guidance covers both when to use and implied when-not-to-use scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does well: it explains the smart parsing behavior, automatic type detection, and returns full resource information. However, it doesn't mention error handling for invalid URLs or rate limits. No contradiction exists since annotations are absent.
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 purpose first, usage guidelines, scenarios, supported formats, and behavioral note. Every sentence adds value: no repetition, no fluff. The bullet points enhance readability without wasting space.
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 single-parameter tool with no annotations or output schema, the description is quite complete: purpose, usage, scenarios, supported formats, and behavior. It could improve by detailing the output structure or error cases, but it's sufficient for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% (parameter 'url' has no description in schema), but the description compensates well by explaining what the URL should be: 'Treasure Data console URL' with three specific format examples. It adds meaning beyond the bare schema, though it could specify URL validation rules.
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: 'Analyze any Treasure Data console URL to get resource details' with specific verbs (analyze, extracts IDs, fetches information). It distinguishes from siblings by focusing on URL parsing rather than direct resource lookup (e.g., td_get_project, td_get_workflow).
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?
Explicit guidance is provided: 'Use when someone shares a console link in Slack, email, or documentation' with four specific scenarios listed. It clearly indicates when this tool is appropriate versus using direct resource-fetching siblings like td_get_project or td_get_workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior: it searches all projects, returns matches with IDs/names/metadata, supports both exact and fuzzy matching via the exact_match parameter, and is designed for lookup operations (implied read-only, non-destructive). It doesn't mention rate limits, authentication needs, or pagination, but covers core functionality well for a search tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and efficiently written. It starts with the core purpose, explains utility, lists common scenarios, provides parameter guidance, and describes returns—all in 7 concise sentences with zero wasted words. Each sentence adds value, and information is front-loaded appropriately.
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 no annotations and no output schema, the description does an excellent job covering the tool's context. It explains purpose, usage, parameters, and return values (project IDs, names, metadata). The main gap is lack of explicit mention of read-only/non-destructive nature (though implied), but for a search tool with 2 simple parameters, this is nearly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds significant semantic value: it explains that 'search_term' is for project names/keywords, clarifies that 'exact_match=True' enables precise name matching while 'False' enables fuzzy search, and connects parameters to the tool's purpose. This goes well beyond the bare schema, though it doesn't detail format constraints for search_term.
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: 'Find project by name when you don't know the exact ID. Searches all projects and returns matches.' It specifies the verb ('find'), resource ('project'), and scope ('by name'), and distinguishes it from siblings like td_get_project (which likely requires ID) and td_get_project_by_name (which might be exact-match only).
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 provides explicit guidance on when to use this tool: 'Useful when you know project name but need the ID for other operations like downloading archives.' It lists common scenarios (e.g., user mentions project name, looking for keywords) and names a specific alternative use case ('Getting project ID before using td_download_project_archive'). It also distinguishes from exact-match alternatives by mentioning fuzzy search capability.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does well by specifying the tool's purpose (debugging), output format ('task list with names, states, timing, and failure details'), and behavioral context (identifying failed/slow steps). It doesn't mention rate limits, authentication needs, or pagination, but provides substantial 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 well-structured and front-loaded with the core purpose, followed by bulleted scenarios and output details. Every sentence adds value without redundancy, making it efficient and easy to parse.
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 tool with no annotations, no output schema, and low schema coverage, the description does well by explaining purpose, usage scenarios, and output format. It could improve by explicitly describing the 'attempt_id' parameter and potential error cases, but is largely complete for a debugging-focused 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?
With 0% schema description coverage and 1 parameter, the description compensates by implying the parameter's purpose through context ('workflow execution'), though it doesn't explicitly explain 'attempt_id'. The description adds value by clarifying what the tool analyzes, but could better define the parameter's role.
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 specific verb ('Get task breakdown') and resource ('workflow execution'), distinguishing it from siblings like td_get_attempt or td_diagnose_workflow by focusing on individual task-level details rather than overall execution status or workflow-level diagnostics.
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 provides explicit usage scenarios with 'Common scenarios' listing four specific cases (debugging failures, identifying slow tasks, understanding dependencies, debugging data issues), clearly indicating when to use this tool versus alternatives like td_get_attempt for high-level status or td_diagnose_workflow for broader diagnostics.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior: it's a read-only operation (implied by 'list', 'monitor', 'check'), returns recent executions with filtering capability, and specifies the return content (list with workflow names, execution times, success/failure status). However, it doesn't mention pagination, rate limits, or authentication requirements, which would be helpful for a production monitoring 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 perfectly structured and concise: it starts with a clear purpose statement, provides usage guidance in the second paragraph, lists common scenarios in bullet points for quick scanning, and ends with return value information. Every sentence earns its place, with no redundant or vague language.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description provides excellent contextual completeness. It covers purpose, usage, parameters, return values, and common scenarios. The only minor gap is the lack of explicit mention of the 'count' parameter name and its effect on 'recent' definition, but overall it provides sufficient context for effective tool selection and use.
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 must compensate for the undocumented parameters. It successfully explains both parameters: 'workflow_id' is described as a filter for specific workflow history (with option to leave empty), and 'count' is implied through 'recent' and the default value context. While it doesn't explicitly name 'count' or specify numeric ranges, it provides meaningful semantic context that significantly enhances understanding beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('list recent workflow executions', 'monitor status', 'find failures') and distinguishes it from siblings by focusing on execution sessions rather than workflows, projects, or other resources. It explicitly identifies the resource as 'recent scheduled runs (sessions)' with their execution status.
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 provides explicit guidance on when to use this tool versus alternatives: 'Filter by workflow ID to see history of a specific workflow, or leave empty for all.' It also lists common scenarios (check recent runs, find failures, monitor patterns, get session IDs) and implicitly distinguishes it from sibling tools like td_get_session (detailed analysis) and td_list_workflows (workflow listings rather than executions).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: the tool returns table names (or schemas/sizes/counts with verbose=True), supports pagination via limit/offset, and offers an all_results option. However, it doesn't mention potential rate limits, authentication requirements, or error conditions.
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 and front-loaded with the core purpose, followed by specific details and usage scenarios. Every sentence adds value: the first establishes purpose, the second explains output options, the scenarios provide concrete guidance, and the final sentence covers pagination behavior. 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?
For a tool with 5 parameters, 0% schema coverage, and no output schema, the description does an excellent job covering purpose, usage, and key behaviors. It explains what information is returned and how to control output. The main gap is lack of information about return format/structure since there's no output schema, but otherwise it's quite complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate for the lack of parameter documentation in the schema. It explains the purpose of 'verbose' (shows schemas, sizes, record counts) and mentions 'limit/offset' and 'all_results' for pagination control. However, it doesn't explain 'database_name' parameter semantics or provide format/validation details.
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 specific action ('List tables in a database') and resource ('tables'), distinguishing it from sibling tools like td_list_databases or td_list_projects. It explicitly mentions exploring data structure and finding datasets, which provides concrete purpose beyond just the tool name.
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 provides explicit guidance through 'Common scenarios' that detail when to use this tool (e.g., explore available data, find specific tables, check schemas before queries). It also distinguishes usage by mentioning verbose mode for different information needs, though it doesn't explicitly name alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: the tool returns ranked results with relevance scores (0-1), supports multiple search modes (exact, fuzzy, semantic) and scopes (all, projects, workflows, tables), and defaults to fuzzy search and 'all' scope. It doesn't mention rate limits, authentication needs, or pagination, but covers core operational traits well.
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 and front-loaded: it starts with the core purpose, then usage guidelines, common scenarios, and technical details. Every sentence adds value—no fluff or repetition. It uses bullet points for readability without wasting space, making it efficient for an AI agent to parse.
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 (5 parameters, no annotations, no output schema), the description does a strong job. It covers purpose, usage, behaviors, and some parameter semantics. Gaps include no output format details (though it mentions relevance scores) and incomplete parameter coverage. For a search tool with moderate complexity, this is nearly complete but could slightly enhance parameter documentation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaningful context for parameters: it explains search_mode options (exact, fuzzy, semantic) and scopes (all, projects, workflows, tables), which aren't in the schema. However, it doesn't cover active_only or min_relevance parameters. The description provides substantial value beyond the bare schema but doesn't fully document all parameters.
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: 'Universal search across Treasure Data - best for broad queries. One-stop search for projects, workflows, and tables with smart ranking.' It specifies the verb ('search'), resources ('projects, workflows, and tables'), and distinguishes it from siblings by emphasizing its broad, cross-resource nature versus more specific lookup tools like td_find_project or td_get_workflow.
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 provides explicit guidance on when to use this tool: 'Use when unsure what resource type you're looking for or need comprehensive results.' It lists common scenarios (e.g., 'Broad exploration of available data assets') and contrasts with more targeted tools by implication, as siblings include specific find/get tools for individual resource types.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes what the tool does (traces through SQL queries to build dependency graph), what it returns (visual-ready dependency tree), and its operational characteristics (default values for direction and max_depth). It doesn't mention performance characteristics like rate limits or authentication requirements, but provides substantial 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, scenarios, directions, args, returns) and front-loaded with the core functionality. While somewhat lengthy, every section adds value. The 'Common scenarios' section could be more concise, but overall the structure enhances readability.
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 3-parameter tool with no annotations and no output schema, the description provides comprehensive context. It covers purpose, usage scenarios, parameter semantics, and return format. The main gap is the lack of output schema details, but the description adequately explains what the tool returns ('visual-ready dependency tree with table/project relationships').
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 providing detailed parameter semantics. It explains table_or_project format ('database.table'), direction options and their meanings (upstream=sources, downstream=consumers, both=complete graph), and max_depth behavior ('Maximum levels to trace'). This adds significant value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('Map data flow', 'Traces through SQL queries') and resources ('tables/projects'). It distinguishes this tool from siblings by focusing on data lineage/dependency analysis rather than general analysis, search, or listing operations found in other tools like td_analyze_execution or td_list_tables.
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 provides explicit guidance on when to use this tool through 'Common scenarios' (impact analysis, source tracing, data quality issues, migration planning, documentation) and 'Directions' (upstream, downstream, both). It clearly defines the tool's specific use cases without being misleading about alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes what the tool returns ('project information including creation time, last update, and revision hash') and provides practical usage scenarios. However, it doesn't mention error conditions, rate limits, or authentication requirements, which would be helpful for a complete behavioral picture.
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 and front-loaded with the core purpose. Every sentence adds value: the opening statement defines the tool, the second describes returns, the third provides prerequisites, the bulleted scenarios offer practical context, and the final notes clarify parameter format and alternatives. 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?
For a single-parameter read operation with no annotations or output schema, the description provides excellent context about what information is returned and how to use the tool. It covers purpose, prerequisites, alternatives, and parameter semantics well. The main gap is lack of information about return format structure or error conditions, which would be helpful given no output schema.
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 input schema has 0% description coverage, so the description must fully compensate. It provides crucial semantic information about the project_id parameter: 'Use numeric project ID (e.g., "123456") not project name.' This clarifies the expected format and distinguishes it from project_name alternatives, adding significant value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get workflow project details by ID') and resource ('project'), distinguishing it from siblings like td_get_project_by_name (which uses name instead of ID) and td_download_project_archive (which retrieves contents rather than metadata). The opening sentence provides a precise verb+resource combination with clear scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('Use after finding project ID from td_list_projects') and when not to use it ('For project contents, use td_download_project_archive'). It provides clear alternatives and prerequisites, with specific sibling tool names mentioned for context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it's a read operation (implied by 'List'), returns names or details based on verbose flag, supports pagination, and can fetch all results. However, it doesn't mention rate limits, authentication needs, or error handling, leaving some gaps.
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 and front-loaded with the core purpose. Each sentence earns its place: the first states the action, the second explains output options, the third lists usage scenarios, and the fourth covers pagination. There is no wasted text, making it efficient and clear.
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 moderate complexity (4 parameters, no output schema, no annotations), the description is largely complete. It covers purpose, usage, parameters, and behavior. However, it lacks details on output format (e.g., structure of returned data) and error cases, which would enhance completeness for a tool with no output schema.
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 significant meaning beyond the schema: explains that verbose=True returns details like 'table count and permissions,' and clarifies that pagination (limit/offset) is for 'large lists' while all_results=True fetches 'everything.' This provides essential context not in 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 specific action ('List available databases') and resource ('databases'), distinguishing it from siblings like td_list_tables or td_list_projects. It explicitly mentions the purpose is to 'find data sources and check access,' providing clear differentiation.
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 provides explicit guidance on when to use this tool through 'Common scenarios' (e.g., 'Discover what databases are available,' 'Check permissions,' 'Get database list for documentation'). It also mentions usage patterns like pagination for large lists, offering clear context without exclusions.
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:

[![td-mcp-server MCP server](https://glama.ai/mcp/servers/knishioka/td-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/knishioka/td-mcp-server)

Score Badge

Copy to your README.md:

[![td-mcp-server MCP server](https://glama.ai/mcp/servers/knishioka/td-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/knishioka/td-mcp-server)

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/knishioka/td-mcp-server'

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