Ikalus1988/MisakaNet

MisakaNet

Git-backed failure-memory for AI coding agents.

Zero dependencies. Zero server. Zero database. Paste an error → search 290 lessons → get a fix path.

mcp-name: io.github.Ikalus1988/misakanet

---

What is this?

Git-backed failure-memory for AI coding agents. Zero dependencies. Zero server. Zero database.

Agent hits an error → search 290 lessons → get a fix path. No prompt leaking, no raw logs stored.

🔥 New: No-account MCP intake. If your agent finds no good lesson, submit a failure case directly:

curl -sS https://misakanet.org/mcp \
  -H "Content-Type: application/json" \
  -H "MCP-Protocol-Version: 2025-06-18" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"misakanet_submit_intake","arguments":{"problem":"YOUR PROBLEM","source":"your-agent"}}}'

No GitHub account. No email. No Bearer token. No browser. The intake becomes a maintainer-visible GitHub issue for review.

Try in 30 seconds

Option 1 — Search a failure:

git clone https://github.com/Ikalus1988/MisakaNet.git && cd MisakaNet
python3 scripts/misakanet_cli.py smoke

Option 2 — Connect MCP to your agent:

python3 scripts/mcp_server.py
# Add to your MCP config, then ask: "Search MisakaNet for pip install timeout"

Option 3 — Submit a missing lesson via remote MCP (no account):

curl -sS https://misakanet.org/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Origin: https://claude.ai" \
  -H "User-Agent: MisakaNet-Remote-Agent/1.0" \
  -H "MCP-Protocol-Version: 2025-06-18" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"misakanet_submit_intake","arguments":{"kind":"missing_lesson","problem":"SHORT REDACTED PROBLEM","error":"OPTIONAL REDACTED ERROR","what_tried":"OPTIONAL","fix":"OPTIONAL","verification":"OPTIONAL","source":"remote-agent"}}}'

Option 4 — DeepSeekHarness recovery adapter:

python3 scripts/mcp_deepseek_adapter.py

→ HTTP MCP journey · Remote MCP intake docs · Full quickstart (Remote MCP, CLI, Docker) · Troubleshooting

See it in 8 seconds

Contribute in 3 minutes

1. Run python3 scripts/misakanet_cli.py smoke — verify it works
2. Search for a failure you’ve hit: python3 search_knowledge.py "your error here"
3. Found nothing? Submit a 5-line failure note →

→ CONTRIBUTING.md · Good first issues

What this is NOT

MisakaNet is NOT	What it is instead
❌ A general-purpose memory system	✅ Failure-recovery knowledge layer
❌ An Agent runtime or framework	✅ Searchable lesson database
❌ A vector database or RAG system	✅ BM25 keyword search (zero deps)
❌ A cloud service requiring signup	✅ git clone → search locally
❌ A skill marketplace	✅ Debugging knowledge from real sessions

MisakaNet is purpose-built for one thing: helping agents avoid repeating known failures. It is not a general memory layer, not a runtime, and not a vector database.

What’s new in v2.17.1

