Kira

Your agent stops repeating its own mistakes.

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:privacy to see exactly what leaves your machine. Full wire format and opt-out in PRIVACY.md.

Install (10 seconds)

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.

The snippet above works as-is in every one of them — just paste it under mcpServers (or the equivalent key for your client).

Related MCP server: nautilus-compass

The loop, in 30 seconds

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.

Tools (10)

Auto-firing: you don't call Kira — Kira's MCP instructions tell your agent when to. Japanese queries are first-class (CJK bigram matching).

When nothing matches

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.

The catalog layer (community skills & scars)

38 community skills across deploy / database / auth / payments / UI / testing / CI / infra / mobile / CMS, and 45 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).

How it works

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.

Why not just CLAUDE.md?

Not another "memory MCP"?

There are excellent memory servers (knowledge graphs, session recall, context handoff). Kira is deliberately narrower:

• Failure-first, not everything-first. General memory stores what happened; Kira stores what must never happen again, in a shape built for avoidance: mistake → instead, severity, recurrence count. A pre-task heat-map (kira_premortem) exists only because the data is failures.

• Recurrence is measured, not assumed. Re-recording a similar failure folds into the same scar and bumps hit_count — the corpus learns which walls actually get hit, and honest counts are enforced by review.

• The commons compounds. Your scar, sanitized and human-reviewed, ships to every install — and earns you the fresh feed (RECIPROCITY.md). Memory servers make one agent smarter; a scar corpus makes every agent immune.

• Trust is engineered, not implied. Corpus text is injected into agents' contexts, so every entry passes a sanitizer-stability gate in CI, natural-language-only rules, and human review (SECURITY.md).

If you need general episodic memory, run one of those servers alongside Kira — they don't compete for the same job.

Telemetry

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:

Full schema, redaction rules, retention, and opt-out instructions: PRIVACY.md.

Share a scar, or subscribe, or wait

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:

Currently in grace mode: the fresh feed is open to everyone until the corpus reaches 100 community scars. Full policy: RECIPROCITY.md.

Contributing

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.

Links

• npm

• The Flywheel — how the improvement loop runs

• Design Philosophy

• Business Plan

• Usage Guide

• Troubleshooting

Where agents shine — by remembering where they got burned.

A B Button Corporation project.