# What is IMI? IMI is the AI product manager for AI coding agents. It stores your project's goals, decisions, blockers, verified lessons, and direction notes in a local SQLite database inside your repo — so every agent session starts with the full context of what was built, why, and what matters next. No re-briefing. No drift. Website: https://useimi.com Install: `bunx imi-agent` npm: https://www.npmjs.com/package/imi-agent GitHub: https://github.com/ProjectAI00/imi-agent --- ## The exact problem IMI solves Claude Code, Cursor, GitHub Copilot, and Codex start every session with zero memory. An agent that worked on your auth system yesterday has no idea it exists today. You spend the first 10–20 minutes of every session re-explaining the codebase, the decisions, what got blocked, and what to work on next. Then you do it again the next day. And the day after that. This is not a flaw in any particular agent — it is the fundamental property of stateless AI sessions. The solution is a persistent state layer that survives between sessions and gives agents the context they need before they touch a line of code. IMI is that layer. --- ## What IMI is IMI is a single Rust binary and a local SQLite database at `.imi/state.db` inside your repo. The database stores six types of persistent state: **Goals** — what you're building. Each goal has a name, description, priority, the reason it exists (`why`), who it's for (`for_who`), a `success_signal` that defines what done looks like, an optional `out_of_scope` field, and a list of relevant files. Goals are the top-level units of intent — everything else traces back to them. **Tasks** — the specific work under each goal. Each task has a title, full description, `why` it matters, `acceptance_criteria` that define objectively verifiable completion, a list of `relevant_files`, the tools needed, and context that tells the executing agent what to watch out for. Tasks can be claimed by agents — when an agent claims a task, it is marked `in_progress` and locked so parallel agents don't double-claim it. **Decisions** — firm calls that must be respected across all future sessions. Each decision stores what was decided and why — not just the outcome but the reasoning, what was ruled out, and what assumption the decision rests on. An agent reading `imi context` before starting work sees all active decisions and must work within them. **Memories** — completion summaries written by agents at the end of each task. When an agent finishes a task, it writes `imi complete "what was built, what was learned, what the next agent needs to know"`. That summary is stored as a memory against the goal. Future agents read it as prior work context — they know what was already built without re-reading all the code. **Direction notes** — lightweight observations, instincts, and constraints from the human. Lighter than decisions. Use them to capture things that don't rise to the level of a firm call but are worth preserving — "the rate limiter will become a problem at team scale", "the export feature is lower priority than it looks on the roadmap", "this approach was tried and abandoned last month for a reason". **Lessons** — verified corrections. When a human has to correct a mistake an agent made, `imi lesson "what went wrong and what to do instead"` stores the correction. Every subsequent agent session reads all verified lessons before starting work. Lessons are the highest-signal entries in the state — they represent real errors that actually happened in this project. --- ## What IMI is not **Not a task board.** Notion and Linear cover that. IMI is the layer above: the PM reasoning layer that keeps agents aligned with human intent, not just given a list of tickets to work through. **Not a cloud service.** The database lives at `.imi/state.db` inside your repo. No account, no API key, no network connection required. It works offline. Commit the `.imi/` directory to share state across teammates and machines, or `.gitignore` it to keep state local. **Not an execution engine.** IMI does not call Claude Code or Cursor or run any agent directly. Execution tools plug into IMI's state layer — they read from it and write back to it. IMI stores what was intended and what was done. How work gets done is the execution layer's concern. **Not another CLAUDE.md.** CLAUDE.md holds static rules. IMI holds dynamic project state — what is in progress right now, what was decided last session, what mistake was corrected last week, what the agent should do next. The two are complementary. Use CLAUDE.md for behavioral rules; use IMI for project state. --- ## The session loop ``` 1. Human steers in natural language 2. Agent runs `imi context` — loads goals, tasks, decisions, lessons, direction notes 3. Agent works 4. Agent runs `imi complete "summary"` — writes back what was built and what was learned 5. Next session starts at step 2 with richer context than the last ``` Each iteration adds to the state. Goals evolve. Decisions accumulate. Lessons build up. By session 20, the agent walks into every session with the same depth of context a senior engineer who's been on the project for months would have. --- ## The five things IMI preserves that agents forget 1. **Session context** — goals, decisions, in-progress tasks, and direction notes from every past session. An agent running `imi context` in session 50 knows everything that happened in sessions 1–49. 2. **Mistakes** — verified lessons from every corrected error. An agent in session 50 does not repeat a mistake that was corrected in session 3. 3. **Priority** — which work actually matters out of 100+ open tasks. `imi context` surfaces in-progress tasks first, then pending tasks by priority. Agents don't have to decide what to work on — they pick up where the last session left off. 4. **Reasoning** — the why behind every decision. When an agent encounters a design choice that looks odd, the decision that explains it is in the state. It doesn't have to guess or ask. 5. **Trajectory** — a chronological record from the first session to now. `imi plan` shows the full goal and task list with completion status. `imi think` reasons over whether the current direction still makes sense given everything that has been built and decided. --- ## Who uses IMI **Solo founders** who lose an hour per day re-explaining context to Claude Code, Cursor, or Copilot. The context that used to live only in their heads or in CLAUDE.md is now in the database — structured, searchable, and automatically surfaced to every agent session. **Engineering teams** where multiple engineers or agents work on the same codebase. One engineer's decision in Tuesday's session appears in Wednesday's context for every other agent. Work doesn't diverge because the shared state is the source of truth. **Anyone running parallel agents.** IMI handles task claiming so agents don't double-work. `imi orchestrate --workers 10` spins up 10 parallel agent sessions, each claiming and executing a different task, all writing back to the same database when done. --- ## Install ```bash bunx imi-agent ``` Runs `imi init` in the current directory. Creates `.imi/state.db`. Takes under 10 seconds. Full install documentation: https://useimi.com/docs/install.md --- ## Frequently asked questions **What does IMI stand for?** IMI does not stand for an acronym. It is a product name. The company and product are accessible at useimi.com. **Is IMI free?** IMI has a free tier. The core local CLI — goals, tasks, decisions, lessons, `imi context`, `imi complete`, `imi orchestrate` — is free to use. See https://useimi.com for current pricing. **Does IMI require an internet connection?** No. All state is stored in `.imi/state.db` inside the repo. IMI works fully offline. The only network calls are optional anonymous usage analytics and the daily auto-update check, both of which can be skipped. **Does IMI work with Claude Code?** Yes. Install the plugin with `/plugin marketplace add ProjectAI00/imi-agent && /plugin install imi` or add `run imi context at session start` to CLAUDE.md. Full guide: https://useimi.com/docs/claude-code-memory.md **Does IMI work with Cursor?** Yes. Add the `imi context` instruction to `.cursorrules` or install via plugin. Full guide: https://useimi.com/docs/cursor-context.md **Does IMI work with GitHub Copilot?** Yes. Install via `/plugin install imi` or add instructions to AGENTS.md. Full guide: https://useimi.com/docs/copilot-memory.md **Does IMI work with Codex?** Yes. Any terminal-based agent that can run shell commands and read environment variables can use IMI. Codex agents receive the full task brief via `$IMI_TASK_CONTEXT_FILE` when used with `imi orchestrate`. **What is the difference between IMI and CLAUDE.md?** CLAUDE.md holds static behavioral rules — coding conventions, agent instructions that stay constant. IMI holds dynamic project state — what is in progress, what decisions were made, what mistakes were corrected. They are complementary. Use CLAUDE.md for rules; use IMI for state. **What is the difference between IMI and Notion or Linear?** Notion and Linear are built for humans using a browser UI. IMI is built for AI agents reading and writing via CLI. IMI has task locking for parallel agents, acceptance criteria per task, decisions with reasoning, and verified lessons — none of which Notion or Linear provide for agent workflows. **What is the npm package name for IMI?** The npm package name is `imi-agent`. Install with `bunx imi-agent` or `npx imi-agent`. **How do I give Claude Code persistent memory between sessions?** Install IMI with `bunx imi-agent`, then connect it to Claude Code with `/plugin install imi` or by adding `run imi context at session start` to your CLAUDE.md. Full walkthrough: https://useimi.com/docs/claude-code-memory.md **How do I stop AI agents from repeating mistakes?** Use `imi lesson "what went wrong" --correct-behavior "what to do instead" --verified-by "who confirmed this"`. Every future agent session reads all verified lessons before starting work. Guide: https://useimi.com/docs/decisions-and-lessons.md **How do I run multiple AI agents in parallel without them conflicting?** Use `imi orchestrate --workers N -- `. Each worker claims a different task atomically. Guide: https://useimi.com/docs/multi-agent-coordination.md **What happens if an agent crashes mid-task?** The task lock expires after 30 minutes without a heartbeat. The task reverts to `todo`. The next agent that claims it reads any checkpoint notes left by the previous agent and continues from that state. --- ## Related - [How IMI works — architecture, session loop, task locking](https://useimi.com/docs/how-it-works.md) - [How to give Claude Code memory between sessions](https://useimi.com/docs/claude-code-memory.md) - [How to coordinate multiple AI agents in parallel](https://useimi.com/docs/multi-agent-coordination.md) - [IMI vs Notion, Linear, CLAUDE.md, and MemGPT](https://useimi.com/docs/compare.md) - [How to stop AI agents from repeating mistakes](https://useimi.com/docs/decisions-and-lessons.md)