Your AI Forgets Everything. Here's How to Fix That in Kiro.

Every Kiro session starts from zero. You've spent three weeks refactoring an auth module. Kiro doesn't know. You've decided to use repository pattern over active record. Kiro doesn't know. Here's how to give it a memory.

You know. Your team knows. Your AI doesn't.

I've been building a health-tech iOS app with AI agents for the past 6 months — 200K+ lines of Swift, 170+ batches, 3 agents running in parallel. The single biggest productivity drain wasn't model quality or token limits. It was repeating context that should have been learned weeks ago.

That's why I built Nora.

What Nora Actually Does

Nora is a local daemon that sits behind your AI coding agent. When a Kiro session ends, Nora captures the full transcript, runs it through an LLM (using your own API key), and extracts three things:

Patterns — reusable approaches that worked. "When touching CoreData entities, always check the managed object model first." "Use @MainActor final class instead of actor for UI-layer services." These aren't generic best practices. They're your patterns, from your codebase.

Decisions — architectural choices with rationale. "Chose local-first storage over Firestore because health data must stay on-device." "Using four-layer AI cascade: Vertex → Anthropic → Gemini Pro → Gemini Flash." The next session gets this context without you typing it again.

Anti-patterns — mistakes to avoid, with the fix. "Never use if let on non-optional CoreData @NSManaged properties — causes compile error." "Never name two Swift files the same across directories — causes duplicate .stringsdata output." These are bugs you hit once. Nora makes sure you never hit them twice.

Here's the key: Nora writes these to steering files — markdown files that Kiro reads automatically on every prompt. No manual loading, no copy-paste, no "hey remember that thing from last week." The context is just there.

Install in 30 Seconds (The Power Way)

This is the part that matters for anyone who just wants it working.

Open Kiro. Click the Powers panel (the ↺ icon). Click Add power from GitHub. Paste this:

https://github.com/kernora-ai/nora

Click Install.

That's it. The Power registers Nora's MCP server, creates three hooks (session capture, tool validation, post-tool checks), copies steering file templates, and installs the engine to ~/.nora/. No terminal. No config files. No dependency debugging.

The one thing you'll need: an LLM API key. Nora supports Anthropic (recommended), Google Gemini, AWS Bedrock, or local Ollama. Set it as an environment variable (ANTHROPIC_API_KEY, GEMINI_API_KEY, or AWS_PROFILE) or edit ~/.nora/config.toml.

After install, just code normally. When your Kiro session ends, the agentStop hook fires, Nora captures the transcript, and analysis runs in the background. Within 60 seconds, the steering files update. Your next session is smarter.

The 8 MCP Tools

Once installed, Kiro gets 8 new tools it can call mid-conversation:

These aren't decorative. When Kiro is about to refactor a service layer and calls nora_patterns, it gets back the specific patterns that worked in your project — not generic StackOverflow advice. When it's about to run a batch delete and calls nora_scope_validation, it checks against your project's known danger zones.

The practical effect: fewer "I didn't know about that constraint" moments. Fewer regressions. Fewer sessions where you spend the first 15 minutes re-explaining your project to the AI.

Steering Files: The Quiet Superpower

Kiro automatically reads all markdown files in ~/.kiro/steering/ on every prompt. Nora generates three:

• nora-patterns.md — Playbooks and effective approaches. Updated every time Nora finds a new pattern in a session.
• nora-decisions.md — Project rules and architectural constraints. Grows over time into a living architecture document.
• nora-antipatterns.md — Warnings about known traps. Every bug you've fixed becomes a guardrail.

These files have a YAML frontmatter that tells Kiro when to apply them (globs: "**/*" means always). They start empty and fill up after your first few sessions.

Here's what's powerful about this: you don't manage these files. You don't write them. You don't update them. You code. Nora watches. The files evolve. Every session deposits new intelligence. After a week, Kiro knows your project's quirks without being told.

I've seen my own steering files grow to capture 50+ patterns, 30+ decisions, and 20+ anti-patterns across 6 months of building. That's 6 months of accumulated intelligence that every new session inherits for free.

The Three Hooks

The Kiro Power installs three hooks in your workspace:

1. Session Capture (agentStop) — When Kiro's agent completes a task, this hook captures the full transcript and sends it to Nora's daemon via Unix socket. Analysis runs in the background. You don't wait.

