Alto Connector

Overview Schema Source Related Servers Score Discussions Admin

Server Quality Checklist

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

Latest release: v1.4.0
Disambiguation5/5
Each tool has a clearly distinct role in the pipeline: guide, project creation, timeline creation, consent, content authoring, layout preview, build, publish, and retrieval. Even the content-authoring tools are cleanly separated by target—entities, axes, nodes, connections, and overview—so an agent is unlikely to confuse them.
Naming Consistency5/5
All tools follow a snake_case verb_noun pattern with predictable verbs like create, get, set, add, list, build, publish, and run. The naming convention is consistent and maps well to each tool's function.
Tool Count5/5
Fifteen tools is at the upper end of the ideal range, but the domain is genuinely complex: project/timeline management, a consent gate, multiple entity/axis definitions, node/connection authoring, layout preview, build verification, and publishing all need dedicated surfaces. Each tool feels necessary rather than redundant.
Completeness4/5
The core workflow is fully covered: create project, create timeline, record consent, define entities/axes, add nodes/connections/overview, preview, build, publish, and resume via get_timeline or get_interview_guide. Minor gaps exist for lifecycle management—there is no explicit way to delete a whole project or timeline, or update the original create_timeline brief—but these do not block the main build-and-publish flow.
Average 4.2/5 across 15 of 15 tools scored. Lowest: 3.4/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 42 commits in the last 12 weeks
- Last stable release on August 23, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under Apache 2.0.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=false and destructiveHint=false; the description aligns by describing a write/storage operation without claiming read-only behavior. It adds useful behavioral context by specifying verification checks and the exact failure mode with a check list.
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?
One dense sentence covers action, verification criteria, outputs, and failure behavior with no filler. The parenthetical check list is compact and the final failure clause is high-signal.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter tool with no output schema, it describes the operation, validation rules, stored artifacts, and failure behavior. It lacks prerequisites and the return value shape, but those are minor for this build/verify/store workflow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description never mentions the single required parameter timelene_id or explains how it identifies the timeline. With 0% schema description coverage, the description should compensate, but it relies entirely on the property name and title.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States concrete actions (emit, verify, store) on a specific resource and names the artifact outputs, which distinguishes it from siblings like create_timeline or publish_timeline. It does not explicitly call out sibling differences, but the verification pipeline and artifact storage make the purpose clear.
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 on when to use this tool versus alternatives such as run_layout_preview or publish_timeline. The described workflow implies a build-after-creation context, but this is left to the agent to infer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only say readOnlyHint=false and destructiveHint=false; the description adds substantive behavior: exact deep-link syntax that becomes clickable chips at build, demotion of invalid node links to plain text with a build warning, and guaranteed validation before shipping. It does not discuss whether existing overview content is replaced, but 'set' implies that.
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?
Three dense sentences with no filler; the most important content type is front-loaded, and the link syntax is given exactly. The final clause about validation is slightly redundant with the preceding warning but adds a safety guarantee.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is sufficient for the overview_html format and validation behavior, but omits overwrite semantics and any rationale for the required timeline_id. It also does not clarify whether 'optional' means the panel can be empty despite overview_html being required.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description must carry param semantics. It does this for overview_html by specifying HTML paragraphs and the exact link format, which the bare schema lacks. timeline_id is only inferable from its name and the tool name, so the compensation is incomplete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the tool as an 'Optional prose overview panel (HTML paragraphs)', which clearly states the resource and content type. It goes beyond the title 'Set overview' by explaining what the panel contains, though it never uses an explicit verb like 'sets/updates'. It distinguishes from sibling tools because none of them target the overview panel.
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 in the authoring workflow ('Authored from the user's material (§0)') and refers to build-time behavior, so an agent can infer when it applies. It does not explicitly state when to prefer this tool over siblings like build_timeline or add_nodes, nor provide when-not-to-use conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are minimal (readOnlyHint=false, destructiveHint=false), so the description carries most of the behavioral burden. It discloses upsert-by-id semantics, repeatability, no count cap, verbatim sections from user materials, and exactly what hide_nav does to navigation and chips. It does not cover auth or errors, but the core mutation behavior is clear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded and uses a compact pseudo-schema, but it contains a duplicated rationale sentence near the end and some domain jargon. It could be tightened without losing meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is rich in domain context: it explains the consent-gate timing, why this tool exists, the entity-axis contrast, and hide_nav behavior. Still, it leaves label and singular undefined, and with no output schema it does not mention what the agent should expect in return. An agent would still need to guess on required parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate, and it does for some parameters: values gets a full inline shape, slot is constrained to 1 or 2, and hide_nav is explained in detail. But required parameters timeline_id, label, and singular receive no explanation, leaving significant gaps for a 6-parameter tool with 5 required parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Define or extend an extra axis (slot 1 or 2) after the consent gate.' It also distinguishes this tool from the entity axis and from axes declared inside create_timeline, so an agent can tell what it is for and how it differs from siblings.
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 when-to-use context: after the consent gate, repeatedly as material arrives, and whenever the axis belongs to a course's cases. It also gives a concrete heuristic for hide_nav. However, it never explicitly names an alternative tool or states when not to use this one, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare the operation is not read-only and not destructive, which is consistent with creating a project. The description adds meaningful behavioral context beyond annotations: 'Alto never stores generated blurbs' and 'Name + purpose only' clarify what data is persisted and what is intentionally ignored, reducing the risk of misuse.
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 exceptionally compact: two sentences deliver the action, the resource, the allowed kind values, the relevant parameters, and a key non-obvious behavior. Every clause contributes, and the core action is front-loaded.
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 create operation with three flat parameters and no output schema, the description provides the essential information an agent needs: what to create, what kind values are allowed, and what is not stored. It lacks a return-value note and explicit sequencing guidance, but the low complexity keeps this from being a significant gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description compensates partially by listing the allowed kind values and emphasizing that only name and purpose matter. It does not explain the default/optional behavior of purpose or the required nature of name, but it adds enough semantic meaning to distinguish the parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action and resource: 'Create a project container (Flow 1).' It clarifies the container's scope with 'kind: studying|writing|research' and distinguishes this from sibling tools like create_timeline or list_projects by focusing on the project entity itself.
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 'Flow 1' label implies this is the initial step in a workflow, and 'Name + purpose only — Alto never stores generated blurbs' hints at what the tool is not for. However, it does not explicitly state when to use create_project versus alternatives, nor does it name any sibling tool as a fallback or complement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses that publishing exposes the timeline, explains the access difference between 'private' and 'link', and states the return value (view and offline-download URLs). Since annotations only cover read-only/destructive hints, this adds useful behavioral context without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two focused sentences deliver the core action, visibility semantics, and return value with no wasted words. The description is front-loaded with the primary purpose and immediately gives the agent actionable details.
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 two-parameter publish action, the description covers the operation, access behavior, and return URLs, even though there is no output schema. It could mention re-publishing behavior or prerequisites, but the essential information for correct invocation is present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds real meaning to the visibility parameter by explaining who can access the timeline in each mode, compensating for the 0% schema description coverage. However, timeline_id, the required parameter, is not described beyond its schema name, so compensation is only partial.
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, 'Publish', with a clear resource, 'the built timeline', and adds meaningful scope by defining visibility options and return URLs. This clearly distinguishes it from sibling tools like build_timeline and get_timeline.
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 'built timeline' implies this is the final step after build_timeline, and the visibility options give practical usage context. However, the description does not explicitly state when not to use it or mention alternatives, leaving some inference required.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already establishes that this is a safe read operation. The description adds valuable context by listing what the returned state includes, such as brief, consent, node ids, connection count, status, and urls. No destructive behavior or authorization concerns need to be disclosed beyond this.
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 compact sentence that front-loads the purpose and then provides a colon-delimited list of returned contents. Every word earns its place, and there is no redundant or vague filler.
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 one-parameter, read-only tool, the description is nearly complete: it names the return contents and the intended resumption use case. The lack of an output schema means the field list is valuable, although exact response structure and the meaning of status/url values are not specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain timeline_id beyond what the parameter name and title already imply. There is no guidance about the expected format, default behavior, or how the parameter maps to the returned state, leaving the description to compensate but failing to do so.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the full draft state for a timeline and enumerates the exact contents included. The title 'Get timeline state' reinforces the read action and resource, and the tool is easily distinguishable from the sibling get_interview_guide.
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 'for resuming' gives a concrete use case: retrieve the current draft state to continue work. It does not explicitly name alternatives or exclusion conditions, but the usage context is clear for this simple read-only tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the operation as read-only, and the description adds useful context: it clarifies scope ('the user's') and reveals that the result includes timelines nested within projects. No behavioral contradictions exist.
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, efficient sentence that front-loads the action ('List') and clearly states the resource and its nested contents. Every word contributes meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only listing tool, the description is complete: it specifies exactly what will be returned (projects and their timelines) and the user scoping. No output schema exists, but the description sufficiently communicates the expected content.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters, and the schema is complete with an empty properties object. With zero parameters, the description need not explain parameter meaning; a baseline of 4 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 ('List') and identifies the exact resource: the user's Alto projects and the timelines inside them. This distinguishes it from sibling tools like create_project, create_timeline, and get_timeline, which involve creation or retrieval of a single item.
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?
The description states what the tool does but does not provide explicit guidance on when to use it versus alternatives. It does not mention that it is the appropriate choice for getting a broad overview of projects and timelines, nor does it exclude other tools.
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?
Beyond the minimal read/write hints, it discloses concrete consequences: omitted colors are auto-assigned from a clean palette, missing symbol_svg makes all entities fall back to the same ◆ and thus indistinguishable, and sections must come verbatim from user materials. This is exactly the non-obvious behavior an agent needs to know before calling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three dense sentences: purpose + shape, color/symbol behavior, section provenance. Every clause carries a decision-relevant constraint and there is no filler or repetition.
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 state-setting tool with no output schema and sparse params, it covers the main usage pitfalls: cardinality limit, unique SVG requirement, and verbatim sections. It relies on external guide sections (§C1, §0) for wrapper and sourcing details, which is a minor completeness gap, but the core call contract is well specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage and an additionalProperties entity object, the description is the only documentation of entity structure. It enumerates id, name, optional role/color/symbol_svg, and nested sections with {h,t}, and adds cardinality and value-sourcing rules. It does not explain timeline_id or h/t meaning, but the schema titles cover timeline_id and the guide references cover the rest.
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 opening verb 'Define' with the resource 'entity axis (the chips)' is specific, and the inline entity shape makes it unmistakably a setter for the chip/entity list rather than for axis values, nodes, or connections. This distinguishes it from siblings like set_axis_values and add_nodes without requiring the reader to open the schema.
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 gives strong operational guidance once selected (≤12 entities, unique symbol per entity, verbatim sections), but it never states when to prefer this over set_axis_values or other sibling tools, nor any exclusion condition. Usage context is implied by the tool name and entity-axis wording, not made 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?
Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description explains mode semantics, filter behavior, hide_nav/replace_nav effects, period_noun fallback, and that it returns validation warnings. One gap is that the optional timeline_id inside brief is not explained in terms of whether it creates a new draft, updates, or references an existing timeline.
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 long but justifiably so: it is the only documentation of the nested brief object. It is front-loaded with the primary action, then uses a compact, field-oriented structure that avoids filler while packing in rich behavioral details.
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 0% schema coverage and no output schema, the description is nearly complete: it covers the full brief structure, edge cases like replace_nav, and the return of validation warnings. It relies on external references like 'Flow 2 §B–§I' and does not define timeline_id's effect or the format of validation warnings, which keeps it just short of fully self-contained.
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 almost no detail for brief (0% coverage), and the description compensates comprehensively by documenting every brief field, type, cardinality, and behavioral nuance. project_id is not separately described, but its role is evident from the name and the tool context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Create a timeline draft from the build brief (Flow 2 §B–§I)'. It clearly states what is produced and even notes that entities are set separately via set_entities, which avoids overlap with a sibling tool.
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 this tool is used to create the initial timeline draft from a build brief, and it explicitly routes entity assignment to set_entities. However, it does not explicitly differentiate create_timeline from similar siblings like build_timeline or publish_timeline, nor does it state 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only mark readOnly=false and destructive=false; the description adds the real gate behavior: sources are recorded as a manifest and the materials themselves stay in the conversation. It does not cover all edge cases such as consent=false behavior, but the core side effect is disclosed.
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 front-loads the most operationally important guidance ('Call only after'). The example and lock warning are justified, though the §A/§0 emphasis is slightly noisy.
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 gate tool with three parameters and no output schema, it covers the essential calling context, the source payload shape, and the lock behavior. The main gap is timeline_id semantics and return behavior, but these are secondary to the gate conditions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must carry parameter semantics. It adds a concrete example for sources and explains the role of consent=true, but it leaves timeline_id entirely unexplained and does not address what consent=false would mean.
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 title and description clearly identify the tool as recording materials plus consent to pass a hard gate. It states the exact prerequisites and consequence ('Until consent=true, node authoring is locked'), which distinguishes it from the authoring/publishing siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly says 'Call only after' two concrete conditions and ties the call to unlocking node authoring. This tells an agent exactly when to invoke it and what state must already exist.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations, the description discloses idempotent upsert behavior, verbatim authoring requirements, the rule that exactly one node per unit has no parent, tolerance for out-of-order children, and that col is ignored in outline mode. This is rich behavioral context that annotations alone do not provide.
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 core action is front-loaded, and each remaining section earns its place by governing correct invocation: idempotency, verbatim content, paren containment, and col behavior. Dense but not wasteful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and minimal annotations, the description covers idempotency, node shape, required vs optional fields, mode-specific behavior, and content policy. It is slightly incomplete on the semantics of entity_ids and axis values, and on what the response or warning behavior looks like in full.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description compensates by listing the node object shape, optional fields, nested structures for filters/sections, and detailed rules for parent and col. However, entity_ids, axis1_values, and axis2_values are named but not semantically explained, so it stops short of a perfect score.
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 'Batch-add/update timeline nodes (idempotent upsert by id)', which names the specific action, resource, and a key behavioral trait. This clearly distinguishes it from siblings like delete_nodes, add_connections, and build_timeline.
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 mode-specific invocation guidance for linear vs outline modes and explains when to omit parent or col. However, it never explicitly states when to prefer this tool over sibling tools, so selection guidance is implicit rather than directly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description adds useful behavioral context by calling the operation 'cheap' and listing the outputs it produces (world height, per-column balance, warnings). This clarifies the call is a non-destructive dry-run without contradicting the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The entire description is one purposeful sentence with no filler. It front-loads the core concept ('dry-run'), then gives output details and a workflow pointer, making every part earn its place.
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 one-parameter, read-only tool with no output schema, the description covers what the tool computes, what it reports, and how it fits into the larger build workflow. Nothing needed for selecting and invoking the tool is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the description never mentions timeline_id or explains how to supply it. The single parameter name is somewhat self-explanatory, but the description does not compensate for the missing schema documentation.
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 'Cheap layout dry-run' and states exactly what the tool does: 'resolves columns + vertical positions and reports world height, per-column balance, and warnings.' It also distinguishes itself from build_timeline by explicitly positioning this as the pre-build iteration step.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'iterate here before build_timeline' explicitly tells the agent when to use this tool and names the sibling it precedes. This is clear routing guidance that is not available from the schema or annotations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the destructiveHint annotation, the description discloses that connections touching removed nodes are also dropped and that outline mode refuses to orphan contained concepts. This is exactly the kind of behavioral nuance an agent needs to anticipate side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two dense sentences deliver purpose, side effects, an edge case, and remediation advice without filler. The main action is front-loaded, and every clause adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter destructive tool, this is complete: it explains what gets removed, what is dropped with it, when it might refuse, and how to resolve that refusal. The schema supplies the required argument names, and the description supplies the behavioral context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description carries the burden of explaining parameters. It implies node_ids are the nodes to remove and "the draft" maps to the timeline, but it never explicitly names timeline_id or node_ids. The parameter names are conventional enough to infer, but the description could be more direct.
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 a specific verb and resource: "Remove nodes from the draft." It goes beyond a tautology by stating the effect on connections and the outline-mode refusal behavior, clearly distinguishing it from sibling tools like add_nodes and set_entities.
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 a concrete usage context ("after §J scope reconciliation") and provides actionable guidance for the outline-mode edge case: delete the subtree or re-parent children first. It does not explicitly contrast against sibling tools, but the intended use is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark this as read-only, so the description adds useful behavioral context by specifying the returned contents: the interview/build guide, the non-negotiable closed-system rule §0, and the user's resumable drafts. This goes beyond the bare read-only hint without contradicting it.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with zero filler. The imperative 'START HERE' is front-loaded, followed by a compact list of what the tool returns. Every word earns its place.
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, read-only retrieval tool, the description is fully sufficient. It states what the tool returns, its ordering role, and a notable content element (§0). No critical information is missing for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema covers 100% of the (empty) parameter set. The description does not need to explain parameters, and it doesn't. Baseline for no parameters is 4, which 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 clearly identifies the tool's function: returning the interview/build guide and the user's resumable drafts. The 'START HERE' directive distinguishes it as the session entry point among siblings like get_timeline or list_projects, leaving no ambiguity about its role.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: 'START HERE in any Alto session.' This gives strong contextual guidance. It does not explicitly name alternatives or exclude other tools, but the entry-point framing makes the usage context clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already signal mutation via readOnlyHint=false, and the description adds the crucial side effect that the stored connection list is overwritten. It also discloses constraints that will affect execution, such as existing endpoints and valid relation_key values, which the annotations alone do not provide.
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 well-structured: core action first, then constraints, then the critical replacement instruction. Every sentence adds necessary information without repeating schema or annotation details.
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 two-parameter tool with a nested array, the description fully covers the complex parameter's structure, constraints, and call contract. The only omitted parameter is the self-explanatory timeline_id, and no output schema is promised, so no return-value description is needed.
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 only shows an array of arrays of strings, but the description decodes each entry as [source_id, target_id, relation_key], explains the relation_key vocabulary, and states endpoint constraints. Timeline_id is not described in the description, though its schema title makes its purpose reasonably clear.
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 ('Set') and clearly identifies the resource ('full connection list'), immediately correcting the additive implication of the tool name. It also defines the element format and explicitly states that the stored list is replaced, which distinguishes this from incremental add operations like add_nodes.
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 call guidance: send the complete set because the stored list is replaced, ensure endpoints exist, and use relation keys from the brief's vocabulary. It does not explicitly name sibling alternatives, but the context makes it clear this is for full-list replacement rather than incremental addition.
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

Alto Connector MCP server – quality and maintenance score on Glama

Copy to your README.md:

[![Alto Connector MCP server – quality and maintenance score on Glama](https://glama.ai/mcp/servers/lukebmandel-debug/alto-connector/badges/card.svg)](https://glama.ai/mcp/servers/lukebmandel-debug/alto-connector)

Score Badge

Copy to your README.md:

[![Alto Connector MCP server – quality and maintenance score on Glama](https://glama.ai/mcp/servers/lukebmandel-debug/alto-connector/badges/score.svg)](https://glama.ai/mcp/servers/lukebmandel-debug/alto-connector)

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/lukebmandel-debug/alto-connector'

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