torneo
Server Details
Observatory operated and funded by devlo: real tools on frozen tasks; intervals, cost, limits.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
Available Tools
4 toolsexplain_limitsExplain the limits of a resultAInspect
Returns what a category's (or run's) result can and cannot tell you: status and its meaning, fixture flag, freshness, expiry, explicit limits, conflicts, funding, published errata (each chained to the served result hash), the legal preflight verdict per tool including tools not run, and the answer rule every consumer must follow.
| Name | Required | Description | Default |
|---|---|---|---|
| run_id | No | Run id (alternative to category) | |
| category | No | Category id |
TDQS
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 reveals substantial behavior: status meaning, fixture flag, freshness, expiry, explicit limits, conflicts, funding, errata chained to the served result hash, legal preflight verdicts for all tools, and a mandatory answer rule. It does not explicitly say the tool is read-only, but 'Returns' and the content list make the tool's behavior largely transparent.
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 one dense, front-loaded sentence that begins with the core purpose and then packs in many specific output components. Every listed item adds information, though the long comma-heavy list is harder to scan than a structured or shorter version would be.
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 description thoroughly inventories the return content, but it leaves invocation semantics ambiguous: both parameters are optional in the schema and the description does not state whether one is required or what happens if both or neither are supplied. Since there is no output schema, the lack of any return-shape guidance also reduces completeness.
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 describes both parameters with 100% coverage, so the baseline is 3. The description adds only the category-vs-run framing, which is largely mirrored by the schema's 'alternative to category' note. It does not add meaningful semantics beyond what the schema already provides.
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 opens with a specific verb and resource: 'Returns what a category's (or run's) result can and cannot tell you' and then enumerates a detailed list of returned aspects. This clearly differentiates it from siblings like get_results, which retrieves raw results, and get_run, which retrieves run details.
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 interpreting the limits and meaning of a result rather than retrieving the raw data itself. However, it never explicitly says when to use this tool instead of get_results or get_run, nor does it provide exclusions or alternative routing. Usage context is only implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_resultsQuery the evidence for a categoryAInspect
Answers for one category with the canonical answer rule: never 'the best tool', only the best observed evidence for this task, this context, at this date, with intervals, costs, conflicts and limits. On a STALE, SUPERSEDED or INDETERMINATE result the answer is INSUFFICIENT_EVIDENCE and carries no rank. Identical to gladiator query <category> on the CLI.
| Name | Required | Description | Default |
|---|---|---|---|
| category | Yes | Category id, e.g. 'transcription' (see list_categories) |
TDQS
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, and it does a strong job: it explains the canonical answer rule, the special STALE/SUPERSEDED/INDETERMINATE cases producing INSUFFICIENT_EVIDENCE, and that such answers carry no rank. It also hints at the kinds of evidence included (intervals, costs, conflicts, limits), though it leaves some details about the exact return shape implicit.
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 dense sentences with no filler. It front-loads the core purpose and rule, then adds the important edge-case behavior and a useful CLI equivalence. Every clause contributes meaningful information.
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 simple one-parameter tool with no output schema or annotations, the description is reasonably complete: it explains the answer rule, the insufficient-evidence condition, and the absence of rank. It could be more explicit about the exact response structure and when to prefer sibling tools, but the core calling context is well covered.
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 100%, with the category parameter already documented via an example and a pointer to list_categories. The description adds no parameter-specific guidance beyond saying 'for one category', so the baseline score of 3 is appropriate.
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 that the tool 'Answers for one category' and specifies the exact canonical answer behavior, including the special INSUFFICIENT_EVIDENCE outcome. It is specific about the resource (a category) and the output semantics, but it does not explicitly differentiate this tool from its siblings such as explain_limits or get_run.
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 explicit guidance about when to use this tool versus the sibling tools, and does not name alternatives or exclusion conditions. The only implicit context is that it answers 'for one category', and the parameter schema mentions list_categories, but the description itself does not help the agent choose among the available tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_runGet a run bundleAInspect
Returns the canonical result bundle of one run (schema result.v1): protocol lock hash, provenance, reproduce command, per-participant outcomes with intervals. A PRE-REGISTERED run, whose protocol is frozen and timestamped but which has not been executed, returns state PRE_REGISTERED with measured false, its lock and its frozen files, and no result: nothing has been measured yet.
| Name | Required | Description | Default |
|---|---|---|---|
| run_id | Yes | Run id, e.g. 'TRANSCRIPTION-001' (see list_categories, field run_id) |
TDQS
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 explains the special PRE_REGISTERED state behavior: returns state PRE_REGISTERED, measured false, lock and frozen files, and no result because nothing has been measured. This goes well beyond a simple 'get' description, though it does not mention errors, permissions, or pagination.
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 dense but efficient: the main content is stated first, followed by a precise edge-case explanation. Every sentence adds value, and the special PRE_REGISTERED behavior is clearly separated without unnecessary prose.
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 simple one-parameter tool with no output schema and no annotations, the description is remarkably complete. It names the return schema, lists expected result components, and covers the pre-registered edge case. An agent has enough information to call the tool correctly and interpret its response.
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 schema already provides 100% coverage of the single parameter run_id, including an example format. The description adds the context that it identifies 'one run' and connects to list_categories, but does not add substantial new 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 a specific verb ('Returns'), a clear resource ('canonical result bundle of one run'), and enumerates the contents (protocol lock hash, provenance, reproduce command, per-participant outcomes). It also names the schema 'result.v1', making it easy to distinguish from sibling tools like get_results.
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 clearly implies when to use the tool: to fetch the canonical result bundle for a single run, identified by run_id. It does not explicitly name alternatives or exclusion conditions, but the 'one run' scope and reference to list_categories for run_id provide sufficient context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_categoriesList categoriesAInspect
Lists every category with its status (OK: replicated ranking; LOCAL_VALIDITY: single block, no current rank claim; INDETERMINATE: precision insufficient, no rank), observation date, freshness and source run. Categories prefixed 'fixture-' are synthetic demo data validating the machinery, never evidence about real tools.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral burden and does substantial work: it defines the meaning of OK, LOCAL_VALIDITY, and INDETERMINATE, and explicitly warns that 'fixture-' categories are synthetic demo data, preventing misinterpretation. It does not cover auth or error behavior, but for a read-only list that is a minor gap.
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 entire description is one dense sentence with high information density. Every clause earns its place, and the most important context—status semantics and the fixture-data caveat—is included without padding.
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 parameterless tool with no output schema and no annotations, the description covers the returned fields and the key interpretive caveats. It could mention ordering or pagination, but nothing critical is missing for correct invocation.
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 zero parameters and schema description coverage is 100%, so the baseline is 4. There is no parameter information for the description to add.
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 opens with a specific verb and resource ('Lists every category') and enumerates the returned attributes plus status values. This clearly distinguishes it from sibling tools like get_results or get_run, which target different data.
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 explains what the tool returns but gives no explicit guidance on when to use this tool versus the sibling tools. An agent must infer that listing categories is the intended use, with no exclusions or alternative routing provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
4 tool updates
- First observed
explain_limits - First observed
get_results - First observed
get_run - First observed
list_categories
Frequently Asked Questions
Claiming proves that you control a remote MCP connector. It does not move, proxy, or interrupt the server.
Open the connector listing, choose Claim ownership, and sign in to Glama.
Complete one verification method:
GitHub identity — fastest for official registry listings. For a namespace such as
io.github.alice/server, link the matching GitHub user, then choose Claim with GitHub. An organization namespace such asio.github.acme/serveralso needs that organization to have installed the Glama AI GitHub App and approved its permissions, because GitHub discloses organization membership only to apps it has installed. Use HTTP or DNS when it has not.HTTP challenge — works when you can deploy a public file. Generate a token, publish the exact JSON Glama shows at
/.well-known/glama.jsonon the same origin as the connector, then choose Check HTTP challenge.DNS challenge — works when you control DNS but cannot change the server. Generate a token, create the exact TXT record Glama shows, wait for it to propagate, then choose Check DNS challenge.
After verification, Glama sends a confirmation email and gives you access to listing details, thumbnails, health checks, and analytics. Keep the HTTP file or DNS record in place: Glama periodically checks it and ownership remains verified while the token is discoverable.
The HTTP ownership file has this structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"claim": "glama_claim_..."
}Claim tokens are opaque, stable, and bound to the signed-in Glama account. They contain no email address or other personal information. If Glama can no longer discover a verified HTTP or DNS token, it starts a seven-day grace period before removing claim-based access. Restore the same token during that period to keep ownership verified. Never publish an email address, Glama session token, GitHub token, or connector credential as ownership proof.
If verification fails, confirm that you copied the current token exactly. The HTTP file must be public, return valid JSON with a successful HTTP response, and stay on the connector's origin. DNS changes may need more time to propagate. A claim cannot transfer to a different origin or hostname: if the connector target changes, Glama starts the grace period and the new target must be claimed separately after the previous claim is released.
For a connector linked to the official MCP Registry, registry updates continue to replace its name, description, and URL by default. After claiming, open Manage connector and enable Use Glama listing details as the source of truth if edits made on Glama should be preserved. Categories and thumbnails are always managed on Glama; registry linkage and technical connection settings continue to sync.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
To improve your MCP server's ranking:
Claim ownership of the server listing
Complete the server profile with an accurate description and thumbnail
Provide a test profile so Glama can connect to and evaluate the server
Keep tool definitions clear and complete to earn a high Tool Definition Quality Score (TDQS)
Route real usage through the Glama Gateway; more recorded successful server uses also improve the ranking
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!
Related MCP Connectors
Observational astronomy in one place
- FixterOAuthdev.fixter
Monitoring for small teams. Logs, traces, metrics, live issue tracking, API/MCP uptime.
ADHD-friendly tasks, notes & projects for LucidNest - 18 tools, scoped tokens, Streamable HTTP.
Monitoring that agents set up for themselves — cron jobs, CI/CD pipelines and AI agent runs.
Related MCP Servers
- AlicenseAqualityBmaintenanceReal-time cost observability for Model Context Protocol tool calls. Wraps any MCP server, attributesspend per tool/project/customer. Free 25K calls/month. EU-hosted, GDPR-ready, MIT.6106MIT
- AlicenseNot gradedqualityDmaintenanceA hosted remote MCP server that lets your AI agent schedule tasks for later — reminders, delayed webhook callbacks, and recurring jobs. Read-only by design.8MIT
- FlicenseNot gradedqualityCmaintenancePassword-protected dashboard and Remote MCP observer for Codex work, recording concise task milestones via observe_start, observe_report, and observe_finish tools.-

agent-taskofficial
FlicenseNot gradedqualityBmaintenanceAgentTask is a governed work platform where human teams and AI agents share one backlog. Hosted remote MCP server (streamable HTTP, OAuth 2.1 or org API keys) with 60+ tools for tasks, subtasks, projects, groups, labels, notes, comments, attachments, search, crews, and agent runs.-
Glama MCP Gateway
Add one secure layer between your agents and this server.
TDQS
Each tool has a clearly distinct job: list categories, get category-level results, get run-level bundles, and explain interpretive limits. The overlap in concepts like 'limits' and 'answer rule' is acceptable because explain_limits is explicitly about interpretation while get_results is about the evidence-based answer.
All tool names follow a consistent verb_noun pattern with simple, specific actions: list, get, get, explain. The naming makes both the action and the resource predictable across the set.
Four tools is a well-scoped size for a read-only evidential querying service. Each tool earns its place and there is no filler or unnecessary duplication.
The read/interpretation flow is covered: list categories, fetch category results, fetch run result bundles, and explain limits. The only minor gap is the lack of a direct run-listing endpoint, though list_categories provides source-run pointers and get_run can fetch specific runs.