2. Tool Shield (preToolUse) — Before Kiro executes a tool (file write, terminal command, etc.), this hook checks the invocation against known danger patterns and anti-patterns from past sessions. Think of it as a learned guardrail.

3. Post-Tool Check (postToolUse) — After a tool runs, this hook checks the output against known error signatures. If Nora has seen this error before, it injects the fix immediately.

These hooks run in milliseconds. You won't notice them. But over time, they prevent the kind of mistakes that cost 30-minute debugging sessions.

Privacy: Zero Bytes Leave Your Machine

This was non-negotiable when I built Nora. Session transcripts contain your code, your architecture, your business logic. None of that should touch someone else's server.

Nora runs 100% locally. The daemon is a Python process on your machine. The database is SQLite at ~/.nora/echo.db. Steering files are local markdown. The only network call is to your own LLM provider (Anthropic, Google, AWS, or local Ollama) for session analysis. Zero telemetry. Zero tracking. Zero cloud storage.

BYOK — Bring Your Own Key. Your key, your machine, your data.

The Part Nobody Talks About

The real value isn't the tools or the steering files. It's what happens after week 3.

In the first few sessions, Nora is learning. The steering files are thin. The pattern library is small. It feels like a nice-to-have.

By week 3, something shifts. You start a session and Kiro already knows the tricky parts of your codebase. It avoids the pitfall you hit two weeks ago. It follows the architectural decision you made last month without being reminded. It uses the pattern you discovered works best for your specific stack.

Your AI becomes a colleague who was there for every previous session. Not a fresh intern who needs onboarding every morning.

I've been tracking this in my own build. Sessions where Nora has 50+ patterns to draw from produce measurably fewer regressions. The AI makes fewer "obvious" mistakes — the kind that come from not knowing project history. The quality delta compounds. Every session makes the next one better.

That's the loop: code → capture → analyze → steer → code. It runs silently. You just code normally and get better results over time.

Getting Started

1. Install — Kiro Powers panel → paste https://github.com/kernora-ai/nora → Install
2. Set your API key — export ANTHROPIC_API_KEY=sk-... (or Gemini, Bedrock, Ollama)
3. Code normally — Complete 2–3 Kiro sessions
4. Check steering — Open ~/.kiro/steering/nora-patterns.md and see what Nora learned
5. Watch Kiro get smarter — By session 5, you'll notice the difference

The dashboard at localhost:2742 shows sessions analyzed, patterns extracted, and knowledge growth over time. It's satisfying to watch.

Why This Architecture

If you're evaluating the design, here's the rationale:

Local-first, not cloud-first. Health-tech taught me that user data on someone else's server is a liability, not a feature. The same applies to your codebase. SQLite + local filesystem is the simplest architecture that could work, and it's the most private.

BYOK, not vendor-locked. Nora uses LiteLLM under the hood. Anthropic, Google, AWS Bedrock, Ollama — your choice, your key. If you switch providers tomorrow, Nora still works.

Hooks, not polling. The capture happens on session events (agentStop, preToolUse, postToolUse), not on a timer. This means zero overhead during coding and instant capture when it matters.

Steering over RAG. Instead of building a retrieval pipeline that queries a vector DB on every prompt, Nora writes flat markdown that Kiro reads natively. Simpler. Faster. No embedding model dependency. No relevance-ranking tuning. The steering approach uses what Kiro already does well — reading context files.

Elastic License 2.0. Free for personal and team self-hosted use. No legal review needed for internal use. The license only restricts commercial redistribution (offering Nora as a managed service).

What's Next

Nora currently supports Kiro (via Power), Claude Code (via the Claude Code adapter shipped in the main repo), VS Code, and Cursor. Windsurf and Cline adapters are coming. The Claw Protocol is an open spec — if your agent can write to a Unix socket, it can talk to Nora.

We also submitted Nora to the Kiro Powers marketplace. If it lands, you'll be able to find it directly in the Powers panel without pasting a URL.

The repo is at github.com/kernora-ai/nora. Star it if the idea resonates. Open an issue if something breaks. And if you build a claw for an agent we don't support yet — PR welcome.

Mihir Choudhary — serial entrepreneur, founder at Kernora. Previously SVP leading engineering teams at scale. Now building tools that make AI agents smarter over time. If your AI starts every session from zero, it doesn't have to.