Click on "Install 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., "@smart-coding-mcp recall project conventions"
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.
A stateful coding-analysis MCP server that gives your AI coding assistant persistent memory, deterministic code checks, and a curated rules file that grows with your project.
Try it |
|
Wire it up | drop the JSON in § Wire into your editor into your editor's |
Status | v0.2.x · Beta · 55 tests green · CI on Linux / macOS / Windows |
License | MIT |
If you just want to see it work:
uvx smart-coding-mcp doctorThat downloads the package from PyPI, runs the diagnostic in an
ephemeral Python env, and prints a report. If you see [ok] lines,
you're set up.
To wire it into your editor (Kimi Code, Claude Code, Cursor, anything MCP-aware), save the snippet below to the path your editor reads:
{
"mcpServers": {
"smart-agent": {
"command": "uvx",
"args": ["smart-coding-mcp"]
}
}
}Editor | Config file |
Kimi Code |
|
Claude Code |
|
Cursor |
|
Claude Desktop | use |
Start a new session. The orchestrator will start using the lesson store automatically; there's nothing else to wire up.
If anything fails, jump to Troubleshooting.
Related MCP server: CodeImpact
A stateful coding-analysis MCP specialist for the Kimi Code (and
Claude Code / Cursor / any MCP-aware orchestrator) agent loop. It
holds a persistent lesson store, runs deterministic static checks the
LLM shouldn't be trusted with, and helps a project evolve a curated
rules file (AGENTS.md) over time.
The agent itself does not call any LLM. Every "intelligence" call comes from the orchestrator. Its job is to:
Hold persistent state across sessions.
Run deterministic checks the LLM can't be trusted with.
Make past lessons trivially retrievable so the orchestrator applies them.
That's what "evolution" looks like today: persistent lessons + an orchestrator that follows the recall-at-start / record-at-end convention (see § Convention).
Three ways — pick the one that fits.
The package is on PyPI as smart-coding-mcp. You can run it
ephemerally (uvx) or install it persistently (pip / uv add).
Run without installing — uvx pulls the latest published wheel
into a throwaway env, runs the command, then discards the env:
uvx smart-coding-mcp # start the MCP server (default subcommand)
uvx smart-coding-mcp doctor # one-shot diagnostic
uvx smart-coding-mcp --help # list subcommandsInstall into your current Python env:
pip install smart-coding-mcp # runtime only
pip install "smart-coding-mcp[dev]" # also installs pytest + ruffCross-platform: works on Linux, macOS, and Windows. Python 3.10+ required.
⚠️ Important name note. Always type
smart-coding-mcp(with the-mcpsuffix). PyPI hosts another package calledsmart-agentowned by someone else;uvx smart-agent doctorresolves to that one and crashes withModuleNotFoundError: readlineon Windows. See Troubleshooting.
Use this when you want to modify the code.
git clone https://github.com/cbuntingde/smart-agent
cd smart-agent
uv sync
uv run smart-coding-mcp # == uv run smart-coding-mcp serve
uv run smart-coding-mcp doctorEdits land in the next session without re-installing.
Same as option 2, but Kimi Code's mcp.json points directly at the
working tree so any unsaved changes are live:
{
"mcpServers": {
"smart-agent": {
"command": "uv",
"args": [
"--directory", "/path/to/smart-agent",
"run", "smart-coding-mcp"
]
}
}
}In all three paths the entry point is the same: smart-coding-mcp,
with subcommands serve (default), doctor, --help.
smart-coding-mcp speaks the Model Context Protocol over stdio.
Any MCP-aware client can use it.
~/.kimi-code/mcp.json:
{
"mcpServers": {
"smart-agent": {
"command": "uvx",
"args": ["smart-coding-mcp"]
}
}
}claude mcp add --transport stdio smart-coding-mcp -- uvx smart-coding-mcp~/.cursor/mcp.json:
{
"mcpServers": {
"smart-coding-mcp": {
"command": "uvx",
"args": ["smart-coding-mcp"]
}
}
}Streamable HTTP isn't directly supported in the connector UI. Wrap the
stdio server with mcp-remote:
npm install -g mcp-remoteThen in Claude Desktop's custom connector config:
{
"smart-coding-mcp": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://search.parallel.ai/mcp"]
}
}Replace smart-coding-mcp endpoint accordingly — Claude Desktop's
connector dialog accepts the mcp-remote --stdio uvx ... wrapper if you
point it at a stdio script.
uvx smart-coding-mcp doctorIf you see [ok] lines for paths, DB, and store stats — and your
editor's mcp.json is in place — you're done.
Capability | How |
Persistent memory across sessions | SQLite + FTS5 lesson store at |
Deterministic static analysis |
|
Subprocess linters and tests |
|
Living conventions file |
|
Recall-at-start / record-at-end loop |
|
The orchestrator's LLM does the reasoning. This agent is the stateful, deterministic scaffolding around it.
Platform | Tested in CI |
Linux (Ubuntu) | ✅ |
macOS | ✅ |
Windows | ✅ |
Python 3.10, 3.11, 3.12, 3.13 all tested.
Concern | Where |
Schema evolution |
|
Crash safety | Per-operation SQLite connections (no shared long-lived handle). WAL + |
Logging | stdlib |
Monitoring |
|
Input validation | All tool params go through FastMCP's Pydantic schema; the store enforces caps on summary (500), evidence (2 000), tag count (32), tag CSV length (500). |
Security | See |
Reproducibility |
|
See ARCHITECTURE.md for a deeper dive (module map,
data flow diagram, schema versioning protocol, logging conventions,
configuration env vars, what-it-doesn't list).
In one sentence: the orchestrator talks to this server via MCP; the
server holds a SQLite store and an AGENTS.md file; the server never
calls an LLM.
14 MCP tools, organised by what they do:
Purpose | Tools |
Memory — write |
|
Memory — read |
|
Conventions |
|
Static analysis |
|
Diagnostics |
|
Plus three resources (memory://recent, memory://stats,
conventions://current) and one prompt (code_review).
Full list: ARCHITECTURE.md.
The agent gets smarter only if the orchestrator follows this discipline:
BEFORE tackling a task:
1. Call recall_lessons(query=task_topic, k=5)
2. Read conventions://current
3. Apply each relevant rule before flagging it as a new finding
AFTER each non-trivial task (or whenever you learn something reusable):
1. Call record_lesson(category, summary, evidence, tags)
— keep summary atomic (~80 chars)
— category ∈ bug, style, perf, convention, debt, risky, win
— tags comma-separated, no spaces within tags
2. If the lesson is project-wide, also call set_convention(...)
— plain English, 1-3 sentencesThe MCP server's instructions field repeats this so any MCP-aware
orchestrator gets the reminder at session start.
Goal | Status |
Persistent memory across sessions | ✅ SQLite + FTS5 lesson store |
Deterministic static analysis | ✅ built-in |
Subprocess linters and tests | ✅ |
Living conventions file | ✅ |
Recall-at-start / record-at-end loop | ✅ |
Code self-modification of the agent itself | ❌ not shipping in any production tool |
Online weight learning | ❌ not production-stable |
True evolutionary self-improvement | ❌ research-only |
The agent doesn't try to do the impossible — it does the things that actually compose to "smarter over time": lessons persist, the orchestrator applies them, the orchestrator records new ones, the conventions file grows.
Honest list of what's still imperfect as of v0.2.x:
Multi-user / shared AGENTS.md. Every entry is appended; no
merge logic or ownership tracking. Treat as single-author.
Prompt injection. Convention text ends up in the orchestrator's
context (the orchestrator decides how — this server doesn't write
to LLM prompts directly). Treat AGENTS.md like any user-supplied
file that ends up in an LLM prompt.
Large codebases. analyze_path walks the FS with a default cap
of 5 000 files and skips files > 1 MB. Pass focus="risk" for huge
codebases.
Concurrency. Single-process SQLite. Multi-writer contention is rare in practice but possible if you point several long-lived MCP servers at the same DB file.
Found a sharp edge? Open an issue or fix it inline and PR — the code
is short on purpose. See CONTRIBUTING.md.
Symptom | Likely cause | Fix |
| PyPI has another | Use |
| The other |
|
|
| Switch the entry to |
| You typed | Pick one form: bare |
| Optional — |
|
| The conventions file is created lazily on first | Expected — call |
Permission errors on Windows when running tests via | The previous |
|
Path | Purpose |
| SQLite DB |
| SQLite DB |
| Curated conventions file (track in git!) |
Override the data dir with SMART_AGENT_HOME=/path/to/dir.
uvx smart-coding-mcp doctorValidates paths, DB integrity, linter availability, and store contents. Exit 0 = OK; 1 = a hard error. WARN lines don't fail the doctor.
Equivalent MCP tool (callable from a running session):
doctor_tool() returns the same report as a string.
uv run pytest # in the source tree55 tests across tests/test_{store,analyzer,server,server_new,lint, reflector,doctor,cli}.py. There's also a real-subprocess stdio
handshake verifier:
uv run python smoke_stdio.pyThe CI matrix in .github/workflows/ci.yml
runs both, plus uv build and twine check, on Linux, macOS, and
Windows against Python 3.10–3.13.
PRs welcome. See CONTRIBUTING.md for dev setup,
PR checklist, and release process. Security issues: see
SECURITY.md.
Semantic recall via sqlite-vec (embedding-based search for >10k lessons)
Per-project isolation (multi-tenant the SQLite by project_root)
reflect worker that proposes a new AGENTS.md draft as a separate, optional tool
DSPy GEPA / MIPROv2 offline prompt optimisation against measured "what worked / didn't" sets
MIT — see LICENSE. © 2026 cbunt.
Run deterministic static checks. Returns Markdown report + raw findings list.
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | Path to a file or directory (absolute, or relative to the current working dir). Defaults to the project root. | |
| focus | No | Filter: 'risk' hides pure-style (lines/format), 'style' keeps style only, 'debt' keeps debt+style+risk, 'all' keeps everything. | all |
| max_files | No | Hard ceiling on files scanned. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It states the tool is 'deterministic' and returns a report, implying no side effects, but does not disclose other behavioral traits such as read/write nature, required permissions, or potential resource usage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary purpose, and every sentence adds value. No extraneous 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?
Given the tool has three optional parameters, full schema coverage, and an output schema, the description is adequate but minimal. It does not elaborate on what 'static checks' entails or how the report is structured, which could be important for an AI agent.
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 baseline is 3. The description does not add any meaning beyond the schema for the three parameters (path, focus, max_files).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool runs 'deterministic static checks' and returns a Markdown report plus raw findings. This distinguishes it from siblings like 'lint_check' and 'by_category', though it does not explicitly differentiate from all 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?
No guidance is provided on when to use this tool versus alternatives like 'lint_check' or 'health_check'. There is no mention of prerequisites or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return lessons filtered by category (most-recent first).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results. | |
| category | Yes | Lesson category to filter by. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Only adds ordering behavior; does not disclose that limit parameter controls pagination, side effects, or permissions. Minimal behavioral info.
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?
Single sentence, no wasted words, immediately conveys core functionality.
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 output schema exists and parameters are simple, description is minimally adequate but lacks guidance on when to use compared to sibling tools. Could mention optional limit and required category.
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% with descriptions for both parameters. Description adds no further meaning beyond what schema already provides for 'category' and 'limit'.
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?
Clear verb 'Return' and resource 'lessons' with explicit filtering and ordering (most-recent first). Distinguishes from sibling 'recent_lessons' which likely returns unfiltered recent lessons.
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?
Implies use for category filtering but does not explicitly state when to use vs alternatives like 'recent_lessons'. No exclusions or prerequisites mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Same report as smart-agent doctor CLI, returned as a string.
Useful when the orchestrator wants to spot-check the installation during a session.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Implies read-only via 'spot-check' but does not explicitly state safety, destructiveness, or other behavioral details like rate limits or authorization needs.
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?
Extremely concise: two sentences front-load the main purpose and usage. No wasted words.
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 no parameters and an output schema, the description is complete. It explains what the tool does and when to use it, leaving return value documentation to the output schema.
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?
No parameters, so baseline is 4. Description adds no param info but none is needed. Schema coverage is 100%.
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?
Description clearly states it returns the same report as a CLI command as a string and is used for spot-checking installation. Purpose is specific but does not distinguish from sibling tools like 'health_check'.
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?
Explicitly states when to use: 'when the orchestrator wants to spot-check the installation during a session.' Provides clear context, though does not mention alternatives or when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the full AGENTS.md content (auto-curated project conventions).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It suggests a read-only, idempotent behavior by stating it returns content. It does not mention any side effects, rate limits, or prerequisites. The description is accurate but minimal; a 3 is appropriate for a tool with straightforward behavior.
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 sentence with no wasted words. It front-loads the purpose and provides all necessary information efficiently. Every part adds value.
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 zero parameters, the existence of an output schema (which may document return format), and sibling tools for related operations, the description is fully sufficient. It provides the key semantic meaning (returning auto-curated conventions) and requires no additional details.
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 tool has zero parameters and the schema is empty. The description adds essential meaning by specifying what the tool returns (full AGENTS.md content) and that it is auto-curated, which goes beyond the empty schema. This fully compensates for the lack of parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (return), the resource (full AGENTS.md content), and the nature (auto-curated project conventions). It is distinct from siblings like set_convention, which modifies conventions, and recall_lessons, which retrieves lessons. Specific verb and resource with no ambiguity.
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 the agent needs to know the current project conventions from AGENTS.md. However, it does not explicitly state when or when not to use it, nor does it mention alternatives like set_convention for modifying conventions. For a simple read tool with no parameters, the guidance is adequate but minimal.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return a structured JSON snapshot for monitoring.
Fields: ok boolean — always true if the store could be opened schema_version stored schema_version current_schema version this code expects wal_mode WAL / journal-mode status db_path absolute path to the SQLite file db_size_bytes file size on disk lessons_total row count in the lessons table conventions_path where AGENTS.md lives conventions_writable bool — whether AGENTS.md can be appended to
Use this for liveness/readiness checks, not for hot-path validation.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the ok field is 'always true if the store could be opened' and describes all output fields. It implies no side effects, which is appropriate for a health check.
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 well-structured with a concise overview and a bullet list of fields. Every sentence adds value, but the field list could be slightly more compact.
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 zero parameters and an existing output schema (as per context), the description fully explains the output and the condition for the ok field. It is complete for a health check tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters, so baseline is 4. No parameter description needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states it returns a structured JSON snapshot for monitoring, lists fields, and explicitly distinguishes from siblings by stating 'Use this for liveness/readiness checks, not for hot-path validation.'
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 explicitly states 'Use this for liveness/readiness checks, not for hot-path validation,' providing clear context on when to use. However, it does not mention specific alternative tools for other scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run external linter(s) and test runner; return findings + summary.
Each tool maps to the same Finding shape the built-in analyzer uses, with
source set to the tool name (e.g. 'ruff', 'pytest'). Tools not on PATH
are skipped with a reason field, not raised as errors.
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | File or directory to lint/test. Defaults to project root. | |
| runs | No | Comma-separated tools to run. Available: 'ruff', 'pytest'. Anything not on PATH is skipped (warning included in the response). | ruff,pytest |
| timeout_seconds | No | Per-tool timeout in seconds. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
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 discloses that tools not on PATH are skipped with a 'reason' field rather than raised as errors, and that each tool maps to the same Finding shape used by the built-in analyzer. However, it does not explicitly state that the tool is read-only or lacks side effects, which would be beneficial.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, front-loaded with the primary action and output. It is concise with no wasted words, while still conveying critical behavioral details about skipped tools.
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 tool has 3 parameters, all with defaults, and an output schema exists (though not shown). The description covers the core functionality and the important edge case of missing tools. It could be more complete by clarifying the relationship to sibling tools, but overall it is adequate.
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 coverage is 100%, so the description does not need to add much. The schema already documents all three parameters (path, runs, timeout_seconds) with descriptions. The description adds value by explaining the output structure (Finding shape with 'source' field) but does not elaborate on parameter behavior 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 clearly states the verb 'Run' and the resource 'external linter(s) and test runner', and specifies the output 'return findings + summary'. This distinguishes it from sibling tools like 'analyze_path' or 'health_check' which likely serve different purposes.
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 does not explicitly state when to use this tool versus alternatives. It notes that missing tools are skipped, but no direct comparison to siblings like 'analyze_path' or 'doctor_tool' is provided. Usage context is implied but not clearly delineated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Bump times_used on a lesson — call when you actually applied it.
| Name | Required | Description | Default |
|---|---|---|---|
| lesson_id | Yes | ID of the lesson the orchestrator applied. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions the action (bump field) but does not disclose return values, error conditions, or permissions. For a simple increment operation, this is adequate but lacks some detail.
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 sentence, front-loaded with the action. No extraneous words; every part serves a purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and an output schema, the description is largely complete. It covers the purpose and usage. Minor gap: no mention of what the response contains.
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 one well-described parameter. The description repeats the schema's meaning ('ID of the lesson') without adding significant new information. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (bump times_used) and the resource (a lesson), with a specific verb and resource. It distinguishes itself from siblings like record_lesson by specifying the condition 'when you actually applied it.'
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 explicitly says 'call when you actually applied it,' providing clear context for use. It does not mention when not to use or alternatives, but the directive is sufficient for the intended use case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Suggest a fix sketch by combining the issue with k similar past lessons.
This is deterministic text-stitching — no LLM is called. The orchestrator (which has the LLM) reads the result and decides whether to apply.
| Name | Required | Description | Default |
|---|---|---|---|
| k | No | Number of past lessons to draw on. | |
| issue_summary | Yes | Plain-English description of the current issue. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite no annotations, the description explicitly states that the tool is deterministic text-stitching with no LLM call, and that the orchestrator reads the result and decides on application. This provides good behavioral context beyond a simple 'suggest fix' statement, though it omits details about failure modes or output format (but output schema exists).
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 extremely concise: two sentences, no redundant phrases. The first sentence states the core purpose, the second adds essential behavioral transparency. Every word 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 simple tool (2 parameters, output schema present), the description adequately covers purpose and behavior. It does not explain error handling or details of the output, but the output schema can fill that gap. Adequate for its complexity.
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?
With 100% schema description coverage, the description adds little beyond the schema: it reiterates that k is the number of past lessons and issue_summary is a plain-English description. No additional parameter semantics are provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's verb ('Suggest') and resource ('a fix sketch') by combining the issue with past lessons. This distinguishes it from siblings like recall_lessons or analyze_path, which retrieve lessons or analyze paths rather than synthesizing fixes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use this tool (to get a fix sketch based on an issue and past lessons) and clarifies that it is deterministic and the orchestrator decides whether to apply. However, it does not explicitly list alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recall top-k lessons matching query (FTS5 retrieval).
| Name | Required | Description | Default |
|---|---|---|---|
| k | No | Number of lessons to recall (1..50). | |
| query | No | Free-text search over summary/evidence/tags. Empty string returns the most recent lessons. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description states FTS5 retrieval but does not explicitly disclose read-only nature or side effects. Adequate but could be more explicit.
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?
Single, front-loaded sentence with no fluff. Every word adds value.
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 low parameter count, schema coverage, and presence of output schema, the description is sufficient. Slight gap: no mention of output format or return structure.
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 covers all parameters (100% coverage). Description adds minimal value: 'FTS5 retrieval' and empty query behavior. Baseline 3 justified.
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?
Clearly states action (recall), resource (lessons), and method (FTS5 retrieval). Distinct from sibling 'recent_lessons' by emphasizing search matching.
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?
Implies usage for search-based retrieval versus recency, but no explicit when-to-use or when-not-to-use compared to siblings like 'recent_lessons'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the most-recent lessons (chronological).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | How many recent lessons to list (1..100). |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only states 'most-recent lessons (chronological)' without explaining return format, pagination, read-only nature, rate limits, or what 'lessons' includes. This is insufficient for a tool with no 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?
The description is a single, front-loaded sentence with no unnecessary words. Every part is essential: verb, resource, ordering. Extremely concise.
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 that an output schema exists and there is only one parameter, the description is minimally adequate but could provide more context about the returned data, default behavior, or time scope. However, it does not mislead and covers the core functionality.
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% for the single 'limit' parameter, which already has a clear description. The tool description adds no extra value beyond the schema, so baseline 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 'Return the most-recent lessons (chronological)' clearly states the verb ('Return'), the resource ('lessons'), and the ordering ('most-recent', 'chronological'). It differentiates from sibling tools like 'recall_lessons' (likely search) and 'record_lesson' (write), making purpose unambiguous.
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?
No guidance on when to use this tool vs. alternatives (e.g., 'analyze_path', 'by_category'). No mention of prerequisites, context, or exclusions. The agent lacks information to choose optimally among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Record a lesson into the persistent store. Returns the new lesson.
| Name | Required | Description | Default |
|---|---|---|---|
| tags | No | Comma-separated tags (no spaces within tags). e.g. 'python,async,timeout'. | |
| summary | Yes | One-line atomic takeaway. Prefers the form 'In <context>, do/avoid X because Y'. Target: ~80 chars. | |
| category | Yes | Lesson category: bug, style, perf, convention, debt, risky, win. | |
| evidence | No | Optional file:line or short quote that triggered the lesson. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions persistence and return value but does not disclose side effects (e.g., overwrite behavior, permissions, rate limits) or what happens with duplicate keys.
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 extremely concise with two sentences, front-loaded with the purpose. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description mentions the return value (implied output schema) and covers the basic action. However, given the tool has 4 parameters and no annotations, it lacks details on error handling, uniqueness, or concurrency. Could be more complete.
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 baseline is 3. The description does not add additional meaning beyond the schema; it only restates the tool's purpose. Parameter details are adequately covered in 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 clearly states the action ('Record a lesson') and the return value ('Returns the new lesson'). It distinguishes from sibling tools like 'recall_lessons' (retrieve) and 'recent_lessons' (list).
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 usage when saving a new lesson, but does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return a Markdown draft of new AGENTS.md conventions from recent lessons.
The orchestrator curates which lines to apply by calling set_convention() for each. The agent itself does no LLM calls — the draft is a deterministic aggregation of stored signals (category breakdown, frequently-recurring tags, never-recalled lessons, top-referenced).
| Name | Required | Description | Default |
|---|---|---|---|
| dry_run | No | If true (default), return the draft without side effects. The agent never auto-writes AGENTS.md; this tool only ever returns a Markdown proposal for the orchestrator to curate. | |
| min_count | No | Minimum tag-cluster mentions to surface as a candidate convention. | |
| lookback_n | No | Number of recent lessons to consider (1..500). |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses key behaviors: deterministic, no LLM calls, no auto-writes, and side-effect-free when dry_run is true. It sets clear expectations about what the tool does and doesn't do.
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 concise (3-4 sentences), front-loaded with the core purpose, and provides context on orchestration and determinism without wasted words.
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 tool has three parameters fully documented in the schema, an output schema exists, and the description covers purpose and behavior, the context is quite complete. Slight lack of explicit usage scenarios prevents a perfect score.
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 baseline is 3. The description does not add additional meaning beyond the schema descriptions for the three parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns a Markdown draft of new AGENTS.md conventions from recent lessons, using a specific verb and resource. It distinguishes from siblings like set_convention (which applies) and get_conventions (which retrieves existing).
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 indicates that the orchestrator curates lines by calling set_convention(), implying this tool is for generating a draft to be curated, not for direct modification. It provides clear context but lacks explicit exclusions or a full alternatives list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Append a new convention to AGENTS.md and return its line number.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | A new convention to append. Plain English, ~1-3 sentences. Don't repeat existing conventions; cite the lesson id if relevant. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
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 states that the tool appends (non-destructive write) to AGENTS.md and returns a line number. However, it does not explain side effects (e.g., whether duplicate conventions are allowed), permission requirements, or potential failures, which limits transparency to a basic level.
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, short sentence that front-loads the key action ('Append a new convention to AGENTS.md') and immediate result ('return its line number'). Every word is necessary, with no filler or repetition.
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 a simple tool with one parameter and an existing output schema, the description adequately covers the action, affected resource, and return value. It specifies that the operation is an append and provides the output type (line number), which is sufficient for 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?
The input schema for 'text' is well-described with length constraints and usage guidance (plain English, 1-3 sentences, cite lesson id). The tool description adds no additional meaning beyond 'new convention', so it does not improve parameter understanding. Baseline 3 applies because schema coverage is 100%.
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 the specific verb 'Append' and clearly identifies the resource as 'AGENTS.md' and the action of adding a 'new convention'. It also immediately states the return value (line number), making the tool's purpose distinct from siblings like get_conventions (read) or record_lesson (different action).
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 does not provide any guidance on when to use this tool versus alternatives such as get_conventions or record_lesson. No context is given for appropriate use cases or when to avoid using it, leaving the agent to infer usage solely from the tool name and siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return total and per-category counts.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must carry behavioral transparency. It only states it returns counts. No mention of side effects, data source, performance, or idempotency. Minimal disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise at 6 words. Every word earns its place. Could be slightly improved by specifying the 'store' context, but for a zero-parameter tool it is efficient.
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 no parameters and an output schema, the description need not explain return values. However, with no annotations and several sibling tools, more context about the 'store' would help an agent select this tool correctly. Currently it is minimally viable.
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?
No parameters exist, so the description does not need to add meaning beyond the schema. Baseline for 0 parameters is 4. The description is adequate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns total and per-category counts. It uses a specific verb ('Return') and noun ('total and per-category counts'), but lacks context about what 'store' refers to. Still, it distinguishes itself from sibling tools like 'by_category' in that it provides both total and per-category counts.
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?
No guidance on when to use this tool versus alternatives like 'by_category' or 'analyze_path'. No context on prerequisites or exclusions. The description gives no usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.3.0analyze_pathby_categorydoctor_toolget_conventionshealth_checklint_checkmark_lesson_usedpropose_fixrecall_lessonsrecent_lessonsrecord_lessonreflectset_conventionstore_statsMost tools have distinct purposes, but there is overlap between analyze_path and lint_check (both analyze code) and between recall_lessons and recent_lessons (both retrieve lessons). Descriptions help differentiate, but ambiguity remains.
Naming conventions are inconsistent, mixing verb_noun (e.g., recall_lessons), noun-only (e.g., health_check), and compound names (e.g., mark_lesson_used). No clear pattern across tools.
14 tools is well within the typical 3-15 range for a focused server, covering lessons, code analysis, and configuration without feeling excessive.
The tool surface covers core CRUD for lessons and static analysis, but lacks a delete lesson tool and an apply fix tool, representing notable gaps for complete workflows.
Persistent memory and cross-session learning for AI coding assistants (hosted remote MCP).
Cloud-hosted MCP server for durable AI memory
An MCP memory server. One memory your agents share — across models, devices and apps.
MCP server for building and testing AI agents with multi-model experimentation and insights.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/cbuntingde/smart-agent'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
