Provides tools for interacting with Git repositories via a proxied MCP server, enabling operations like status, log, and more.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ToolMux list all available tools from my servers"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Efficient MCP server aggregation with FastMCP 3.x foundation
ToolMux proxies multiple MCP (Model Context Protocol) servers through a single interface, reducing token overhead while maintaining full tool access. It supports five operating modes optimized for different use cases.
Related MCP server: MCP Server Proxy
FastMCP 3.x Foundation — Proper MCP protocol compliance via FastMCP framework
Five Operating Modes — Meta (80%+ savings), Gateway (60%+ savings), Proxy (native fastmcp), Search (85%+ savings), Code (90%+ savings)
Native Proxy Mode — Uses fastmcp 3.0's create_proxy() for true transparent proxying with session isolation and MCP feature forwarding
CondenseTransform — Token optimization via fastmcp's Transform system: condensed descriptions/schemas in tools/list, full details on demand via helper tools
Smart Description Condensation — First-sentence extraction with filler phrase removal
Schema Condensation — Strips verbose extras, keeps names/types/required
Progressive Disclosure — Full descriptions via list_all_tools() and get_tool_schema(), condensed in tools/list
Self-Healing Bundle Resolution — Auto-resolves broken server configs from mcp-registry, user bundles, XDG, Claude Desktop, and Cursor bundles
Parallel Backend Init — Thread pool (10 workers, 30s timeout) for fast startup
MCP Instructions — All modes embed instructions in the MCP initialize response telling the LLM to call list_all_tools() first
LLM-Powered Description Optimization — optimize_descriptions tool lets the connected LLM generate high-quality tool descriptions, replacing algorithmic condensation
Tool Collision Resolution — Automatic server-name prefixing for duplicate tool names
# Via PyPI
pip install toolmux
# Via uvx (recommended, no install needed)
uvx toolmux
# From source
git clone https://github.com/subnetangel/ToolMux.git
cd ToolMux
pip install -e .
# Verify
toolmux --versionCreate ~/shared/toolmux/mcp.json (or ~/toolmux/mcp.json):
{
"mode": "gateway",
"servers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user"]
},
"git": {
"command": "uvx",
"args": ["mcp-server-git", "--repository", "/path/to/repo"]
}
}
}# Default gateway mode
toolmux
# Specific mode
toolmux --mode meta
toolmux --mode proxy
# Custom config
toolmux --config /path/to/mcp.jsonAdd to your MCP client configuration (e.g., Claude Desktop, Cursor, Kiro, VS Code):
{
"mcpServers": {
"toolmux": {
"command": "toolmux",
"args": ["--mode", "gateway"]
}
}
}ToolMux offers three modes that trade off between token savings and tool transparency. All modes share a common set of helper tools (list_all_tools, get_tool_schema, get_tool_count, manage_servers, optimize_descriptions) and embed MCP instructions telling the LLM to call list_all_tools() first.
Gateway (default) | Meta | Proxy | Search (new) | Code (new) | |
Token savings | ~60-85% | ~80-93% | ~69% | ~85-95% | ~90-97% |
tools/list size | 1 tool per server + helpers | 5 meta-tools | All backend tools (condensed) | 2 synthetic + helpers | 3 synthetic + helpers |
Tool invocation |
|
|
|
|
|
Backend init | BackendManager (parallel threads) | BackendManager (parallel threads) | fastmcp | fastmcp | fastmcp |
Best for | Balanced savings + usability | Maximum savings, many servers | Full MCP compliance, advanced features | Large catalogs (100+ tools) | Multi-step workflows |
Collapses each backend server into a single tool. The LLM sees one tool per server (e.g., filesystem, git) instead of dozens of individual tools. Each server-tool's description lists all its sub-tools with their purpose and required parameters.
How it works:
On startup, BackendManager initializes all backends in parallel (10-worker thread pool, 30s timeout). If a build cache exists (.toolmux_cache.json), tools are loaded instantly from cache and backends init in the background.
Tools are grouped by server. For each server, a single FastMCP tool is registered with a rich description listing all sub-tools (e.g., "Tools: read_file (Read complete file contents; required: path), write_file (...), ...").
The LLM calls list_all_tools() first to discover all available tools with full descriptions.
To invoke a sub-tool, the LLM calls the server-tool with tool= and arguments= parameters: filesystem(tool="read_file", arguments={"path": "/tmp/example.txt"}).
On first invocation of each sub-tool, the response is enriched with the full description and parameter schema (progressive disclosure). On errors, the full schema is always appended.
tools/list returns:
- filesystem (server-tool): "Tools: read_file, write_file, ..."
- git (server-tool): "Tools: git_status, git_log, ..."
- list_all_tools (native): MUST call first — full descriptions grouped by server
- get_tool_schema (native): Get full parameter details for any tool
- get_tool_count (native): Get tool count statistics by server
- manage_servers (native): Add, remove, validate, test backend servers
- optimize_descriptions (native): LLM-powered description optimization
Calling pattern:
list_all_tools() # discover all tools with full descriptions
filesystem(tool="read_file", arguments={"path": "/tmp/example.txt"})Token savings mechanism: Instead of exposing N tools with full descriptions and schemas in tools/list, gateway exposes ~S server-tools (where S << N) plus helper tools. Descriptions are condensed to first-sentence + required params. Full details are disclosed progressively on first use.
Exposes only 5 generic meta-tools regardless of how many backend tools exist. The LLM discovers tools via list_all_tools() / catalog_tools(), inspects schemas via get_tool_schema(), and executes via invoke().
How it works:
Same BackendManager parallel init as gateway mode.
Instead of registering per-server or per-tool entries, 5 fixed tools are registered: list_all_tools, catalog_tools, get_tool_schema, invoke, get_tool_count.
catalog_tools() returns a JSON array of all backend tools with name, server, condensed description, and parameter names.
get_tool_schema(name="tool_name") returns the full description and inputSchema for a specific tool.
invoke(name="tool_name", args={...}) routes the call to the correct backend server. Results are enriched with full docstrings on first invocation.
tools/list returns:
- list_all_tools: MUST call first — full descriptions grouped by server
- catalog_tools: List all backend tools with name, server, description
- get_tool_schema: Get full schema for a tool
- invoke: Execute a backend tool
- get_tool_count: Tool count by server
- manage_servers: Add, remove, validate, test backend servers
- optimize_descriptions: LLM-powered description optimization
Workflow: list_all_tools() → get_tool_schema("tool") → invoke("tool", args)Token savings mechanism: tools/list always returns exactly 7 tools (5 meta + 2 management) regardless of backend count. A setup with 200 backend tools still only shows 7 in tools/list. The tradeoff is an extra round-trip: the LLM must call get_tool_schema() before invoke() to know the parameters.
Uses fastmcp 3.0's native create_proxy() for true transparent proxying. All backend tools are exposed directly — the LLM calls them by name just like normal MCP tools. Token optimization is applied via CondenseTransform, which condenses descriptions and schemas in tools/list while helper tools return full uncondensed details.
How it works:
Server configs are converted to standard mcpServers format and passed to create_proxy(), which creates a FastMCP proxy with MCPConfigTransport for each backend.
CondenseTransform (a fastmcp Transform subclass) is applied to the proxy. It intercepts tools/list responses and replaces each tool's description with a condensed version (first sentence, filler removed, max 80 chars) and each schema with a minimal version (property names + types + required only).
Helper tools (list_all_tools, get_tool_schema, get_tool_count) are registered directly on the proxy. They query the proxy's internal tool list before the transform is applied, so they return full uncondensed descriptions and schemas.
For multi-server setups, tools are prefixed as {server}_{tool} (e.g., filesystem_read_file). Single-server setups leave tools unprefixed.
Sessions are persistent and reused across tool calls (fastmcp 3.1.1+).
tools/list returns all backend tools with CONDENSED descriptions/schemas.
- Single server: tools unprefixed (echo_tool)
- Multi server: tools prefixed as {server}_{tool}
Helper tools (return FULL uncondensed info):
- list_all_tools(): MUST call first — full descriptions grouped by server
- get_tool_schema(name): full description + full inputSchema
- get_tool_count(): tool counts by server
- manage_servers: Add, remove, validate, test backend servers
Call directly: echo_tool(message="hello")Proxy mode features:
True transparent proxying via fastmcp's MCPConfigTransport
Session isolation per request
Automatic MCP feature forwarding (sampling, elicitation, logging, progress)
CondenseTransform for ~69% token reduction in tools/list
Progressive disclosure: condensed by default, full on demand via helper tools
Token savings mechanism: All tools appear in tools/list (unlike gateway/meta), but descriptions are condensed from paragraphs to single sentences and schemas are stripped to names/types/required. The LLM calls list_all_tools() once to get full descriptions, then calls tools directly.
Uses FastMCP's BM25SearchTransform to replace the full tool catalog with ranked search. The LLM discovers tools by querying search_tools(query="what I need") and gets back only the top-k relevant results. Execution via call_tool(name, arguments).
How it works:
Same per-server proxy setup as proxy mode (error isolation, session persistence)
BM25SearchTransform intercepts tools/list — replaces all backend tools with search_tools and call_tool
BM25 indexes tool names, descriptions, and parameter names for natural language ranking
Helper tools (list_all_tools, get_tool_schema, get_tool_count) bypass the transform for full catalog access
tools/list returns:
- search_tools: Find tools by natural language query (BM25 ranked)
- call_tool: Execute any tool by name
- list_all_tools: Full catalog grouped by server
- get_tool_schema: Full parameter details
- get_tool_count: Tool count statistics
- manage_servers: Backend management
Workflow: search_tools("read file") → call_tool("filesystem_read_file", {"path": "..."})Token savings mechanism: The LLM never sees tools it doesn't need. A search for "calendar" against 258 tools returns ~10 relevant results (~400 tokens) instead of the full catalog (~5,000 tokens).
Uses FastMCP's experimental CodeMode transform for sandboxed multi-step execution. The LLM discovers tools via BM25 search, then writes Python code that chains multiple call_tool() calls in a sandbox. Intermediate results stay in the sandbox — only the final result enters the context window.
How it works:
Same per-server proxy setup as proxy mode
CodeMode replaces tools with search, get_schema, and execute
execute(code) runs Python in a pydantic-monty sandbox with call_tool() available
Multiple tool calls can be chained in a single execute() invocation
Helper tools bypass the transform for full catalog access
tools/list returns:
- search: Find tools by query (BM25 ranked, with detail levels)
- get_schema: Get parameter details for specific tools
- execute: Run Python code with call_tool() in sandbox
- list_all_tools: Full catalog grouped by server
- get_tool_count: Tool count statistics
- manage_servers: Backend management
Workflow: search("calendar") → get_schema(["calendar_view"]) → execute("result = await call_tool(...)")Token savings mechanism: Multi-step workflows execute in one round-trip. Intermediate results (e.g., raw API responses passed between tools) never enter the context window — they exist only inside the sandbox.
All modes use progressive disclosure to minimize tokens while keeping full information accessible:
tools/list — Condensed descriptions and schemas (what the LLM sees on connect)
list_all_tools() — Full descriptions grouped by server (LLM calls this first)
get_tool_schema(name) — Full description + complete inputSchema for a specific tool
First-use enrichment (gateway/meta only) — On the first invocation of each tool, the response includes the full description and parameter schema appended to the result
The condense_description() function:
Normalizes whitespace (collapses newlines and multiple spaces)
Removes filler phrases ("Use this tool to", "This tool allows you to", etc.)
Capitalizes the first letter after filler removal
Extracts the first sentence (up to ., !, or ?)
Trims to 80 characters without cutting mid-word
The condense_schema() function strips schemas down to:
Property names and types
Array item types
Required field list
Removed: descriptions, defaults, examples, enums, pattern constraints, nested object details.
The optimize_descriptions tool lets the connected LLM generate higher-quality descriptions than the algorithmic condensation:
optimize_descriptions(action="generate") — Returns all tools with full descriptions
The LLM writes concise (<60 char) descriptions for each tool
optimize_descriptions(action="save", server="name", descriptions={...}) — Saves to cache
Restart ToolMux to use the optimized descriptions
Use optimize_descriptions(action="status") to check if descriptions have been optimized.
ToolMux caches tool descriptions in .toolmux_cache.json next to the config file. The cache is validated against a SHA-256 hash of mcp.json — any config change invalidates it.
Cache hit: Tools load instantly from cache. Backends init in the background for actual tool calls.
Cache miss: Server names are registered as placeholders immediately (so mcp.run() starts without delay). Backends init in the background. A cache is auto-generated once backends finish.
The manage_servers tool provides runtime server management:
manage_servers(action="list") — List all configured servers
manage_servers(action="add", name="my-mcp", command="cmd") — Add a server (auto-resolves from bundles if no command given)
manage_servers(action="remove", name="my-mcp") — Remove a server
manage_servers(action="validate") — Check all server commands exist on PATH
manage_servers(action="test", name="my-mcp") — Start server and verify it returns tools
When a configured server command fails or returns 0 tools, ToolMux automatically searches for the correct launch config in these locations (in order):
mcp-registry bundles (~/.config/smithy-mcp/bundles/)
User bundles (~/.aim/bundles/)
XDG mcp config (~/.config/mcp/mcp.json)
Claude Desktop (~/.claude/claude_desktop_config.json)
Cursor (~/.cursor/mcp.json)
If a fix is found, it's persisted back to mcp.json so it only happens once.
toolmux [OPTIONS]
Options:
--mode {gateway,meta,proxy,search,code} Operating mode (default: gateway)
--config PATH Path to mcp.json config file
--version Print version and exit
--list-servers List configured servers and exit
--build-cache Generate LLM description cache and exit
--manage [list|add|remove|validate|test] Manage backend servers--config flag (explicit path)
./mcp.json (project-local)
~/shared/toolmux/mcp.json (shared environments — persists across sessions)
~/toolmux/mcp.json (local installs)
First-run setup creates ~/shared/toolmux/mcp.json
{
"mode": "gateway",
"cache_model": "us.anthropic.claude-3-5-haiku-20241022-v1:0",
"servers": {
"server-name": {
"command": "npx",
"args": ["-y", "package-name"],
"env": {"KEY": "value"},
"cwd": "/optional/working/dir",
"description": "Optional human description"
},
"http-server": {
"transport": "http",
"base_url": "https://api.example.com/mcp",
"headers": {"Authorization": "Bearer token"},
"timeout": 30
}
}
}MCP Client (Agent/IDE)
↕ stdio JSON-RPC
FastMCP Server (ToolMux)
├── Mode Router → meta | gateway | proxy | search | code
│
├── Gateway/Meta Mode
│ ├── BackendManager (parallel init, tool routing)
│ ├── Pure Functions (condense, enrich, collisions)
│ ├── Build Cache (SHA-256 validated, auto-generated)
│ ├── Self-Healing Bundle Resolution
│ └── manage_servers + optimize_descriptions
│
├── Proxy Mode (fastmcp native)
│ ├── create_proxy(mcpServers config)
│ ├── CondenseTransform (token optimization)
│ ├── Helper tools (list_all_tools, get_tool_schema, get_tool_count)
│ ├── manage_servers
│ └── Session isolation + MCP feature forwarding
│
├── Search Mode (fastmcp native)
│ ├── create_proxy(mcpServers config)
│ ├── BM25SearchTransform (replaces catalog with search_tools + call_tool)
│ ├── Helper tools (list_all_tools, get_tool_schema, get_tool_count)
│ └── manage_servers
│
└── Code Mode (fastmcp native)
├── create_proxy(mcpServers config)
├── CodeMode transform (search + get_schema + execute sandbox)
├── pydantic-monty sandbox (intermediate results stay in sandbox)
├── Helper tools (list_all_tools, get_tool_count)
└── manage_servers# Install in development mode
pip install -e ".[dev]"
# Run tests
python3 -m pytest tests/ -v
# Run with benchmark output
python3 -m pytest tests/test_token_optimization.py -v -sFile | Tests | Coverage |
| 24 | Property-based (hypothesis) + unit tests for all pure functions |
| 20 | list_all_tools across all modes, server filtering, cache integration |
| 20 | Self-healing bundle resolution across 5 config sources |
| 15 | Config discovery, CLI args, version sync, build cache |
| 11 | BackendManager, HttpMcpClient, parallel init |
| 11 | MCP protocol compliance, end-to-end mode workflows |
| 6 | Token savings benchmarks per mode |
Total | 107 | 0 failures |
Version | Changes |
2.1.0 | Native proxy mode via fastmcp |
2.0.8 |
|
2.0.7 | Self-healing bundle resolution (5 config sources), 8 test fixes, publish script symlink fix |
2.0.6 |
|
2.0.5 | Cache-first startup (no more init timeout), graceful stdin EOF handling, stderr suppression, version sync |
2.0.0 | Initial v2: FastMCP foundation, 3 operating modes, BackendManager, parallel init, smart condensation, build cache, collision resolution |
MIT
Tools: brave-search (Web search using Brave Search API)
| Name | Required | Description | Default |
|---|---|---|---|
| tool | No | ||
| arguments | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It omits key behaviors such as whether the search is read-only, API rate limits, authentication needs, result format, or side effects. The description adds no behavioral context beyond the basic function.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with no filler words, but it is under-specified. The 'Tools:' prefix suggests it might be a list entry, and the fragment-like structure does not provide enough detail to justify its brevity. It is not a complete standalone description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
While an output schema exists, which reduces the need to explain return values, the description is still incomplete. The generic parameters, lack of annotations, and missing usage instructions mean the agent cannot confidently determine how to call the tool or what behavior to expect. The description fails to cover even basic invocation details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema exposes two generic parameters, 'tool' and 'arguments,' both with null defaults and no descriptions (0% coverage). The description does not explain what these parameters mean or how to populate them, leaving the agent without the necessary information to invoke the tool correctly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Web search using Brave Search API,' which clearly conveys the tool's function of performing web searches via the Brave API. It distinguishes from sibling tools, none of which are search-related. However, the phrasing is a noun phrase with a 'Tools:' prefix, making it read like a list label rather than a proper imperative description, which slightly reduces clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no indication of when to use this tool, no mention of alternatives, no prerequisites, and no exclusions. It is purely definitional, leaving an agent without any guidance on choosing 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.
Tools: filesystem (Local filesystem access - read, write, and manage files)
| Name | Required | Description | Default |
|---|---|---|---|
| tool | No | ||
| arguments | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits but only gives a high-level summary. It does not warn about destructive operations, permission requirements, scope, or the nature of the 'tool' and 'arguments' parameters, leaving significant behavioral ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the core purpose. However, it is so brief that it sacrifices substance, bordering on under-specification rather than effective brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's dispatcher-like schema (tool + arguments) and lack of annotations or parameter explanations, the description is grossly incomplete. It leaves the agent without enough information to correctly invoke the tool or understand what arguments are valid.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has two parameters ('tool' and 'arguments') with zero schema description coverage. The description provides no explanation of what these parameters mean or how they map to filesystem operations, so it does not compensate for the missing schema detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides 'Local filesystem access' with operations 'read, write, and manage files', giving a specific verb+resource combination. It is distinct from the listed sibling tools (e.g., brave-search, manage_servers), though it lacks detail on what 'manage' entails.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description only implies usage for local filesystem operations but does not mention any exclusions, prerequisites, or comparisons to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get count of available tools by server.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits itself. 'Get count' implies a read-only operation, but it does not explain whether it requires authentication, how it groups by server, or if there are any limitations. The description is adequate but minimal for a simple count tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that uses clear noun-verb structure. No wasted words or redundant details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with an output schema present, the description sufficiently conveys the purpose. It could add detail about the output format, but the output schema likely covers that. The behavior is simple and the description is complete enough for the context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema fully covers this with an empty properties object. The description correctly implies no input is needed, so there is no missing parameter information to compensate for.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get count' and the resource 'available tools by server', which distinguishes it from sibling tools like list_all_tools (which likely returns full details) and get_tool_schema (which returns schemas).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool instead of alternatives like list_all_tools or get_tool_schema. It is left to the agent to infer that this is for a lightweight count rather than full details.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get full description and inputSchema for a specific tool.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
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 communicates a read-only 'Get' operation but does not disclose details such as error handling, case sensitivity, or whether the operation has side effects. It adds minimal behavioral context beyond the literal function.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently states the action and target. It is appropriately concise for a simple tool, though it could include slightly more context without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one parameter and an output schema, the description covers the core purpose but lacks usage guidance. It does not mention how to get a valid tool name or when to use this tool instead of list_all_tools. The output schema likely covers return values, but the description alone is only moderately complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one required parameter 'name' with no description, and schema coverage is 0%. The description adds that the schema is for 'a specific tool,' which clarifies that 'name' refers to a tool name, providing a small semantic layer. However, it does not specify the expected format or how to obtain valid names, such as via list_all_tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Get' to indicate retrieval, and specifies the resource as 'full description and inputSchema for a specific tool.' This clearly distinguishes it from sibling tools like list_all_tools (which lists all tools) and get_tool_count (which counts tools), as it targets a single tool's schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'for a specific tool' implies the tool is used when you need schema details for one tool, but it does not explicitly state when to use it versus alternatives. It lacks any mention of list_all_tools as a way to discover valid tool names or any contextual guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all tool names and descriptions grouped by server. Optionally filter by server name.
| Name | Required | Description | Default |
|---|---|---|---|
| server | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully carries the burden of behavioral disclosure. It clearly states the output behavior (list names and descriptions grouped by server) and that filtering is optional. No hidden side effects or additional traits need disclosure for such a simple listing operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences: the first states the core function, the second explains the optional filter. Every word earns its place, and the most important information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-optional-parameter tool with an output schema, the description is complete. It covers what is listed, how it is grouped, and the only parameter's purpose. There is no missing information that would prevent an agent from using it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Even though the schema provides no parameter descriptions (0% coverage), the description explains the 'server' parameter as an optional filter by server name. This compensates fully for the schema's lack of detail and adds clear meaning to the parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('List all tool names and descriptions') and the grouping key ('grouped by server'). It also distinguishes itself from sibling tools like get_tool_schema (which retrieves a single tool's schema) and get_tool_count (which counts tools) by focusing on listing all tools in a grouped format.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for obtaining an overview of available tools, optionally filtered by server. However, it does not explicitly compare with siblings like get_tool_schema or get_tool_count, leaving the choice of when to use this versus those tools to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Manage ToolMux backend MCP servers. Actions: list, add, remove, validate, test, retry.
Examples: manage_servers(action="list") manage_servers(action="add", name="my-mcp", command="my-mcp-server", description="My MCP") manage_servers(action="remove", name="my-mcp") manage_servers(action="validate") manage_servers(action="test", name="my-server") manage_servers(action="retry", name="aws-sentral-mcp")
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | ||
| name | No | ||
| action | Yes | ||
| command | No | ||
| base_url | No | ||
| transport | No | ||
| description | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits, but it only lists actions without describing side effects, destructive nature (e.g., 'remove'), permissions required, or impact of test/retry operations. The examples show invocation but not consequences, leaving significant transparency gaps for a management tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded with the purpose, and uses examples effectively to illustrate usage. The example list is longer than strictly necessary but each line earns its place by clarifying action-parameter combinations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, 6 actions) and no annotations, the description is not fully complete: it lacks per-action parameter requirements and edge cases. An output schema exists, so return values are not needed, but the action-parameter mapping remains underspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description partly compensates by demonstrating usage of name, command, and description in examples. However, it does not explain parameters like args, base_url, or transport, nor how parameters vary across actions, so it adds only partial meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states it 'Manage[s] ToolMux backend MCP servers' and enumerates concrete actions (list, add, remove, validate, test, retry), making the tool's purpose clear. It distinguishes from siblings that focus on tool schema/count/list or file operations, though 'manage' is somewhat broad and relies on the action list for specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied through examples such as adding or removing a server with specific parameters, but there is no explicit guidance on when to use this tool versus alternatives like list_all_tools or when not to use it. No exclusions or alternative tool references are provided, so the guidance is present but implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Optimize ToolMux tool descriptions using your intelligence as the LLM. Produces higher-quality descriptions than the auto-generated algorithmic ones.
Actions: status — Check if descriptions have been optimized or are still algorithmic. generate — Returns all tools with their full descriptions. Read them and generate concise (<60 char) versions. save — Save your optimized descriptions for a server.
Workflow:
optimize_descriptions(action="generate") → review all tools
For each server, write concise descriptions capturing the action verb and key object
optimize_descriptions(action="save", server="server_name", descriptions={"tool1": "desc1", ...})
Restart ToolMux to use optimized descriptions
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | ||
| server | No | ||
| descriptions | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the three actions (status, generate, save), the workflow, and the important consequence that a restart is required after saving. It does not detail all side effects or return behaviors, but the output schema presumably covers return values. This is more transparent than a simple 'update' tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-organized with a brief purpose statement, a categorized action list, and a numbered workflow. Every sentence provides useful information—no filler or redundancy. It is concise enough despite covering multiple actions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has moderate complexity (three actions, output schema exists). The description includes purpose, actions, workflow, and the restart requirement. It does not describe the exact return format, but that is likely in the output schema. 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.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description fully compensates by explaining each parameter in the workflow. It explicitly shows action values ('generate', 'save', 'status'), the server parameter ('server="server_name"'), and the descriptions object format ({"tool1": "desc1", ...}). This gives complete semantics beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb + object: 'Optimize ToolMux tool descriptions'. It distinguishes itself from sibling tools like list_all_tools or get_tool_schema by focusing on improving descriptions rather than retrieving them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides an explicit numbered workflow: generate → review → save → restart. It explains when to use the tool by framing it as producing higher-quality descriptions than algorithmic versions. It does not explicitly mention when not to use it or alternatives, but the workflow gives clear context for use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v2.3.1brave-searchfilesystemget_tool_countget_tool_schemalist_all_toolsmanage_serversoptimize_descriptionsScored across 7 tools
Most tools have clearly distinct purposes: introspection (get_tool_schema, get_tool_count, list_all_tools), server management (manage_servers), and description optimization (optimize_descriptions). However, 'filesystem' and 'brave-search' are ambiguous as they appear to be single tools but actually represent bundled servers, making their usage boundaries unclear.
Five tools follow a consistent verb_noun pattern (get_tool_schema, get_tool_count, list_all_tools, manage_servers, optimize_descriptions). The remaining two, 'filesystem' and 'brave-search', are bare nouns with hyphens, breaking the convention and reducing consistency.
Seven tools is a reasonable number for a server management and introspection tool. The inclusion of 'filesystem' and 'brave-search' as standalone tools is somewhat unusual but does not significantly bloat the count.
The tool set covers core operations: listing tools, fetching schemas, counting tools, managing servers (list/add/remove/validate/test/retry), and optimizing descriptions. A notable gap is the lack of an update operation for server configurations, but most common workflows are supported.
Unified gateway hosting 5 Hive Civilization MCP servers (evaluator, trade, depin, compute-grid…
MCP Gateway: wrap any MCP server with cold-start retries, uptime SLA, and per-execution MPP billing.
MCP server providing access to the Scorecard API to evaluate and optimize LLM systems.
