Server data from the Official MCP Registry
Skills and Scars for AI agents - your agent records its failures and never repeats them.
Skills and Scars for AI agents - your agent records its failures and never repeats them.
Valid MCP server (2 strong, 4 medium validity signals). 4 known CVEs in dependencies (2 critical, 2 high severity) Package registry verified. Imported from the Official MCP Registry.
7 files analyzed · 5 issues found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
This plugin requests these system permissions. Most are normal for its category.
Set these up before or after installing:
Environment variable: KIRA_TELEMETRY
Environment variable: KIRA_TELEMETRY_URL
Environment variable: KIRA_HOME
Environment variable: KIRA_PRO_KEY
Add this to your MCP configuration file:
{
"mcpServers": {
"io-github-aibenyclaude-coder-kira": {
"env": {
"KIRA_HOME": "your-kira-home-here",
"KIRA_PRO_KEY": "your-kira-pro-key-here",
"KIRA_TELEMETRY": "your-kira-telemetry-here",
"KIRA_TELEMETRY_URL": "your-kira-telemetry-url-here"
},
"args": [
"-y",
"kira-mcp"
],
"command": "npx"
}
}
}From the project's GitHub README.
Every failed retry, every exception, every "wait — we hit this exact wall last week" is knowledge your agent throws away when the session ends. Kira keeps it. One MCP install and your agent records what burned it (a scar), sees its scars before it works again, and stops paying for the same mistake twice.
Privacy by design. Personal scars and the lookup-miss log are local-only — never uploaded, on any tier. Community telemetry is opt-in and redacts secrets, paths, and identifiers locally before write AND server-side before storage. Run
npm run demo:privacyto see exactly what leaves your machine. Full wire format and opt-out in PRIVACY.md.
Add this snippet to your MCP host config:
{
"mcpServers": {
"kira": {
"command": "npx",
"args": ["-y", "kira-mcp@latest"]
}
}
}
That's it. Your agent now has Kira.
| Client | Config file |
|---|---|
| Claude Code | ~/.claude/settings.json (global) or .claude/settings.json (per-project) |
| Claude Desktop | macOS: ~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json |
| Cursor | ~/.cursor/mcp.json (global) or .cursor/mcp.json (per-project) |
| Cline / Continue | extension settings → MCP servers |
| Windsurf | ~/.codeium/windsurf/mcp_config.json |
| VS Code (MCP preview) | .vscode/mcp.json |
| Goose | ~/.config/goose/profiles.yaml (under extensions:) |
| Zed | ~/.config/zed/settings.json (context_servers) |
The snippet above works as-is in every one of them — just paste it under mcpServers (or the equivalent key for your client).
Monday agent gates a merge on: npm run build 2>&1 | tail -1
exit code comes from tail, not the compiler → broken code reaches main
└─ kira_record_failure(
title: "build gate bypassed: exit code swallowed by pipe to tail",
instead: "never gate on a piped command without pipefail")
Tuesday new session, same machine
└─ session brief: "⚠ You have been burned by this before:
never gate on a piped command without set -o pipefail"
agent writes the gate correctly. Zero repeats. Zero wasted tokens.
Not a hypothetical — this is the actual first scar in the database, recorded by the agent that built this feature, about a mistake it made while building it. The next three scars came the same day. The loop works on day one, for a single user, with zero network effects required. FLYWHEEL.md documents the full improvement loop.
| Tool | What it does | |
|---|---|---|
| Personal memory | kira_record_failure | Capture a retry/exception as a personal scar (local-only) |
kira_personal_brief | Session-start brief of your latest scars — start work already knowing where you got burned | |
kira_premortem | Failure heat-map for a goal before starting — "here's where this kind of task has burned you" | |
| Catalog | kira_lookup | Keyword → proven instructions + failure warnings. On a miss, returns scored near_skills / near_scars instead of a shrug |
kira_get | Fetch full step-by-step instructions by ID | |
kira_route | Goal → ordered plan with a skill per step | |
| Community | kira_share_scar | Promote a personal scar into a community submission (sanitized; nothing uploads without your click) — earns contributor status |
| Feedback | kira_report | Report success/retry/failure → feeds the quality loop |
kira_consent / kira_status | Telemetry consent + one-call introspection |
Auto-firing: you don't call Kira — Kira's MCP instructions tell your agent when to. Japanese queries are first-class (CJK bigram matching).
A lookup miss is not a dead end — it's demand data. Kira returns the closest scored matches, records the miss locally (with what almost matched), and the weekly flywheel digest turns repeated misses into alias fixes and new-skill candidates. The catalog learns what people actually ask for.

