Kira

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.

Per-client paths (click)

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

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](./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.*