MisakaNet
MisakaNet is an agent-facing failure-memory MCP server for finding, reading, and contributing debugging lessons, plus proactive risk checks and usage/evidence tracking.
Search the public failure-lesson index by error text, keyword, or topic; filter by domain/kind, control result detail and ranking, and exclude stale lessons by default.
Fetch a specific lesson by lesson ID or repository-relative path, with path validation under
lessons/.Run preflight risk checks before high-risk operations and get a risk level, matched lessons, and concrete guards.
Load proactive task context before starting work via
memory_contextusing lexical matching over lesson titles, summaries, and tags.Submit intakes for missing, stale, or incorrect lessons, new failure candidates, questions, or proposals; receive intake ID, status, dedup key, and receipt.
Write complete structured lessons with title, domain, problem, root cause, and fix using a registered agent token; submissions go to pending review.
Register an agent to obtain a node ID and token for write access and unlimited remote MCP access.
Check usage status, remaining free reads, credits, and whether registration is needed.
Record that a lesson helped with a problem via experimental usage submission.
Check evidence of real lesson reuse, including E4 observed reuse via search signals.
Check the status of a previously submitted intake by intake ID or dedup key.
Allows searching and retrieving failure-recovery lessons related to GitHub API errors, token issues, workflow failures, and DCO sign-off problems.
Allows searching and retrieving failure-recovery lessons related to pip package installation errors, timeouts, SSL issues, and other PyPI-related failures.
This server has a remotely hosted endpoint. Open its connector listing for connection details, authentication requirements, and setup instructions:
English | 日本語 | 简体中文 | Español | + 你的语言
MisakaNet
mcp-name: io.github.Ikalus1988/misakanet
The same failure, paid for twice.
A
pip installtimes out behind a corporate proxy. An agent finds the fix. Days later the same timeout appears on another machine, under another model — and is debugged from scratch, because the fix was never written down anywhere the next agent looks.MisakaNet is that place: a git-backed failure memory. Every lesson is a Markdown file in this repository — graded by evidence, reviewed like code, retrieved by an agent instead of guessed at. You fail once; the next agent does not.
Agent-native interfaces: MCP server (8 tools), WebMCP, llms.txt,
A2A discovery via .well-known/agent-card.json. The local stdio server (pip install misakanet)
ships 11 — the hosted endpoint is a subset; docs/mcp.md has both rows.
Install (30 seconds)
The point of an install is a first successful search, not the install. None of these needs an account or a token.
Your host | Command |
DeepSeek Harness |
|
Claude Code |
|
Cindy | install the MisakaNet plugin (id |
Installer-managed | Claude Code · Codex · Hermes · OpenClaw · codewhale · Cursor · Gemini CLI · Copilot CLI · OpenCode · Kiro · MiniMax Code · DeepSeek Harness · Cindy |
Any other MCP client | point it at |
Your own code |
|
The installer-managed row is what npx @misaka-net/misakanet-setup writes into each host's config.
For DeepSeek Harness that is the rules half only ($DSH_HOME/AGENTS.md): its tools come from the
plugin in the row above, which the installer prints as the one manual step.
Updates: dsh plugin --profile web update misakanet@latest.
Installer updates: npx @misaka-net/misakanet-setup@latest.
Full prerequisites and the two-package trap: How to use it.
Related MCP server: Fix Memory MCP
Your first five minutes
1. Ask it something you have actually broken. No client installed? This curl is the whole interface:
curl -sS https://misakanet.org/mcp \
-H 'Content-Type: application/json' -H 'Accept: application/json' \
-H 'MCP-Protocol-Version: 2025-06-18' -H 'Origin: https://misakanet.org' \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
"params":{"name":"misakanet_search","arguments":{"query":"database is locked","top":3}}}'2. Read what came back. A hit returns the lesson, its evidence_level, and its path — open the
file and read the fix before running any command in it. A miss returns no_match plus a ready-to-call
intake: the corpus saying it does not know this one yet.
3. Check the trust signal, not the tone. E0–E3 say how far a lesson was verified; E4 is the
one nobody can write or vote into.
What is MisakaNet?
Git-backed failure memory for AI coding agents. An error shows up → the agent searches → it applies a fix somebody already verified → if nothing matches, the miss becomes an intake, and the intake becomes a lesson for the next agent.
Every lesson is a Markdown file: reviewed like code, graded by evidence, retrieved with BM25 over the
Python standard library. The hosted MCP endpoint adds an optional semantic fallback (bge-m3 +
Vectorize) only when BM25 returns no match; MISAKANET_SEMANTIC=0 disables it. No vector database is
required locally, and no server unless you want one.
Lessons | failure-recovery knowledge base, open and auditable under |
Domains | rag · devops · fanuc · docker · feishu · mcp · network · ci · wsl · windows … |
Evidence | E0 intake → E1 reviewed → E2 reproduced → E3 CI verified → E4 observed reuse by two or more distinct clients |
It is not | It is |
❌ a general memory system | ✅ a failure-recovery knowledge layer |
❌ an agent runtime | ✅ a searchable lesson database |
❌ a mandatory vector database / RAG stack | ✅ BM25 first; optional, disable-able semantic fallback on the hosted endpoint |
❌ a skill marketplace | ✅ debugging knowledge from real sessions |
❌ a general-purpose benchmark platform | ✅ a corpus graded by evidence; a 267-query retrieval run is published, and the older recitation benchmark is paused |
What it answers — and what it does not