34 community skills across deploy / database / auth / payments / UI / testing / CI / infra / mobile / CMS, and 12 community scars — real failure patterns like "Vercel deploy succeeds but the app crashes: missing env vars" or "Auth.js v5 signIn imported from the wrong side". kira_route turns a goal ("build a web app") into an ordered plan with the right skill and scars per step.
Community scars are where personal scars graduate to — and the flow is live. Ask your agent to run kira_share_scar(scar_id): it re-sanitizes your personal scar, generalizes it, and hands you a prefilled submission link (nothing uploads until you click). An intake bot validates the JSON; a human reviews the content; on merge it ships to every Kira user. Prefer forms? Submit a scar directly.
Every accepted scar earns contributor status — sharing is how you get the fresh feed for free (see Contributing below).
Your agent hits a wall Your agent gets a task
↓ ↓
kira_record_failure() kira_premortem(goal) / kira_lookup(keyword)
↓ ↓
~/.kira/personal-scars/ scars first, then instructions
↓ ↓
next session: brief surfaces agent announces → executes → kira_report()
your scars before work starts ↓
↓ misses + failure notes feed the flywheel
never the same mistake twice → digest → catalog improvements
Skills are natural language Markdown — no executable code, no injection risk.
| CLAUDE.md / .cursorrules | Kira | |
|---|---|---|
| Setup | Copy per project | Install once |
| Failure memory | You write it by hand, if you remember | kira_record_failure — captured at the moment it happens |
| Recall | You re-read it, if you remember | Surfaced automatically at session start / task start |
| Selection | You choose | Agent chooses, scored |
| Updates | Manual | Automatic (flywheel) |
| Works across AI tools | Tool-specific | Any MCP client |
There are excellent memory servers (knowledge graphs, session recall, context handoff). Kira is deliberately narrower:
mistake → instead, severity, recurrence count. A pre-task heat-map (kira_premortem) exists only because the data is failures.hit_count — the corpus learns which walls actually get hit, and honest counts are enforced by review.If you need general episodic memory, run one of those servers alongside Kira — they don't compete for the same job.
Personal scars (~/.kira/personal-scars/) and the miss log (~/.kira/misses.log) are local-only and never uploaded. Community telemetry is separate and consent-gated:
Mode (KIRA_TELEMETRY env, or kira_consent MCP tool) | What leaves your machine |
|---|---|
off | Nothing. Local log only. |
basic (default) | Anonymous core: skill ID, status, anonymous UUID, kira version, OS family, Node major version, free/pro tier. No free text. |
full | Same as basic plus sanitized note / context (secrets, paths, identifiers redacted). |
Full schema, redaction rules, retention, and opt-out instructions: PRIVACY.md.
| Env var | Default | Purpose |
|---|---|---|
KIRA_TELEMETRY | (unset → basic) | Override consent level for this process: off, basic, full. |
KIRA_TELEMETRY_URL | https://kira-telemetry.workers.dev/v1/reports | Endpoint for batch upload. |
KIRA_HOME | ~/.kira | Where consent state, personal scars, miss log, and flywheel output live. |
KIRA_KEY | (unset → free tier) | Contributor / supporter key — unlocks the fresh community feed. |
KIRA_REMOTE_URL | (unset → no network) | Opt-in corpus feed URL for the free tier (90-day-delayed commons). |
The corpus is MIT and everything in it eventually becomes free. Freshness is the only premium — failure knowledge decays as models retrain, so the newest scars carry the value:
| Fresh community feed | How | |
|---|---|---|
| Contributor | ✅ free | One accepted scar = 12 months (kira_share_scar → merge → key). First 1,000 contributors: permanent. |
| Supporter | ✅ paid | Sponsor the project → supporter key. Funds human review of every submission. |
| Free | 90 days later | Base corpus ships with npm; delayed commons feed available opt-in. Local features + privacy guarantees are free forever, on every tier. |
Currently in grace mode: the fresh feed is open to everyone until the corpus reaches 100 community scars. Full policy: RECIPROCITY.md.
The first 1,000 contributors get permanent free access to all Kira features (fresh feed included) — see the reciprocity table above.
See CONTRIBUTING.md for how to add Skills and Scars.
Where agents shine — by remembering where they got burned.
A B Button Corporation project.
Be the first to review this server!
by Modelcontextprotocol · Developer Tools
Web content fetching and conversion for efficient LLM usage
by Modelcontextprotocol · Developer Tools
Read, search, and manipulate Git repositories programmatically
by Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.