L-Dopa
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@L-DopaI'm stuck in a retry loop; diagnose the issue and suggest a focused next step."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
L-Dopa
An MCP server for helping AI agents recover, refocus, and get shit done.
L-Dopa fixed me, alright??
L-Dopa is a small, production-minded Model Context Protocol (MCP) server that helps an agent recover when an approach is failing, context is scattered, or retries are turning into a loop. It does not execute commands, mutate external systems, or replace an agent's judgment. It analyzes the evidence supplied to it, retains bounded recovery state, and proposes a safer next move.
The name is a joke. The recovery loop is not.
What it does
L-Dopa v0.1 provides six MCP tools that let an agent diagnose failures, reduce scope, restore relevant context, and manage retries deliberately.
Tool | Use it when | It returns |
| An operation failed and the agent has an error or log excerpt. | Likely cause, calibrated confidence, redacted evidence, next actions, and retry guidance. |
| The agent is circling without making a useful observation. | A concise reset that focuses on an assumption and a minimal safe check. |
| A task is too broad or tangled. | A prioritized list of one to five concrete next actions; three is the default. |
| The agent needs relevant recovery context from its L-Dopa session. | A compact summary of recent failures, attempts, successes, facts, and unresolved issues. |
| The agent is considering or reporting a retry. | A recorded, bounded retry or a block with an alternative-strategy recommendation. |
| The agent is stuck and wants one concise recovery sequence. | Diagnosis, focused actions, a recovery nudge, and retry guidance. |
Related MCP server: nautilus-compass
Design principles
Principle | Implementation in v0.1 |
No magical certainty | Diagnostic confidence is |
No blind loops | Repeated materially similar failures, unchanged retry proposals, and per-operation retry limits block further retries. |
Bounded memory | JSON-backed state retains only the configured number of records per category for each session. |
Safe by default | L-Dopa offers diagnosis and planning only. It never executes shell commands or external actions. |
Credential-aware output | Common token, authorization header, password, API-key, JWT, AWS-key, and GitHub-token patterns are redacted before state, logs, and tool output. |
Simple deployment | The server uses standard MCP stdio transport and requires Node.js 18 or newer. |
Installation
Clone the repository and install the dependencies:
git clone https://github.com/mshanghai570/L-Dopa.git
cd L-Dopa
npm install
npm run buildStart the stdio server manually with:
npm startnpm start intentionally appears to wait for input. MCP servers speak JSON-RPC over standard input and output, so normally an MCP client launches it for you.
Connect an MCP client
Build L-Dopa first, then use its executable entry point. The following generic MCP configuration is compatible with clients that support local stdio servers:
{
"mcpServers": {
"l-dopa": {
"command": "node",
"args": ["/absolute/path/to/L-Dopa/dist/index.js"],
"env": {
"LDOPA_STATE_FILE": "/absolute/path/to/l-dopa-state.json",
"LDOPA_MAX_HISTORY": "50",
"LDOPA_RETRY_LIMIT": "3",
"LDOPA_LOG_LEVEL": "info"
}
}
}
}For an installed package, the command may instead be l-dopa, depending on the client environment. Keep standard output reserved for MCP protocol messages. L-Dopa writes its own concise structured operational logs to standard error.
Configuration
L-Dopa runs with safe defaults and can be configured through a JSON file and/or environment variables. Copy the provided example to get started:
cp l-dopa.config.example.json l-dopa.config.json
LDOPA_CONFIG=./l-dopa.config.json npm startEnvironment variables override file values.
Setting | JSON property | Environment variable | Default | Meaning |
State path |
|
|
| Location of the bounded JSON session store. |
History limit |
|
|
| Positive maximum records retained for each category in a session. |
Retry limit |
|
|
| Positive maximum planned/reported retries retained for an operation before new retries are blocked. |
Logging level |
|
|
| One of |
Config file | — |
| — | Optional path to a JSON configuration file. |
Configuration contains no provider credential settings because this version makes no model or provider calls. If a future extension requires credentials, pass them through environment variables; do not add them to a repository, configuration file, or recovery prompt.
Tool reference
All text arguments are bounded and credential-redacted before L-Dopa persists or returns them. sessionId defaults to "default", but agents should use a stable ID per task or conversation to prevent unrelated recovery histories from mixing.
diagnose
Use diagnose after a failure with as much useful context as is available. errorMessage, recentOperation, logs, attemptedSolution, expectedResult, and actualResult are optional, but a precise error or actual result makes the response more useful.
{
"sessionId": "deploy-2026-08-27",
"recentOperation": "Deploy version 0.1.0",
"errorMessage": "429 Too Many Requests",
"attemptedSolution": "Immediately retried the deployment",
"expectedResult": "Deployment accepted",
"actualResult": "The API rejected the request"
}The response includes likelyCause, confidence, evidence, recommendedNextActions, retryAppropriate, tryDifferentStrategy, and a redacted indicator. Detection is deliberately heuristic rather than falsely authoritative.
stimulate
Use stimulate when an agent needs to stop narrating and start learning. Supply a required task and optional high-signal context.
{
"sessionId": "deploy-2026-08-27",
"task": "Repair the deployment",
"context": "The health check timed out twice after a successful build"
}The recovery strategy emphasizes a minimal, verifiable action and warns against unchanged loops.
focus
Use focus to turn a broad task into a deliberately short sequence. maxSteps is optional and ranges from one to five; it defaults to three.
{
"sessionId": "deploy-2026-08-27",
"task": "Repair the deployment and verify availability",
"context": "Health checks time out",
"maxSteps": 3
}reuptake
Use reuptake when the agent needs relevant session context without dumping a transcript. limit defaults to five and is capped at twenty.
{
"sessionId": "deploy-2026-08-27",
"limit": 5
}It returns the current task, recovery status, recent failures, attempted solutions, successful approaches, discovered facts, unresolved issues, and retry count. The v0.1 tools do not yet expose a dedicated fact-recording tool; discoveredFacts is reserved for extensions and remains present in the compact schema.
retry
Use retry to create an explicit retry record or report its outcome. A proposedChange should name what is different. L-Dopa permits planned, successful, and failed records, but it never performs the retry itself.
{
"sessionId": "deploy-2026-08-27",
"operation": "Deploy version 0.1.0",
"previousFailure": "429 Too Many Requests",
"proposedChange": "Wait for Retry-After and submit only one request",
"result": "planned"
}L-Dopa blocks a retry if the configured operation limit is exhausted, the same failure has recurred, or an existing retry is repeated without a changed proposal. Its block response recommends a bounded alternative path, which may include handing a well-scoped subtask and gathered evidence to another capable agent.
fix_me
Use fix_me for the short version of diagnose → focus → stimulate → retry guidance. It records a supplied failure, when present, then returns a plan; it does not execute it.
{
"sessionId": "publish-0.1.0",
"task": "Publish the package safely",
"recentOperation": "npm publish",
"errorMessage": "401 Unauthorized",
"attemptedSolution": "Re-ran the same command"
}State and privacy
The state store is a plain JSON file written atomically with mode 0600. It has a versioned shape and stores separate sessions keyed by sessionId. Within each session, failure records, retry records, attempted solutions, successful approaches, and discovered facts are trimmed to maxHistory.
State is intentionally lightweight, not a long-term memory system. It is local to the running user's machine and is not transmitted by L-Dopa. Review or delete the configured state file whenever you need to clear recovery history.
Important: Redaction covers several common credential patterns but is a defensive convenience, not a license to submit secrets. Do not intentionally place passwords, tokens, private keys, or full authorization headers in diagnostic input.
Development
npm install
npm run build
npm testThe project is deliberately modular:
src/
config.ts Configuration loading and validation
index.ts Executable stdio MCP entry point
logger.ts Structured, redacted standard-error logging
redaction.ts Credential-detection and output redaction
recovery.ts Diagnostic, focus, stimulation, and plan logic
server.ts MCP server and tool registrations
state.ts Bounded, atomic JSON session storage
types.ts Shared contracts
tests/
l-dopa.test.ts End-to-end MCP and state behavior testsTest coverage
The automated suite connects a real MCP client and server through the SDK's in-memory transport. It covers server initialization, MCP tool discovery, every tool, state persistence, bounded retention, retry limits, unchanged retries, repeated-failure detection, and credential redaction.
Run it with:
npm testLimitations and roadmap
L-Dopa v0.1 uses deterministic heuristics, so it recognizes common failure classes but is not an omniscient debugger. It has no vector store, remote persistence, model-provider integration, or command-execution capability by design. It does not inspect an agent's hidden chain of thought; it only works with supplied operational context.
Future additions should preserve these boundaries: add a tool only when it provides a clear recovery benefit, keep command execution in a separate permission-controlled component, and keep state bounded and inspectable.
License
Available Tools
6 toolsdiagnoseDiagnose a failureA
Analyze an error or failed operation, record it in bounded session state, and recommend safe next actions.
| Name | Required | Description | Default |
|---|---|---|---|
| logs | No | Relevant log excerpt. Credentials are redacted. | |
| sessionId | No | A stable identifier for this agent recovery session. | default |
| actualResult | No | What happened instead. | |
| errorMessage | No | The exact error message, if available. | |
| expectedResult | No | What should have happened. | |
| recentOperation | No | The operation that most recently failed. | |
| attemptedSolution | No | A solution already attempted. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With annotations providing only broad flags, the description adds meaningful behavioral detail: it records state in a bounded session and recommends rather than executes actions. This clarifies side effects and scope 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, tightly worded sentence front-loads the core verb and object, then packs in two meaningful behavioral outcomes. There is no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with seven optional but fully documented parameters and no output schema, the description conveys the essential flow: analyze, record, and recommend. It stops short of describing the exact shape of the recommendation output, but it is sufficiently complete for an agent to understand the tool's role.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the input schema already documents each parameter, so the tool description does not need to repeat parameter details. The description adds no parameter-specific meaning beyond the schema, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb ('Analyze') and resource ('an error or failed operation'), and adds two concrete outcomes: recording in bounded session state and recommending safe next actions. It is clear about what the tool does, though it does not explicitly differentiate it from sibling tools like retry or fix_me.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'Analyze an error or failed operation' implies the intended trigger, and 'recommend safe next actions' positions it as an advisory step before acting. However, it gives no explicit guidance on when not to use it or how it compares to sibling alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
fix_meCreate a complete recovery sequenceA
Combine diagnosis, focus, stimulation, and retry guidance into a concise recovery plan without executing commands.
| Name | Required | Description | Default |
|---|---|---|---|
| logs | No | Relevant log excerpt. Credentials are redacted. | |
| task | Yes | The task that is stuck or needs recovery. | |
| sessionId | No | A stable identifier for this agent recovery session. | default |
| actualResult | No | Actual result. | |
| errorMessage | No | The exact error message, if available. | |
| expectedResult | No | Expected result. | |
| recentOperation | No | The operation that failed. | |
| attemptedSolution | No | A solution already tried. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already tell the agent the operation is not read-only, not idempotent, and not destructive. The description adds valuable behavioral context beyond those annotations by explicitly stating that no commands are executed, meaning the tool only produces guidance/planning content. This helps the agent set expectations about 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It states the action, the inputs, the output, and a key behavioral constraint ('without executing commands') in under 15 words. Every phrase earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the 8-parameter schema with full coverage, annotations, and no output schema, the description provides enough context: it defines the output as a concise recovery plan and clarifies the non-execution behavior. It does not detail the plan's format or how to handle partially supplied inputs, but the required task parameter and well-described optional parameters make the tool usable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so all eight parameters already have descriptions. The tool description adds conceptual meaning by mapping the plan components to diagnosis, focus, stimulation, and retry guidance, but it does not explain how specific parameters map to those components. Baseline 3 is appropriate because the schema carries the parameter-documentation burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Combine') and resource ('diagnosis, focus, stimulation, and retry guidance into a concise recovery plan'), so an agent knows what the tool produces. It also distinguishes itself from the sibling tools diagnose, focus, stimulate, and retry by framing those as components rather than the tool's own action. The phrase 'without executing commands' further differentiates it from the more action-oriented siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly conveys that this tool is for synthesizing a recovery plan rather than executing recovery actions, which gives the agent a clear decision context. It does not explicitly enumerate exclusions or say 'use X when...', but naming the component tools implies when this orchestrator is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
focusFocus the next actionsA
Reduce a complicated task to a short, prioritized sequence of concrete, verifiable next actions.
| Name | Required | Description | Default |
|---|---|---|---|
| task | Yes | The task to reduce into next actions. | |
| context | No | Relevant blocker, constraint, or diagnostic finding. | |
| maxSteps | No | Number of actions to return; defaults to three. | |
| sessionId | No | A stable identifier for this agent recovery session. | default |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide no positive behavioral hints (all false), so the description itself must convey behavior. It does state the transformation and output nature, but it does not disclose aspects like whether actions are executed, how sessions affect behavior, or any side effects. This is adequate but not richly transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence with no wasted words. It efficiently conveys the core purpose and expected output without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description does indicate the return shape ('sequence of concrete, verifiable next actions'), which helps. However, it lacks guidance on how the tool relates to the provided sessionId/context and does not address when it should be preferred over sibling tools, leaving some practical gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema fully documents all four parameters. The description adds no parameter-specific meaning beyond the schema, hitting the baseline expected when the schema carries the load.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb ('reduce') and resource ('a complicated task') and states the output: 'a short, prioritized sequence of concrete, verifiable next actions.' This clearly communicates the tool's purpose, though it does not explicitly contrast it with siblings like diagnose or retry.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool should be used when a task is complicated and needs to be broken into manageable next actions. However, it gives no explicit when-to-use vs. alternative guidance and does not mention any exclusions or sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
retryPlan or record an intelligent retryA
Record a bounded retry with its specific change and result. Blocks unchanged or exhausted retry loops.
| Name | Required | Description | Default |
|---|---|---|---|
| notes | No | Short result or verification note. | |
| result | No | Whether the retry is planned, succeeded, or failed. | planned |
| operation | Yes | The operation to retry. | |
| sessionId | No | A stable identifier for this agent recovery session. | default |
| proposedChange | No | What will be changed before retrying. | |
| previousFailure | No | The previous failure for this operation. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only say the tool is not read-only, not idempotent, and not destructive. The description adds a real behavioral trait beyond those annotations: retries must be bounded, and unchanged or exhausted retry loops are blocked. This gives the agent useful expectations about side effects and constraints, with no contradiction against 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no filler: the first states the core action and required components, the second states the key constraint. It is front-loaded and every phrase earns its place. The description is appropriately sized for what it conveys.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The schema covers all parameters well and the description gives the core retry constraint, so the tool is basically usable. However, the title mentions 'Plan or record' while the description only explains recording, and there is no output schema or description of what happens when a retry is blocked or succeeds. The exact meaning of 'bounded' and the return behavior remain under-specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and each parameter already has a meaningful description, so the baseline is 3. The description only echoes 'change and result' which maps to proposedChange/result, and it does not add operational detail about sessionId, previousFailure, or notes. It does not need to compensate for missing schema docs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific action and resource: 'Record a bounded retry with its specific change and result.' It also adds the distinguishing guardrail—'Blocks unchanged or exhausted retry loops'—which separates it from sibling tools like diagnose or fix_me. The title's 'Plan or record' is somewhat broader, but the description still gives a clear, non-tautological purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this is for retrying an operation after a change and warns against unchanged or exhausted retry loops, so there is some embedded when-not guidance. However, it never explicitly states the triggering conditions for using this tool over a sibling, nor does it name alternatives. The usage context remains mostly inferred 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.
reuptakeRecover relevant session contextBRead-onlyIdempotent
Retrieve a compact, relevant summary of failures, attempts, facts, successes, and unresolved issues from this session.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum recent entries per context category. | |
| sessionId | No | A stable identifier for this agent recovery session. | default |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds useful output composition details (failures, attempts, facts, successes, unresolved issues) but does not disclose additional behavioral traits such as staleness, scoping caveats, or return formatting.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One front-loaded sentence states the action, the resource, and the scope with no wasted words. 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.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only, side-effect-free retrieval tool with fully documented parameters, the description gives an agent enough to call it and understand the returned content. It could briefly mention when to use it relative to siblings, but the essential invocation context is present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully documents limit and sessionId with defaults, bounds, and descriptions, so schema coverage is 100%. The description adds no parameter-specific meaning or usage examples, keeping this at the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Retrieve') and clearly identifies the resource: a compact session summary containing failures, attempts, facts, successes, and unresolved issues. It is unambiguous about what the tool does, though it does not explicitly contrast with sibling tools like diagnose or focus.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use reuptake versus its siblings such as diagnose, focus, or fix_me. The intended use case is only implied by the title and description, not explicitly stated as a condition or recommendation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
stimulateNudge a stuck agentA
Return a concise, structured recovery nudge that emphasizes reassessment, minimal checks, and changed approaches.
| Name | Required | Description | Default |
|---|---|---|---|
| task | Yes | The task on which the agent is stuck. | |
| context | No | The most relevant constraint, failed assumption, or observation. | |
| sessionId | No | A stable identifier for this agent recovery session. | default |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description is transparent about the primary behavior: it returns a nudge rather than performing the task, and it specifies the nudge's 'concise, structured' form and themes. With no output schema and annotations that provide no positive safety signal, this is meaningful disclosure, though side effects and session-state behavior are not addressed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that front-loads the action ('Return'), the deliverable ('recovery nudge'), and the key content directives. Every phrase earns its place, with no filler or duplicated schema information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The definition is adequate for a simple text-generation tool with fully documented parameters and a clear title. However, it lacks explicit sibling differentiation, usage timing, and an output-format preview, so an agent choosing among the six siblings gets only partial context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear descriptions for task, context, and sessionId, so the baseline of 3 applies. The description's mention of reassessment and changed approaches hints at how context might be used but adds no concrete parameter-level meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific deliverable—a 'concise, structured recovery nudge'—and defines its content emphasis (reassessment, minimal checks, changed approaches), so an agent knows what the tool produces. It does not explicitly distinguish this from sibling tools like diagnose or retry, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage context is implied rather than stated: the title and the task parameter describe an agent that is stuck, and context mentions failed assumptions. However, the description never says when to prefer stimulate over diagnose, reuptake, focus, retry, or fix_me, nor does it offer exclusion conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
v0.1.0- First observed
diagnose - First observed
fix_me - First observed
focus - First observed
retry - First observed
reuptake - First observed
stimulate
TDQS
Scored across 6 tools
Several tools have unclear boundaries: diagnose, focus, and fix_me all produce recommended next actions or plans, while stimulate and focus both generate recovery-oriented output. Only reuptake and retry are clearly distinct, making tool selection genuinely ambiguous.
The tools mostly follow a consistent lowercase imperative-verb style: diagnose, stimulate, focus, retry. The main deviation is fix_me, which introduces an underscore and an object pronoun, but the overall naming pattern is still recognizable.
Six tools is a reasonable size for a session-recovery-focused server. However, fix_me is an aggregate of other tools and adds some redundancy, so the set is slightly less lean than it could be.
The tool surface covers the core recovery loop well: diagnose failures, focus on next actions, retry with bounded state, and retrieve session context. Minor gaps exist around explicit session reset or state-clearing operations, but agents can generally work around them.
Maintenance
Related MCP Connectors
Persistent memory and knowledge graphs for AI agents. Hybrid search, context checkpoints, and more.
Persistent memory and drift detection for AI agents across session restarts.
Endpoint reliability and evidence checks for autonomous software agents.
Collective memory for AI agents. One agent solves a bug — every agent gets the fix instantly.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEnables AI coding agents to execute formal, stateful workflows with typed contracts, postcondition enforcement, and structured retry logic.1Apache 2.0
- AlicenseNot gradedqualityAmaintenanceEnables AI agents to retain memory of past interactions and detect behavioral drift, preventing repeated mistakes without LLM token extraction.15 npm139 PyPI207MIT
- FlicenseAqualityCmaintenanceEnables LLM-driven agents to autonomously detect, diagnose, repair, verify, and prevent software and hardware failures on local and remote systems. Includes built-in safety checks and automatic rollbacks.15-
- AlicenseNot gradedqualityAmaintenanceEnables AI agents to persist and recall episodic memories across sessions, consolidating experiences into reusable rules and lessons to reduce repeated mistakes and improve task performance.1MIT