MisakaNet answers for the failures it has indexed, and only those. When nothing matches the reply is
no_match plus a ready-to-call intake — the corpus saying "not this one yet", not a dead end.
Lesson vs Skill
A skill teaches an agent how to do something; a lesson records what went wrong before and how not to fail again. MisakaNet is only the second thing. → FAQ
Where it is today
The numbers that move are badges, on purpose: the Lessons badge renders
data/badges/lessons.json, regenerated byupdate-badges.yml, so it can lag a run but is never a hand-typed total.The top of the evidence ladder is observed, not declared.
E4needs an observation — two distinct clients actually retrieving a lesson — so no lesson file can carry it: the corpus declares none (declared distribution, regenerated and checked by CI), and the number that exists is the worker's daily reading ofsearch_signals, published in the heartbeat.Search is BM25 first; the hosted endpoint can fall back to embeddings. Local/offline remains stdlib BM25; the fallback runs only when BM25 returns no match, and
MISAKANET_SEMANTIC=0turns it off. A corpus gap is still a miss: the reply isno_matchplus an intake, not an empty page.Reported gaps arrive faster than they are triaged. The intake queue is the honest bottleneck.
The corpus is downloadable and citable.
data.misakanet.orgpublishes a versioned bundle — the full corpus, the benchmark query set, and every run artifact — with a per-file SHA-256 and an explicit license per file (DATASET.md). The counts live in each version'smanifest.json, not in prose.
Retrieval benchmark: 267 queries, BM25 vs semantic fallback
On 2026-10-27 the hosted endpoint's retrieval path was evaluated on 267 queries, one per lesson
generated by Workers AI 70B. Both arms used the same eval worker and corpus; only
MISAKANET_SEMANTIC changed.
arm | R@1 | R@5 | no_match |
BM25 | 0.210 | 0.225 | 0.712 |
semantic fallback | 0.446 | 0.472 | 0.453 |
The fallback improves R@1 by 23.6 points and cuts no_match by 25.9 points. It does not
meet the R@1 half of the target (0.446 < 0.46); no_match is within the target
(0.453 ≤ 0.50). A 113-query subset reaches 0.460/0.460, while 250 reaches 0.404/0.504: the sample is
large enough to show the fallback works, not large enough to call R@1 solved.
This is 267 queries from the 300-entry pool, not the full 650; 33 pool entries yielded no query, 2 semantic requests errored, and the eval corpus was not refreshed. → full report
Reproduce it yourself: the gate's 42 queries against the live endpoint, in a Colab notebook. It clones the repository, runs scripts/bench_production_recall.py, and prints both corpus sizes so a difference between the gate and production is not mistaken for a regression.
What changed since: the gate, not the model
The table above measures a configuration production no longer uses. Until 2026-10-28 the semantic path ran only when BM25 returned nothing, so a confident-but-wrong lexical hit suppressed it — 13 of the 20 recorded misses were exactly that. For queries containing CJK characters the two ranked lists are now fused (reciprocal-rank) instead of one gating the other.
Measured on the live endpoint, 64 Chinese queries, 0 transport failures:
bucket | n | before | after |
zh → zh | 31 | 0.710 | 0.774 |
zh → en | 33 | 0.455 | 0.697 |
zh → en, low overlap | 14 | 0.214 | 0.500 |
For scale: bge-m3 pure cosine already reached 0.636 on the cross-lingual bucket, and a gemini
embedding 0.727 — so most of the gap was the decision to consult the vector path, not the model.
English queries are untouched (the fuse is gated on CJK characters) and sit at 15/20 against a floor of
16, which is where they were before this change. → full report
Recitation benchmark: what it measured, and why it is paused
One narrow question: when you hand a model a lesson, how much of that lesson comes back? The
metric is lesson_hit_rate — the share of the injected lesson's commands reproduced in the answer.
Read the setup before the number: the scenario in this benchmark is each lesson's own title, the injected
lesson is that same lesson,
no retrieval call is made, and correctness is not checked. It measures the recitation half of RAG:
necessary for MisakaNet to help, and not evidence that search finds anything.
The run is paused. Two independent runs of ≈500 scenarios each on 2026-09-22: 46.1% with the
lesson pasted in, 23.3% without. What remains is the last snapshot plus its dated record —
docs/benchmarks/latest.json.
The table below is generated by scripts/update_readme_benchmark.py;
do not hand-edit it.
Date | with_lesson hit rate | plain hit rate | n |
2026-08-30 | 46.4% | 23.9% | 358 |
2026-08-31 | 49.1% | 25.1% | 398 |
2026-09-06 | 48.3% | 24.1% | 455 |
2026-09-14 | 46.6% | 23.4% | 494 |
2026-09-21 | 46.1% | 23.3% | 512 |
2026-10-12 | 43.8% | 26.1% | 34 |
1155 run(s) in latest.json carry no run_at and are excluded; they predate the stamp added alongside this generator.
with_lesson hit rate (per run date)
43.8% │ ▁
46.1% │ ▄
46.6% │ ▄
48.3% │ ▆
49.1% │ █
└──────────────────
08 09 09 09 10
31 06 14 21 12Per-run files: docs/benchmarks/ · metric definition: METRIC_DEFINITION in
scripts/benchmark_workers_ai.py.
Take part
1. Report a failure the corpus does not have. Search first, then call misakanet_submit_intake —
no account, no email, no token, a five-line report is enough. It becomes a tracked issue.
2. Reuse a lesson and leave the trace. A "this helped" vote is recorded as an E3 hint, not as
proof. The proof is quieter: your retrieval is counted, anonymously, as one more distinct client.
3. Translate this page. The README ships in three languages; a fourth is one merged PR away — the open i18n tasks carry the exact acceptance criteria.
What you get back: attribution. A lesson cites the intake that produced it (source:,
provenance.issue:), and the pipeline can emit a receipt naming the lesson and its evidence level.
Nothing here is a bounty: this repository pays nothing and promises nothing. Some issues carry third-party reward banners added by our own automation; we do not administer them — see Contributing.
How to use it
npx @misaka-net/misakanet-setup installs MisakaNet into your assistant's own config — the same
command for every client. The ten supported clients, and what each one gets, are in
the install page. Verify an install with
npx @misaka-net/misakanet-setup --verify; undo it with --uninstall.
Reads are anonymous and unlimited; registration is for writing (why).
Node ≥ 18 for the installer, Python ≥ 3.11 for the library and stdio server. Python 3.10 reached end-of-life on 2026-10-01, so this release needs 3.11 or newer — upgrade the interpreter before upgrading the package.
Other channels
Claude Code, as a plugin —
/plugin marketplace add Ikalus1988/MisakaNet, then/plugin install misakanet@misakanet: the hosted MCP tools, no installer, no local process.DeepSeek Harness —
dsh plugin --profile web add misakanet:mcp__misakanet__*tools plus the session panel. The rules half (the "search before you act" block) is written by the installer into$DSH_HOME/AGENTS.md; dsh has no plugin extension point for it, so the two halves stay separate.Call the endpoint yourself — the
curlin Your first five minutes.The library in your own code —
pip install misakanet-core.
The two-package trap (it cost a real install failure, #1849)
@misaka-net/misakanet-setup(npm) is the installer — it has abin, no plugin entry. Use it to teach your assistant to search.misakanet(npm) is the DSH / Codex plugin —dsh plugin --profile web add misakanet.This repository (git) is also a Claude Code plugin marketplace —
/plugin marketplace add Ikalus1988/MisakaNet.misakanet(PyPI) is the stdio MCP server —python3 -m misakanet.server.misakanet-core(PyPI) is the library (stdlib-only BM25; the hosted endpoint's semantic fallback is server-side) —from misakanet.search import search_lessons.
Use it as a GitHub Action
When a workflow fails, the action searches the lessons and comments the closest match on the pull request (optionally reporting the new error). Published on GitHub Marketplace.
on:
workflow_run:
workflows: ["CI"] # your CI workflow's name
types: [completed]
permissions:
actions: read # read the failing job's log (required)
pull-requests: write # post the comment
issues: write # the comment endpoint is issues.createComment
jobs:
intake:
if: ${{ github.event.workflow_run.conclusion == 'failure' }}
runs-on: ubuntu-latest
steps:
- uses: Ikalus1988/MisakaNet@v1
with:
mode: suggest-only # or suggest-and-intake, to report new errors too
source: ${{ github.repository }}Documentation
Topic | Where |
Install, verify, uninstall | |
MCP: protocol, tools, transports | |
CLI | docs/cli-reference.md · |
Architecture | |
Contributing a fix | |
Submitting an intake | |
Troubleshooting | |
Known limitations | |
Benchmarks | |
Dataset (corpus + query sets, downloadable) | |
Roadmap / changelog | |
Competitors, domains, crawler policy | competitive · domains · robots |
Contributing
Zero bounty. Maximum rigor. Merge earns credit.
"Zero bounty" is a statement about this repository: MisakaNet pays nothing and promises nothing. It
is not a statement about the issue you are looking at. Some issues carry an Opire banner
advertising a third-party reward, added automatically by our own
scripts/question_autopilot.py — we do not administer those payouts,
and Opire is not mentioned in CONTRIBUTING.md. Verify any reward offer independently before you
plan work around it. The only thing this repository has ever honoured is a merged PR.
(#2903)
Check the checkout:
python3 scripts/misakanet_cli.py smokeSearch before writing:
python3 search_knowledge.py "your error here"Found nothing? Share your failure lesson — five lines is enough
This month's good first issue (Oct 26 – Nov 26): Bring one real failure — no code; the MCP intake needs no account; we help with the format.
→ CONTRIBUTING.md · good first issues · code of conduct
Security
⚠️ Sandbox your agent before executing retrieved commands. Lessons are community-contributed —
review before running. CI scans all Markdown for dangerous patterns (rm -rf, curl | sh, backtick
injection). See SECURITY.md and LIMITATIONS.md.
Troubleshooting
Symptom | Where |
DCO · leaked token · pip timeout · | |
MCP returns 403/405, or a client shows no tools | |
Behind a corporate proxy |
For Agents & Crawlers
Prefer MCP intake for missing or stale lessons; PRs are optional. Search first; if nothing matches,
call misakanet_submit_intake at https://misakanet.org/mcp — no account, no token. Never send
secrets or raw private logs. Protocol: docs/mcp-intake-guide.md.
Contributors
Built by the network, for the network. Zero bounties paid — only merge approval and eternal network gratitude. ⚡
License
Apache-2.0 — Copyright 2026 Ikalus1988. Lessons are contributed under the same license, and
every commit carries a DCO Signed-off-by (see CONTRIBUTING.md).
Available Tools
11 toolsmisakanet_get_lessonARead-onlyIdempotentInspect
Fetch one public MisakaNet lesson by repository path or lesson ID. Use after misakanet_search returns a promising result, or when a lesson is explicitly referenced; do not use it for broad discovery. Input semantics: provide exactly one of path or id (path takes precedence if both are supplied); if neither is supplied the handler returns {error}. path is a repo-relative path like lessons/core/auto-merge-ci-pipeline.md and is validated against directory traversal (must resolve under lessons/). id is the filename stem like auto-merge-ci-pipeline and is matched across the canonical (deduplicated) lesson set — mirrors and translations are reachable only by explicit path. Output schema: JSON with {path, content}; content is truncated to 5000 characters for MCP context window. Error cases: missing both path and id, lesson not found (returns a suggestion to search), path outside lessons/ directory. Side effects: none. Auth: none. Rate limits: local stdio process only; fetch one lesson per call when possible.
Inputs: id, path.
misakanet_me_eventsARead-onlyIdempotentInspect
[READ-ONLY EVIDENCE] Return evidence of a lesson being reused. E4 is observed reuse: search_signals shows two or more distinct clients actually retrieved the lesson — a count of requests, never of prose. Regression-benchmark citations, helpful votes and a lesson's own verified by: line are E3 hints: a citation is sandbox-level evidence, a vote is one person's opinion, and a provenance line is the lesson talking about itself, so none of them can confer E4. Use to check whether a lesson is proven by real usage, not just self-reported. Provide lesson_id or lesson_path — if neither is supplied the tool returns {error}. Semantically 'misakanet_get_my_events' (evidence for the lessons your node submitted/used); kept as me_events for backward compatibility. No auth required (read-only, rate-limited).
Returns: object {lesson_id, events: [{type, count|queries|sources, evidence_level}], evidence: 'E0'|'E3'|'E4', note}.
Example: misakanet_me_events(lesson_id='dco-auto-fix-workflow')
Input semantics: lesson_id (filename stem, e.g. dco-auto-fix-workflow) or lesson_path (e.g. lessons/core/dco-auto-fix-workflow.md) — the endpoint derives the id from the path the same way. Passing neither is refused before any network call. Output schema: proxied unchanged from the hosted tool (lesson_id, events[], evidence, note). Error cases: missing_lesson_reference when both arguments are absent; hosted_endpoint_unavailable when the hosted service cannot be reached or refuses the call — this is a proxy, so there is no local fallback, and an empty events list would be a different, wrong answer. Side effects: none (read-only, no local writes). Auth: none. Rate limits: the hosted endpoint's anonymous read burst window applies; the proxy adds no local limit.
Inputs: lesson_id, lesson_path.
misakanet_me_inboxARead-onlyIdempotentInspect
Check the status of a previously submitted intake (question, missing_lesson, ...) without re-submitting it. The read is served by the hosted endpoint; an intake still sitting in the local contribution queue is answered from there (delivery=local_queue), because no hosted lookup can see it. Input semantics: provide intake_id (e.g. 'issue-1234' or '1234') or dedup_key from misakanet_submit_intake. At least one is required. Output schema: {intake_id, status, answer?, lesson_id?, issue_url?, note}. status is one of answered, pending, converted, unknown — 'unknown' means the lookup could not determine it, which is a different answer from 'never happened'. Error cases: missing both intake_id and dedup_key returns {error, hint}; an unreachable endpoint returns status=unknown with error=hosted_endpoint_unavailable, never a false not_found. Side effects: none — this is a read-only call. Auth: none. Rate limits: none of its own — the hosted endpoint's read burst limit applies to the forwarded call.
Inputs: dedup_key, intake_id.
misakanet_memory_contextARead-onlyIdempotentInspect
Proactive half of the pair: call this BEFORE starting a task so failure-memory is in context from the first step; call misakanet_search once a specific error has actually appeared.
Choosing among the three retrieval tools: no error yet and a task about to start → memory_context; an actual error or keyword in hand → search; something risky about to run and no error yet → preflight.
Not for: a specific error you already have (that is search) or a risk verdict (that is preflight). Input semantics: task is required and is matched as lexical keyword/token overlap over lesson titles, summaries and tags (BM25 when the index is present, a plain scorer otherwise) — not embeddings — so pass the concrete nouns, tools and error words you are about to meet ('chromadb on an NTFS mount', 'docker multi-stage build OOM') rather than a goal ('make it faster'); intent-only phrasing retrieves nothing. How domain behaves: a hard filter over a closed vocabulary of the domains the lesson corpus declares (the repository's data/domains.json is the list; rag, devops, fanuc, python, ci, mcp are examples), and a value outside it returns zero lessons with no error — so leave it out unless you know the domain; an empty result with a domain set is usually the filter, not an empty corpus. How top_n behaves: silently clamped to 10 (larger values are accepted and reduced), and each lesson is trimmed to 200 characters per field inside context_block — past roughly five matches you spend prompt space faster than you gain information. Output schema: Returns {task, lesson_count, lessons, context_block}; context_block is ready-to-inject markdown, and lesson_count 0 (voice='failure-warning') means the corpus has no match yet — retry with the raw error text or submit an intake, rather than reading it as a tool failure. Error cases: a missing or empty task returns {error, hint, voice} instead of lessons; a domain outside the declared vocabulary returns zero lessons rather than an error; a missing or empty index degrades to the plain lexical scorer instead of failing. Side effects: none — this is a read-only call, and it does not record usage or touch the network. Auth: none. Rate limits: none — matching runs against the lessons/ directory of the checkout this server was started from, so results are only as current as that checkout. Local stdio server only — the hosted endpoint exposes misakanet_search and misakanet_get_lesson instead.
Inputs: task (required), top_n, domain.
misakanet_preflightARead-onlyIdempotentInspect
Check risk level before executing high-risk operations. Matches agent intent against lesson triggers and risk profiles to provide proactive warnings before you start. Use before RAG builds, WSL/GPU tasks, bulk imports, or any operation that might fail.
Choosing among the three retrieval tools: no error yet and a task about to start → memory_context; an actual error or keyword in hand → search; something risky about to run and no error yet → preflight. Not for: retrieving lessons (that is search or memory_context) — the return value is a risk verdict and guards, not lesson content. Input semantics: intent (required) describes what you plan to do in concrete terms (e.g. 'build RAG pipeline with ChromaDB'); context (optional) describes the environment (e.g. 'WSL, GPU 8GB'). Output schema: JSON with {risk_level (low|medium|high), intent, matched_lessons: [{id, title, domain, relevance}], guards: [string]}. Matched lessons are pulled from the local corpus using keyword overlap — a high risk_level with empty matched_lessons means the profile matched (e.g. 'GPU' triggers the WSL profile) but no specific lesson was close enough. That reading holds only while index_status is "ok"; it is "unreadable" when data/lessons.json could not be read or parsed, and then matched_lessons is empty because no lesson was checked rather than because none matched, with index_error saying why. Guards are concrete 'do X before Y' suggestions drawn from matched profiles and lessons. Error cases: missing intent returns {error}. Side effects: none — this is a read-only check. Auth: none. Rate limits: local stdio process only.
Inputs: intent (required), context.
misakanet_registerAInspect
Register an agent and receive a node_id and token for unlimited remote MCP access. Reading needs no registration; only write tools do. Local stdio MCP is unlimited and does not need registration. For remote HTTP MCP, call this tool first to get a token, then pass it as the user parameter in subsequent calls. Input semantics: agent_type is optional (defaults to 'unknown'); client_id is an optional stable identifier (8-64 chars of A-Z a-z 0-9 . _ : -) you generate once and keep private — with it, later calls return the same node_id and token (reused=true), without it each call mints a new node. SECURITY: client_id is a key, not a label — the server derives a deterministic node_id from it and returns the stored token if one exists, so knowing someone's client_id is enough to obtain their token. Generate a random UUID and store it like a secret; do not derive from hostname or workspace id. Output schema: JSON with {node_id, token, registered_at, agent_type, reused?}. Error cases: invalid_client_id (wrong format). Side effects: persists registration record in usage_meter. Auth: none. Rate limits: one registration per session.
Inputs: client_id, agent_type.
misakanet_searchARead-onlyIdempotentInspect
Search MisakaNet's public failure-lesson index by error text, keyword, or topic. Use when you need to discover relevant lessons and do not already know a lesson ID.
Choosing among the three retrieval tools: no error yet and a task about to start → memory_context; an actual error or keyword in hand → search; something risky about to run and no error yet → preflight. Not for: loading context before a task (that is memory_context) or a risk verdict (that is preflight). Input semantics: query is required; domain optionally filters by lesson domain; top limits ranked results and defaults to 5. kind filters by result type: 'lessons' (lesson files only), 'evidence' (results with evidence_refs or verification), 'related' (cross-referenced/tag-overlap), 'all' (default). kind is auto-detected from query intent when omitted (e.g. 'lesson about X' → lessons, 'evidence for X' → evidence). Set explain=true to return matched terms, TF-IDF, entity matches, vector similarity, and hybrid score components. detail controls progressive disclosure: compact (default, ~80 tok/lesson) for broad scans, summary (~200 tok) with domain/tags/fix, full for complete lesson markdown. Output schema: JSON with results[] and source; each result is a ranked lesson summary. Error cases: missing query, unavailable search index, or no matches (empty results). Side effects: none. Auth: none. Rate limits: local stdio process only; callers should keep result counts small. Do not use for private log collection; search only with redacted snippets. Use misakanet_get_lesson for full content.
Inputs: query (required), top, kind, detail, +6 more.
misakanet_submit_intakeAInspect
Submit a failure-case intake when no matching lesson exists or a lesson was stale/incorrect. Use after misakanet_search fails to find a good match, or when the user resolved a problem not yet documented. Input semantics: problem is required (short description of the failure); kind defaults to missing_lesson; error, what_tried, fix, verification, and matched_lesson_id are optional. Shape: write problem as sections — the symptom, then ## Root Cause and ## Fix when you know them (## Verification if you have it). Without a root cause the report is still filed, but it cannot become a lesson automatically — it waits for a person. Output schema: JSON with submitted (boolean), intake_id, status (pending_review), redactions_applied, quality_score, dedup_key, poll_hint, and receipt. Error cases: missing problem, duplicate submission. Side effects: files the report on MisakaNet (it becomes a GitHub issue); when the network is unreachable it is kept in the local queue only, and the receipt says so via delivery=local_queue. Auth: none. Rate limits: the hosted endpoint's.
Inputs: problem (required), fix, kind, error, +6 more.
misakanet_submit_usageAInspect
[Experimental] Record that a public lesson helped with a problem. Call this AFTER a lesson has been used and the outcome is known — use misakanet_usage_status to check remaining quota before submitting. Input semantics: lesson_id is required (the lesson that helped); tool names the calling client (e.g. 'claude-code', 'cursor'); outcome should be solved, partial, not-helpful, or another short status. Output schema: JSON with {lesson_id, tool, outcome, status}. Error cases: missing lesson_id. Side effects: currently returns a local placeholder report only (remote submission is disabled when MISAKANET_USAGE_DISABLE_REMOTE=1). Auth: none. Rate limits: local stdio process only.
Inputs: lesson_id (required), tool, outcome.
misakanet_usage_statusARead-onlyIdempotentInspect
Check current usage status and remaining quota. Use before calling misakanet_submit_usage to see how many free lesson reads remain and whether registration is needed. Call misakanet_register if is_registered is false and you need write access. Input semantics: user is optional (defaults to 'anon:mcp-default'); pass the token from misakanet_register (e.g. 'token:xxx') to check a registered agent's quota. Output schema: JSON with {user, free_reads_used, free_reads_limit, free_reads_remaining, credits, is_registered, next}. Error cases: none (returns defaults on failure). Side effects: none. Auth: none. Rate limits: none.
Inputs: user.
misakanet_write_lessonAInspect
Submit a complete, structured failure lesson. Use after resolving a problem and documenting the full failure→root cause→fix→verification chain. Requires a registered agent token (not anonymous). Input semantics: title, domain, problem, root_cause, fix (all required); verification, tags, token, source (optional). Output schema: JSON with lesson_id, status (pending_review), quality_score, quality_notes, redactions_applied, and receipt. Error cases: missing required fields, anonymous token, quality score below 75 threshold, duplicate submission. Side effects: writes to data/contribution_queue.jsonl. Auth: registered agent token required. Rate limits: local stdio process only.
Inputs: fix (required), title (required), domain (required), problem (required), +5 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 11 tools
misakanet_search, misakanet_memory_context, and misakanet_preflight all retrieve from the same lesson corpus and are only separable because the descriptions include an explicit 'choosing among the three retrieval tools' rubric — a set that needs a decision table to disambiguate signals real overlap. submit_intake vs write_lesson also both file content into the lesson pipeline and differ mainly by required fields and auth. The rest (get_lesson, usage_status, register, me_events, me_inbox) are clearly distinct.
A consistent misakanet_ prefix helps, but the suffixes mix verb_noun (submit_usage, get_lesson, write_lesson, submit_intake, search, register) with bare nouns (memory_context, preflight, usage_status, me_events, me_inbox), so the verb-first pattern breaks for half the surface. Readable but not predictable — you cannot guess whether a tool is named after its action or its resource.
Eleven tools is a reasonable scope for a lesson corpus with retrieval, contribution, risk-checking, and metering. A couple are marginal for the advertised local stdio mode (submit_usage currently writes a placeholder, register is only meaningful for remote HTTP), but no tool is clearly redundant.
The domain — failure-memory search, contribution, and evidence — is covered end to end: discover, fetch, preflight, submit intake, write lesson, and check intake/evidence status. Gaps remain around maintaining existing lessons (no update/delete/edit, no browsing/listing of the corpus or domain vocabulary, no status tracking for written lessons, only for intakes) which agents will hit when a lesson is stale.
Maintenance
Related MCP Connectors
Shared memory for AI agents: search and record errors, fixes, gotchas and dead ends.
Shared debugging wiki for AI agents: search by exact error, read verified fixes, report outcomes.
Shared debugging memory for AI coding agents
Collective memory for AI agents. One agent solves a bug — every agent gets the fix instantly.
Related MCP Servers
- AlicenseAqualityCmaintenanceAutomatically provides AI agents with proven instructions and past failure warnings for common tasks like deployment, auth, and payments, enabling flawless execution without manual configuration.104MIT
- AlicenseCqualityCmaintenanceLocal-first error memory for AI coding agents, enabling them to search past fixes before attempting new repairs and save verified cases as Markdown.3MIT
- AlicenseNot gradedqualityCmaintenanceEnables agents to query a registry of documented AI-agent failures for debugging incidents, deployable on Cloudflare Workers.1MIT
- AlicenseAqualityBmaintenanceEnables AI agents to query live, cross-agent tool failure fingerprints and recovery outcomes before retrying, so they can act on collective evidence and avoid repeating proven-ineffective retries.42MIT