Aionis MCP Server

by ostinatocc

Overview Schema Source Related Servers Score Discussions Admin

TypeScript

Local

Server Quality Checklist

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

Latest release: v0.4.0-rc.1
Disambiguation3/5
Most tools have distinct purposes, but 'aionis_forget' explicitly includes rehydrate/activate actions while a separate 'aionis_rehydrate' tool exists, creating potential confusion. Session tools are clearly separated by lifecycle stage.
Naming Consistency4/5
All tools share the 'aionis_' prefix, and session tools follow a consistent 'session_<verb>' pattern. However, single-word verbs/nouns like 'forget', 'remember', and 'health' break the compound pattern, making the style slightly mixed.
Tool Count5/5
12 tools is a well-scoped count for a memory and session management server. Each tool covers a distinct aspect of the domain without excessive granularity.
Completeness4/5
The tool surface covers the session lifecycle (begin, resume, turn, action, verify, finish) and memory operations (remember, forget, rehydrate) comprehensively. Minor gaps exist, such as no explicit session listing or deletion, but core workflows are supported.
Average 2.6/5 across 12 of 12 tools scored. Lowest: 2/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 16 commits in the last 12 weeks
- Last stable release on June 26, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are absent, so the description carries full burden. It only says 'Return' (implying a read), but provides no information about side effects, return format, errors, or data handling. The qualifier about MCP renderer is technical but not behaviorally transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single terse sentence, which is concise but overly sparse. It uses jargon without unpacking, and while there is no waste, the lack of essential content makes it ineffective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the nested object parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain what the request should contain, what the response looks like, or how this guide fits into the broader Aionis toolset.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, and the description does not mention parameters at all. The two parameters ('request' and 'context_options') are left completely unexplained, and the nested object structure is undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Return') and a resource ('canonical SDK Agent context'), but the resource is vague and the qualifier 'without an independent MCP renderer' does not clarify what the context is. It distinguishes little from sibling tools like 'rehydrate' or 'remember'.
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. There is no mention of prerequisites, alternatives, or exclusions, leaving the agent without any indication of how this relates to session management siblings.
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 responsibility. It mentions actions but does not disclose side effects, permissions, or the meaning of 'rehydrate' and 'activate', offering minimal behavioral insight.
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 a single sentence, but the list of four actions is dense and 'through the SDK' is filler. It is concise length-wise but not effectively structured for clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool appears complex (nested object, multiple memory operations), yet there is no output schema, no parameter details, and no explanation of its relationship to siblings. The description is wholly inadequate for reliable invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and the description does not address the required 'request' parameter at all. An agent has no information about what fields or structure to provide.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool controls memory with four actions (suppress, unsuppress, rehydrate, activate), but the multiple verbs reduce specificity and it does not differentiate from siblings like aionis_rehydrate or aionis_remember.
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 on when to use this tool versus alternatives, nor any conditions or prerequisites. The description is silent on usage context.
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 carry the burden of explaining side effects, auth needs, or whether this operation is destructive (e.g., overwriting current memory). It only states 'Recover exact archived memory' without elaborating on behavior, which is a significant gap for a memory-altering operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single vague sentence that is under-specified rather than efficiently concise. It fails to front-load critical information about parameter semantics or usage, making it low-value despite its brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (generic request object, no annotations, no output schema) and related siblings, the description is insufficient. It lacks details about return values, side effects, and how this tool fits into the memory lifecycle, making it incomplete for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one parameter, 'request,' which is an unconstrained object with 0% schema description coverage. The description adds no information about what 'request' should contain, how to structure it, or what fields are expected, leaving the agent in the dark about the required input.
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 uses the verb 'Recover' and specifies the resource as 'archived memory,' which gives a clear sense of the tool's action. It is distinguishable from siblings like 'remember' and 'forget' at a high level, though it doesn't explicitly compare with them.
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?
There is no guidance on when to use this tool versus alternatives such as 'aionis_remember' or 'aionis_session_resume.' No prerequisites, context, or exclusions are mentioned, leaving the agent to infer usage from the tool name alone.
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 available, the description carries the full burden of disclosing side effects, but it only says 'Store ... through the SDK governed observe path.' It omits what happens to stored memory, whether it is persisted, how it can be retrieved or forgotten, and what access/visibility implications exist. The opaque 'observe path' terminology obscures rather than clarifies the behavior.
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 a single, front-loaded sentence with no filler words. It loses points only because the tail phrase 'through the SDK governed observe path' is compact but unhelpfully jargon-heavy, and the overall brevity comes at the cost of meaningful content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 20-parameter tool with no annotations and no output schema, this one-sentence description is severely incomplete. It fails to explain the memory classification dimensions (kind, tier), scoping and ownership (scope, tenant, owner_*), or lifecycle behavior (lifecycle_state), leaving an agent unable to make informed decisions about which optional fields to populate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 20 parameters with 0% schema description coverage, yet the description names none of them. The schema's type/enum information is insufficient to understand the meaning and purpose of fields like kind, tier, scope, salience, lifecycle_state, or owner_* fields. The description makes no effort to compensate for this gap.
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 states a specific action ('Store ... project memory') and a resource type ('ordinary project memory'), which makes the basic purpose clear. It distinguishes itself from forget/session tools by being the memory-write operation, though it does not clarify what makes memory 'ordinary' or how this relates to sibling tools like aionis_feedback or aionis_rehydrate.
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 on when to use this tool versus alternatives. The phrase 'through the SDK governed observe path' hints at a constrained context but does not explain when this path is appropriate, whether a session must be active, or when to prefer sibling tools such as aionis_guide, aionis_feedback, or aionis_rehydrate.
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 provided, the description must disclose behavioral traits itself. It only states that a new state handle is returned, which is useful, but it omits critical details such as side effects (e.g., mutating session state), prerequisites (e.g., a valid existing session), error conditions, or idempotency behavior. This is insufficient for a stateful recording tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no redundant words. It clearly states the primary action and outcome in a compact form, making it easy to read and process.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 7 parameters, 5 required, no annotations, no output schema, and very low schema description coverage, the description is severely incomplete. It fails to explain the meaning of the required parameters, the expected format of 'completed host action', or the nature of the returned state handle, leaving the agent with insufficient information to invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 14%, meaning most parameters are undocumented in the schema. The description does not compensate by explaining any of the required parameters like operation_id, action_kind, request, or action_result. It only mentions a generic 'state handle', leaving the agent without semantic understanding of the key inputs.
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 uses a specific verb 'Capture' and identifies the resource as a 'completed host action' through AgentSession, making the tool's core function clear. However, it does not explicitly differentiate this from sibling tools like session_turn or session_verify, so it loses a point for lacking sibling distinction.
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?
There is no explicit guidance on when to use this tool versus alternatives. The phrase 'completed host action' implies it should be used after an action is finished, but no prerequisites, exclusions, or alternative tool references are given, leaving the agent to infer usage context.
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?
Since no annotations are provided, the description carries the full burden. It implies a stateful, mutating operation by using 'Begin', but it does not disclose side effects, creation of resources, required verifier/workspace context, or the nature of the portable handle. The description adds minimal behavioral context beyond the core 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, succinct sentence with no filler. It immediately states the action and the expected output, making it easy to parse and free of unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 16 parameters, no annotations, no output schema, and a complex domain (session lifecycle), the description is severely incomplete. It does not explain what constitutes a canonical session, what a portable handle is, how the operation relates to sibling tools, or any verification/continuation logic.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0% and 16 parameters (11 required), the description provides no parameter information whatsoever. The agent receives no help understanding what parameters like task_envelope_v1, required_verifier_id, or workspace_root mean, nor how they relate to starting a session.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Begin') and the resource ('canonical SDK AgentSession'), and specifies that a portable handle is returned. While it doesn't explicitly differentiate from sibling session tools like aionis_session_resume, the verb 'Begin' strongly implies starting a new session, distinguishing it from resume/continue operations.
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 on when to use this tool versus alternatives such as aionis_session_resume or aionis_session_turn. The word 'canonical' hints at a standard entry point, but there is no explicit context, prerequisites, or 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 alone must disclose behavioral traits. It reveals that the tool records an observation and returns context, indicating a write-plus-read operation, but omits side effects, session-safety semantics, verification meaning, error behavior, or state impact. This is insufficient for a stateful session tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-formed sentence with no fluff. It front-loads the core action and is easy to scan, though it sacrifices informativeness for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (11 params, 7 required, nested objects, no output schema), the description is far too thin. It does not explain parameter roles, return value structure, session lifecycle expectations, or any operational steps, making it inadequate for reliable invocation.
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 only 9%; the description must compensate but fails to explain most parameters. It explicitly references only 'observation' and 'same session' (implying handle), while key required params like operation_id, authority, evidence_kind, and evidence remain semantically opaque.
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 states a specific action: record the current observation and return SDK-rendered Agent context for the same session. The verb+resource structure is clear and the two-step behavior helps distinguish it from session_begin or session_finish, though it doesn't explicitly contrast with siblings.
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?
There is no guidance on when to use this tool versus alternatives like session_action or session_verify. No prerequisites, context, or exclusion criteria are mentioned, leaving the agent to infer usage from the name and schema.
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 the full burden of behavioral disclosure. It only says 'Run the Runtime-owned verifier', which implies execution but does not state whether the operation is read-only, mutating, what it validates, or what happens to session state. This is insufficient for an agent 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no redundant words or filler. It is front-loaded with the action, though its brevity borders on under-specification, which slightly reduces its effectiveness as a standalone guide.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This tool has no annotations, no output schema, and a minimal description. It fails to explain return values, error conditions, the verifier's behavior, or the meanings of two of three parameters, making it incomplete for a tool with nested objects and unclear operational details.
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 description covers only the handle parameter (33% coverage), and the tool description adds no information about lease_ttl_ms or operation_id. The description does not compensate for the missing schema explanations, leaving two parameters semantically ambiguous.
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 states a specific action ('Run') and a specific resource ('Runtime-owned verifier for the current AgentSession state'), distinguishing it from sibling session tools like begin/resume/turn. However, it does not clarify what 'verify' means or what the verifier checks, leaving some ambiguity about its exact purpose.
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 provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or alternative tools, so an agent lacks context for when verification is needed compared to other session operations.
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 exist, and the description only states the action without revealing behavioral traits such as idempotency, required fields, or side effects. It does not contradict annotations since none exist, but it offers minimal insight into what happens on submission.
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 a single sentence with no filler, clearly stating the tool's primary action. However, it is under-specified, which limits its usefulness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the opaque request parameter and lack of output schema, the description is wholly inadequate for an agent to select and invoke the tool correctly. It lacks any information about request contents or expected behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter 'request' has zero schema description coverage and is a free-form object. The description provides no information about its structure, required fields, or meaning, leaving the agent to guess.
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 'Submit' and identifies the resource as 'guide-attributed feedback,' which clearly distinguishes this from sibling session-management tools. The 'through the SDK' phrase adds context about the channel.
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 submit feedback, whether it follows a session, or what alternatives exist (e.g., aionis_remember). The description does not mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of behavioral disclosure. It only states that it returns a refreshed handle, but does not disclose side effects, requirements (e.g., valid serialized handle), or whether resuming invalidates the previous handle.
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 concise sentence with no extraneous content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and no annotations, and the description is minimal. It doesn't explain the meaning of operation_id or lease_ttl_ms, the shape of the refreshed handle, or the implications of resuming a session, making it incomplete for correct invocation.
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 covers only 33% of parameters with descriptions (handle). The description adds context for handle ('serialized AgentSession'->resume) but does not explain lease_ttl_ms or operation_id, which remain opaque.
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 uses a specific verb ('Resume') and resource ('serialized AgentSession') and indicates the result ('return the refreshed handle'). However, it does not explicitly distinguish this from the sibling aionis_rehydrate, which may also resume a session, leaving some ambiguity.
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 usage guidance is provided. The description does not state when to use resume versus begin, turn, action, or rehydrate.
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 provided, the description carries the full burden of behavioral disclosure. It reveals that verification gating is required and that failure produces a continuation, which is a useful non-obvious behavior. However, it does not disclose what happens on successful finish (e.g., session invalidation, side effects) or the structure of the continuation, leaving significant behavioral gaps for a session-ending 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, focused sentence that leads with the core action and adds a crucial behavioral caveat. Every word earns its place; there is no redundancy or unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (10 parameters, no output schema, no annotations), the description is too terse to provide a complete understanding of the tool's workflow, prerequisites, or return contract. It fails to explain how the parameters interact, what 'continuation' means practically, or what happens on success. This is a significant gap for a finish operation with multiple required inputs and conditional outcomes.
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 only 10% (only 'handle' has a description), so the description must compensate. It hints at 'verifier_operation_id' through 'SDK verifier gating' but does not explain 'close_operation_id', 'termination', 'recovery_mode', or the other six parameters. This minimal parameter guidance is insufficient for a 10-parameter API, especially with four required parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool finishes a session through SDK verifier gating, and explicitly notes that failed verification returns a continuation rather than a false completion. This distinguishes it from sibling session tools (begin, resume, turn, verify) by focusing on the finish action. The title reinforces the 'Verified Continuity Session' resource.
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 that this tool should be used when finishing a session after SDK verification and that a failed verification will not complete the session but return a continuation. However, it does not explicitly state when not to use it or compare it to alternative finish mechanisms, leaving some ambiguity about prerequisites or 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 provided, the description carries the full burden of behavioral disclosure. It only states the check but does not describe what the tool returns (e.g., boolean, status object), whether it is read-only, or how it behaves on failure or timeout. This is a significant gap for a diagnostic tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that directly conveys the core purpose without any filler. It is appropriately sized for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is too minimal for a tool with no output schema and no annotations. It fails to explain what the result of the check looks like, which is essential for a health-check tool. The agent cannot predict the return format or how to interpret the outcome.
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 schema is empty and there is no semantic burden. Per the baseline rule for 0-param tools, a score of 4 is appropriate since no parameter documentation is needed.
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 function: checking whether the configured Aionis Runtime is reachable. The verb 'check' and resource 'Aionis Runtime' are specific, and the scope (reachability) distinguishes it from siblings dealing with sessions, memory, or feedback.
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 provides no guidance on when to use this tool versus alternatives. It does not mention typical use cases (e.g., troubleshooting connectivity before other calls) or when not to use it. The purpose is implied but not explicitly contextualized.
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

Aionis MCP Server MCP server – quality and maintenance score on Glama

Copy to your README.md:

[![Aionis MCP Server MCP server – quality and maintenance score on Glama](https://glama.ai/mcp/servers/ostinatocc/aionis-mcp/badges/card.svg)](https://glama.ai/mcp/servers/ostinatocc/aionis-mcp)

Score Badge

Copy to your README.md:

[![Aionis MCP Server MCP server – quality and maintenance score on Glama](https://glama.ai/mcp/servers/ostinatocc/aionis-mcp/badges/score.svg)](https://glama.ai/mcp/servers/ostinatocc/aionis-mcp)