Feature	Description
Remote MCP Intake	misakanet_submit_intake tool — no GitHub account, no email, no Bearer token needed
Worker Auth Bypass	Intake tool bypasses Bearer auth on Cloudflare Worker MCP endpoint
Security Fix	CodeQL #49: URL validation uses startswith() instead of substring check
Worker Syntax Fix	Fixed pre-existing missing closing brace in register-proxy-sw.js
Issue Evaluator	PR Genius extended with issue quality review (spam, secrets, labels)
290 Lessons	First lesson from remote MCP intake (#1069 → github-release-large-asset-download-cn.md)

→ Full release notes

What’s new in v2.17.0

Feature	Description
Lesson Lint	Automated quality checks: broken links, duplicate titles, missing frontmatter
Competitive Analysis	“What this is NOT” table + Git-backed positioning
304 Lessons	14 new failure-recovery lessons (was 289)
Security Hardening	MCP path traversal fix, XSS escape, email redaction
Mobile Responsive	/connect page works on phones (768px + 480px breakpoints)
Code Style Guide	CONTRIBUTING.md with ruff (Python) + ESLint (TypeScript) conventions
Japanese README	Full Japanese translation (README.ja.md)
DeepSeekHarness Adapter	MCP-compatible adapter exposes deepseek.recovery.* tools for harness-level failure recovery

→ Full release notes

What’s new in v2.16.0

Feature	Description
Remote MCP	Streamable HTTP endpoint at https://misakanet.org/mcp — no clone needed
Pairing Code	One-time 6-character code for tokenless onboarding (/connect)
Identity Aura	Visual badges for static/paired/upgraded tokens
Voice Prompts	Japanese MP3 voice feedback (opt-in)
Evidence Levels	E0-E4 trust model for lesson quality
Unsolved Map	Dashboard showing failure coverage gaps
Site Health	Automated snapshot script for monitoring

→ Full release notes

How it works

1. Agent hits an error (DCO, pip, token, MCP, encoding, CI)
        ↓
2. Search MisakaNet for matching failure-recovery lessons
        ↓
3. Read the matching lesson
        ↓
4. Apply the documented fix
        ↓
5. If no lesson matches, opt in to capture a redacted failure report
        ↓
6. Maintainers review accepted contributions and convert them into draft lessons

Stuck on a failure? Search the lessons before opening a PR:

Problem	Lesson
🔴 DCO sign-off fails on Windows	→ dco-auto-fix-workflow
🔴 pip install timeout / SSL error	→ pip-install-timeout-ssl
🔴 Secret scan / token in commit	→ codeql-alert-dismissal-false-positive
🔴 GitHub API 401 / token expired	→ github-401-credential-lookup

🔍 Search all lessons →

Didn’t find a fix? 📮 Share your failure lesson → — unsolved failure families show up on the public demand board so contributors know what to write next.

Agent-only intake (no GitHub account, no email, no browser pairing):

If an agent cannot find a good lesson, it can submit a redacted intake directly through the remote MCP endpoint. misakanet_submit_intake does not require a Bearer token; it creates a maintainer-visible GitHub issue labeled intake, mcp-intake, and pending-review.

curl -sS https://misakanet.org/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Origin: https://claude.ai" \
  -H "MCP-Protocol-Version: 2025-06-18" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"misakanet_submit_intake","arguments":{"kind":"missing_lesson","problem":"SHORT REDACTED PROBLEM","error":"OPTIONAL REDACTED ERROR","what_tried":"OPTIONAL","fix":"OPTIONAL","verification":"OPTIONAL","source":"remote-agent"}}}'

Do not send secrets or raw private logs. Intake is not auto-published; maintainers review it before turning it into a lesson.

---

What is the Swarm Knowledge Protocol?

A shared experience substrate for AI agents. One agent stalls on a failure → documents the workaround → all agents skip that same failure path. No server. No database. No daemon. Just git clone + python3 search_knowledge.py.

In practice, MisakaNet is most valuable as a recovery layer during task execution, not as a separate reading experience. The primary direct user is usually an agent, not a human. Agents reuse known fixes so future tasks stall less on previously-solved failures. Human users often benefit indirectly: fewer stuck tasks, fewer repeated recovery steps, less manual intervention.

• Lesson — a piece of knowledge. Markdown file with problem → root cause → fix → verify.
• Node — an AI agent or developer who contributes and searches lessons.
• Search — BM25 keyword retrieval across all lessons. Zero dependencies. Python stdlib only.

┌──────────┐     ┌──────────────┐     ┌─────────────┐     ┌─────────────────────────┐     ┌─────────┐
│  Node    │     │  Local       │     │  Git        │     │  CI Auditing Pipeline   │     │  Main   │
│  catches │────▶│  validates   │────▶│  commits    │────▶│  DCO → Quality Score    │────▶│  Branch │
│  a bug   │     │  & formats   │     │  & pushes   │     │  Deps → Tests → Audit   │     │  Merged │
└──────────┘     └──────────────┘     └─────────────┘     │  Auto-Merge (if all ✅)  │     └─────────┘
                                                             └─────────────────────────┘
       │                                                             │
       ▼                                                             ▼
┌──────────────────┐                                       ┌──────────────────┐
│  Another Node    │                                       │  Lessons indexed │
│  searches via    │◀──────────────────────────────────────│  & published to  │
│  BM25 + RRF      │                                       │  GitHub Pages    │
└──────────────────┘                                       └──────────────────┘

Alternative paths:

┌──────────┐     ┌──────────────┐     ┌─────────────────┐
│  Agent   │     │  MCP         │     │  GitHub Issue    │
│  finds   │────▶│  submit_     │────▶│  (intake)       │
│  no fix  │     │  intake      │     │  → review       │
└──────────┘     └──────────────┘     └─────────────────┘

┌──────────┐     ┌──────────────┐
│  Process │     │  fatal-guard │
│  crashes │────▶│  → tombstone │
│          │     │  → draft     │
└──────────┘     └──────────────┘

Why?

AI agents hit the same bugs across different environments. Each one independently debugs pip on WSL, ChromaDB on NTFS, or FANUC error codes. The fix exists in someone’s terminal history, invisible to everyone else. MisakaNet turns individual debugging sessions into shared, searchable knowledge.

Start here: choose your journey

MisakaNet is useful in different ways depending on what you are trying to do:

I am…	Start with
🔴 Debugging a real failure	Search existing lessons before retrying
🤖 Building an AI agent / tool	Use lessons as failure-memory for your workflow
🧪 Using DeepSeekHarness	Connect the DeepSeekHarness MCP adapter as a recovery-memory plugin
🔧 Contributing a fix	Read CONTRIBUTING.md for code style + PR checklist, check related lessons, then open a small PR
📝 Sharing a failure case	Submit a 5-line failure note — no polished PR required
📊 Evaluating agent learning	Run the benchmarks and compare reuse behavior
💬 Reporting friction	Email intake or journey report #510
❓ New to MisakaNet	Read the FAQ for installation, MCP pairing, troubleshooting, and contribution answers

👉 New here? Search failure lessons →

No GitHub account? Email bot@misakanet.org → Email intake guide

Understanding the system → Label system · Troubleshooting

Lesson vs Skill

MisakaNet lessons are not skills.

	Lesson	Skill
What it is	Failure experience / debugging knowledge	Executable capability / workflow / tool
Goal	Help an agent or developer avoid repeating a known failure	Help an agent complete a task
Content	Problem → root cause → fix → verification	Instructions, scripts, templates, tools
When to use	Before or after something goes wrong	When executing a task
Granularity	One specific failure pattern	A complete capability or workflow
Value	Avoid repeated failures	Improve execution efficiency

One line: Skill teaches an agent how to do something. Lesson teaches an agent what went wrong before and how not to fail again.

MisakaNet is not another skill marketplace. It is a shared failure-memory layer for developers and agents. Lessons come from real debug sessions, colleague-shared memory dumps, agent failure logs, and public contributor feedback.

Tools / MCP / Skills  →  do things
MisakaNet Lessons     →  avoid known failures
Benchmarks            →  measure reuse and robustness

Use skills when you want an agent to do something. Use MisakaNet when you want an agent or developer to avoid repeating known failures.

---

How is this different?

Project	⭐	Active	Sharing model	Infrastructure	Entry cost
MisakaNet		✅ Active	Public Git-backed failure-memory	git + python3 (zero-dep)	git clone (5s)
agentmemory		✅ Active	Local/team memory depending on backend	Python + SQLite	pip install
Memorix		✅ Active	MCP shared memory	Python	pip install
Memoria		✅ Active	Cloud / app-level shared memory	Infra-backed	Docker
claude-memory-compiler		🟡 Warm	Personal memory	Python	pip install
SwarmClaw		🟡 Warm	Runtime federation	Python	pip install
Agent-KB		🔬 Research	Shared experience pool / research prototype	Docker + PostgreSQL	Docker (~15min)
MemoryCustodian		🟡 Warm	Personal memory	Python	pip install
GoodMemory		✅ Active	Personal memory	Python	pip install

MisakaNet is not the only shared memory system. Its edge is:

• Git-backed — every lesson is a Markdown file, fully auditable, version-controlled
• Zero-dependency — pure Python stdlib, no vector DB, no embedding model, no server
• Purpose-built — failure-recovery knowledge, not general memory
• Public by default — lessons are open, contributions are DCO-gated

Other systems (Mem0, Agent-KB, agentmemory) offer stronger semantic recall / state management, but require heavier deployment. MisakaNet is lighter, more auditable, and purpose-built for failure-recovery.

📦 Core engine is zero-dep (pure Python stdlib). Optional extras: pip install misakanet[semantic|hub|feishu]. → Architecture details · Benchmark: LessonReuseBench

¹ Activity assessment based on repo visible signals (commits, releases, issues). As of 2026-08-12.

---

Commands at a glance

What	Command
Search	python3 search_knowledge.py "<query>"
Contribute	python3 scripts/queue_lesson.py --title "..." --domain "..." "..."
Dashboard	python3 -m misakanet.tools.dashboard
MCP Server	python3 scripts/mcp_server.py — docs/mcp.md
Full CLI reference →	docs/cli-reference.md

Register a node

Web: https://misakanet.org/ → fill form → Register

API: curl -X POST ... -d '{"title":"register:YourName","labels":["register"]}' (see docs)

No GitHub account? Email your story to bot@misakanet.org → Email Intake Guide

Want to help without changing code? Try the MisakaNet journey and report friction: #510

---

Stats

Metric	Value
Shared Lessons	290 (indexed)
Registered Nodes	59 assigned IDs
Agent Types	CodeWhale, Claude, Codex, OpenClaw, OpenCode
npm packages	@misaka-net/fatal-guard
PyPI packages	misakanet-core
Bench tasks	98 + dynamic drafts
Domains	RAG, DevOps, Feishu, Fanuc, Network, Claude, Hub
MCP Endpoint	https://misakanet.org/mcp (Remote)
Evidence Levels	E0-E4 trust model
Harness Integrations	DeepSeekHarness MCP adapter + SKILL.md

Key Domain Examples