transformatron

by hexacron

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation5/5
Each tool targets a distinct action: server lifecycle, transform metadata, execution, or setup. There is no overlap between get_transform and run_transform, nor between the server_* commands.
Naming Consistency4/5
Most tools follow a verb_noun pattern (get_transform, list_entities, run_transform), while server management tools use a server_ prefix (server_start, server_stop). This is a minor stylistic deviation but still predictable and readable.
Tool Count5/5
12 tools is well within the ideal range for a server management and transform toolkit. Each tool serves a clear purpose without redundancy, covering discovery, execution, and server control.
Completeness5/5
The surface covers the full server lifecycle (start/stop/restart/status/logs), transform introspection (list/get), execution (run), and setup (seed URL, certs, scaffold). No essential operations are missing for the domain.
Average 4.1/5 across 12 of 12 tools scored. Lowest: 3.3/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 45 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. 'Stop the running transform server' conveys only the action itself, with no info about side effects (e.g., whether running transforms are interrupted, if shutdown is graceful or forced, or if the operation is reversible). This is a significant gap for a state-changing operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no fluff or repetition. It is front-loaded with the verb and resource, maximizing information density.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (no params, likely void output), so minimal description might suffice. However, given no annotations, the description omits critical behavioral context—what happens to ongoing work, whether the server must be running, and error conditions. It is adequate but leaves gaps, so it does not earn a higher score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, and schema coverage is 100% (vacuously). The description adds no parameter semantics because none exist. Since 0 params has a baseline of 4 per rubric, this score is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Stop' and a clear resource 'the running transform server', making it obvious what the tool does. It also distinguishes itself from sibling tools like server_start, server_restart, and server_status by naming a distinct action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. It does not mention prerequisites (server must be running), complementary tools (server_start), or scenarios where stop vs. restart or stop vs. status is appropriate. The usage context is only implied by the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It only says 'return' logs, not whether this is safe/read-only, whether auth is needed, or how recent is defined. No caveats or side effects are disclosed, making it insufficiently transparent.
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 extremely concise: two sentences, purpose first, then parameter explanation. No wasted words, and the structure is front-loaded with the primary function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with an output schema, the description is adequate but not fully complete. It lacks usage guidance and behavioral transparency (e.g., whether the server must be running, what 'recent' means, output format beyond schema). It's a minimal viable description, not a rich one.
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 zero description coverage, but the description adds 'Number of trailing log lines to return,' giving meaning to the 'lines' parameter. This directly compensates for the schema gap, though it's the only parameter and the added detail is minimal.
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 'Return recent server log output,' using a specific verb and resource. It distinguishes from sibling tools like server_start, server_stop, server_status, which are about control/status, not logs.
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?
Usage is implied: use this tool to fetch server logs. However, there's no explicit 'when to use' or mention of alternatives. No exclusions or conditions are stated, so it's not fully transparent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only says it returns a document; it does not disclose error behavior, permissions, or other operation traits. This is a minimal disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences plus an argument line. It is front-loaded, free of unnecessary words, and every sentence provides useful information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple fetch-by-ID tool with an output schema, the description is mostly complete: it explains what is returned and the parameter. It lacks error/not-found behavior, but given the low complexity this is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter, transform_id, is described as a 'Fully qualified transform name from list_transforms', which adds essential meaning beyond the bare string type in the schema. This fully compensates for the 0% schema description 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 action ('Return') and resource ('full detail document for one transform'), and the singular 'one' distinguishes it from sibling list_transforms. This is a specific verb+resource pair that leaves no ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'from list_transforms' implies a workflow (call list_transforms first to get the ID), giving some usage context. However, it does not explicitly state when to use this tool versus alternatives or any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits, but it only mentions the generation action and the ability to infer output fields from sample_response. It does not mention side effects like file creation, required network access, or constraints such as whether at least one of curl/openapi is mandatory.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: one opening sentence and a well-structured Args list. It avoids fluff and is easily scannable, with each parameter explanation earning its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The output schema covers return values, but the description omits critical operational details: the relationship between curl and openapi, whether both can be provided, and expected behavior when neither is given. For a scaffolding tool with optional parameters, this ambiguity leaves the description incomplete.
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, so the description compensates by explaining each parameter: service (optional slug), curl (full command string), openapi (spec string/path), and sample_response (optional JSON). This adds meaningful context beyond parameter names.
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 scaffolds a new Maltego transform module from a cURL command or OpenAPI specification. This is a specific verb+resource and distinguishes it from sibling tools like list_transforms or run_transform, which operate on existing transforms.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for when to use the tool: when you need to generate a new transform module from an API specification. It doesn't explicitly exclude alternatives, but the purpose is distinct enough that no exclusions are necessary.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full transparency burden. It does disclose an important behavioral trait: a transform can report success while producing no entities, and it points to further documentation. However, it does not clarify potential side effects, permission requirements, or error/return behavior beyond the schema. The added warning is helpful but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and well-organized: a one-sentence purpose, a brief cautionary note, and a clear Args section. Every part serves a purpose, and it is not overly verbose. It could be slightly more concise by merging the warning into the prose, but it remains efficient and readable.
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 (5 params, no annotations, output schema present), the description covers the essential context: what the tool does, the meaning of all parameters, a critical usage caveat, and a pointer to further documentation. It does not cover alternatives, but the output schema handles return structure, and the doc reference fills gaps. This is strong but not exhaustive.
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 provides only types and defaults, with 0% description coverage. The description compensates fully by explaining each parameter meaningfully: transform_id is 'fully qualified' and sourced from list_transforms, entity_type includes an example (maltego.Domain), entity_value is described as the 'value carried by the input entity,' settings are keyed, and timeout is in seconds. This adds substantial semantic value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with 'Run a transform against one input entity and return its results,' which clearly states the action (run), the resource (transform), and the scope (one input entity). This distinguishes it from sibling tools like list_transforms or get_transform, and the rest of the text reinforces the purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a useful caution about checking entity count, which indirectly guides behavior when using the tool. However, it does not explicitly state when to choose run_transform over alternatives (e.g., get_transform or list_transforms), nor does it mention exclusions or preconditions. Usage context is implied but not fully articulated.
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 the 'force' parameter's overwrite behavior, which is useful, but it doesn't state what happens when a certificate pair already exists and force is false, nor where files are written. Some behavioral context is missing.
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 very concise: two sentences plus a brief args block. The main purpose is front-loaded, and every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one parameter and has an output schema, so the description needn't explain return values. It covers the tool's purpose and the parameter adequately. Minor gaps remain about default behavior when force is false, but overall it is sufficiently complete for a straightforward tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage for the 'force' parameter. The description fully compensates by documenting its meaning and effect ('Overwrite an existing certificate pair'), which is the only explanation of this parameter's semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's specific action ('Generate') and resource ('self-signed certificate') with a context ('for serving over HTTPS'). This distinguishes it from sibling server management tools.
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 gives clear context for when to use (setting up HTTPS serving), but does not explicitly discuss alternatives or when not to use. No alternative certificate tools exist among siblings, so exclusions are unnecessary.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description's 'Return' clearly indicates a read-only operation with no side effects. It does not mention authentication or error handling, but for a simple zero-parameter getter this is adequate. The behavioral profile is transparent enough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that conveys the essential information with no unnecessary words. It is well-structured and front-loaded with the key verb and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter getter, the description is fully complete. It states exactly what is returned, and the presence of an output schema handles return value details. No significant context is missing for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the description correctly adds no parameter-specific information. The schema is trivially covered (100%), and the baseline for 0 params is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the seed URL and registration steps. It uses a specific verb 'Return' and identifies the exact resource, distinguishing it from sibling tools focused on transforms, server management, or entities.
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 the tool is used to retrieve registration information, but it does not explicitly state when to use it relative to siblings. No exclusions or alternative tool references are provided, so the usage context is clear but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of exposing behavior. 'List the entity types the running server advertises' conveys that this is a read-only operation and that results are dynamic based on the server's advertised capabilities, which is useful context beyond simply stating the action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no redundant words. Every word contributes meaning, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and an output schema is present, the description need not explain return values. The statement fully covers the tool's purpose and source of truth ('running server'), making it complete for a list operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so per rubric the baseline is 4. There is nothing to clarify, and the description does not add unnecessary parameter-related noise.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and a precise resource ('entity types') scoped to the running server. This clearly distinguishes it from sibling tools like list_transforms, as 'entity types' is a distinct concept.
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 the tool is used to discover available entity types on the current server, but provides no explicit guidance on when to use it versus alternatives like list_transforms. For a simple zero-parameter list operation, the implied usage is adequate but lacks direct comparison.
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 usefully discloses the non-obvious ssl behavior (preserving the current scheme), but it does not mention potential downtime or other side effects of a restart. This goes beyond a bare statement but lacks rich detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact: one sentence defining purpose and a brief parameter explanation. No padding, every sentence contributes to understanding the tool and its single argument.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter, the description covers the purpose and parameter semantics effectively. Since an output schema exists, return values need not be described in the text. Minor omissions like downtime impact are acceptable given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description's 'Args' section fully compensates by explaining the ssl parameter in detail: it can enable HTTPS, and when left unset it preserves the existing scheme. This adds substantial meaning beyond the schema's bare type definition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Restart the server to pick up new or edited transform modules,' clearly stating the verb, resource, and purpose. This distinguishes server_restart from sibling tools like server_start, server_stop, or server_status, which have different actions.
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 phrase 'to pick up new or edited transform modules' provides clear context for when to use this tool. It does not explicitly name alternatives or exclusions, but the purpose is clear enough to differentiate it from related server operations.
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 conveying behavioral traits. The word 'report' clearly indicates a read-only operation, and the explicit listing of what is reported (running, healthy, transform count) gives the agent concrete behavioral expectations. It does not discuss side effects, auth, or errors, but for a simple status query this level is reasonably complete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, tightly written sentence that front-loads the verb and immediately specifies the three outputs of interest. Every word contributes meaning; there is no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, status-reporting tool with an output schema, the description is complete. It names all the reported aspects (running, health, transform count) without needing to explain return values, as those are covered by the output schema. The simplicity of the operation does not require further elaboration.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description adds no parameter-level details, but none are needed since there is nothing to configure. It correctly focuses on the output dimensions instead.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'report' paired with the resource 'server' and clearly enumerates the exact outputs (running, healthy, transform count). This fully distinguishes it from sibling tools like server_start, server_stop, and server_logs, which are also self-descriptive in their names.
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 as a health/status check before or during server operations, but it does not explicitly state when to use it versus alternatives. There is no mention of exclusions or alternative tools, though the context of sibling tool names provides implicit differentiation.
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?
No annotations are provided, so the description carries the responsibility. It discloses a notable behavioral trait: an output type of NONE indicates a missing return annotation, which prevents Maltego client routing. This adds valuable context beyond a generic list and helps interpret results. Side effects aren't mentioned, but as a read-only listing operation, this is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first front-loads the main purpose, and the second adds a specific caveat about the NONE type. Both sentences are informative with no unnecessary words, making it highly concise and well structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no params, output schema present), the description is complete. It states what is listed, includes the NONE-type explanation which aids output interpretation, and mentions the 'running server' context. No important details are missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline score of 4 applies. The description mentions input and output types, giving the user an expectation of what the tool reports without needing parameter definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists every advertised transform with input and output types, using a specific verb ('list') and resource ('transforms'). It distinguishes from siblings like get_transform (single transform) and list_entities (different entity type), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context: discovering available transforms on the running server. It doesn't explicitly name alternatives or state when not to use it, but the purpose is self-evident and the tool is simple enough that no further exclusions are needed.
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?
No annotations are provided, so the description carries the full burden. It discloses a meaningful behavioral trait: the tool blocks until the server answers. It also discloses the dependency on generate_certs for SSL mode, adding useful operational context beyond a trivial 'start' statement.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded with the primary purpose, followed by a concise Args block. Every sentence and clause adds value—there is no fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one optional parameter and an output schema, the description is complete enough. It covers the core behavior, the parameter meaning, and a prerequisite. The output format is not explained, but the presence of an output schema makes that unnecessary.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema only provides the parameter name and type, with 0% description coverage. The description's Args section fully explains ssl: it means 'Serve over HTTPS', requires generate_certs first, and is necessary for the Maltego desktop client and Graph Browser. This adds complete semantic meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Start the local transform server') and even adds the readiness condition ('wait until it answers'). This distinguishes it from sibling tools like server_stop, server_restart, and server_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives specific usage context for the ssl parameter: it requires generate_certs first, and both Maltego desktop client and Graph Browser require HTTPS. However, it does not explicitly state when to use server_start instead of server_restart or 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.

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:

[![claude-transformatron-9000 MCP server](https://glama.ai/mcp/servers/hexacron/claude-transformatron-9000/badges/card.svg)](https://glama.ai/mcp/servers/hexacron/claude-transformatron-9000)

Score Badge

Copy to your README.md:

[![claude-transformatron-9000 MCP server](https://glama.ai/mcp/servers/hexacron/claude-transformatron-9000/badges/score.svg)](https://glama.ai/mcp/servers/hexacron/claude-transformatron-9000)

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/hexacron/claude-transformatron-9000'

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