# Your agents start from what the team already decided Coding agents forget everything between sessions. Korium gives them the decisions, the reasons and the gotchas, plus a map of the code, so every change starts from what the last one learned. Masthead, our open source plugin, runs this loop on Claude Code. [Start for free](https://app.kyroco.ai/pricing.md) [Get Masthead](https://github.com/kyroco/masthead/blob/main/README.md) We build Korium this way. Every change searches memory before its first edit and saves what it learned before it stops. Nothing merges on a decision someone half remembers. What goes wrong today ### The agent rediscovers the codebase Every session reads file after file to find what the last session already found. ### The decision lived in a chat Why the code works this way was settled in a thread nobody can find, so the next agent undoes it. ### Review checks against a memory The reviewer remembers the decision roughly, and roughly is how it gets enforced. ### The same gotcha bites twice One session lost an hour to it. The next session loses the same hour. Before the change ## The map says where. The memory says why. The first thing Korium asks is what the team already knows about this part of the code. The agent gets one working brief, then reads the code itself before it changes anything. WHAT STARTS IT WHAT COMES OUT An issue is picked up Its scenarios say what done looks like and where each came from. A session starts Masthead searches memory before the first edit. Someone asks where "Where is the invoice export, and what calls it?" asks search asks writes KORIUM Team memory plus the code map The first question it asks: what do we already know about this part of the code? New area Nothing on record yet. The code map still finds the files, tests and callers. Known area Korium already has history here, so it returns: Decisions Gotchas Related code Past changes Also looked up every time · The principles and decision records that bind it · Who decided, and when · What the last session left unfinished asked from Claude Code, Codex or any MCP client Working brief What the agent knows before it touches code WHERE · Files and lines from the code map · The tests that cover them, and the callers WHY · Decisions, each with its reason · Gotchas from past changes DONE · The scenarios the change must pass · What is out of scope corrections during the work are saved as they happen After the change ## The next session starts where this one stopped What was decided, what bit, and what is left go into Korium before the session ends. The code map is refreshed after each commit, so the next agent finds the code as it is now. WHAT GOES IN WHAT COMES OUT The change itself Commits and the files they touched Decisions on the way Each with its reason and who made it Review findings What held, what was fixed, what was left Test results Which scenarios passed, and the proof Gotchas What cost time, so it never costs it twice Incidents Later: what broke in production, and why KORIUM One memory for the team and its agents People and agents read and write the same place. Saved before the session stops Typed, so each can be found again Decisions Gotchas Lessons Handoffs Remembers what changed A reversal replaces the old decision. The old one stays on record, marked replaced. Code map kept current korium-cli can refresh the index after every commit. asked from Claude Code, Codex or any MCP client writes updates warns indexes Handoff note What was done, what is left, in what order, for the next session. Decision record · What was decided · Why, and what was rejected · What it replaces Warnings for next time Gotchas surface the moment another agent works in the same area. A fresh code map The index for this branch, so the next search finds the code as it is now, not as it was. saved back after every change: what was decided, what bit, what is left Ask Korium ## The questions every new session asks | THE QUESTION YOU ASK | WHAT KORIUM ANSWERS FROM | | --- | --- | | "Why does the export skip canceled orders?" | The decision, who made it and when, linked to the test that holds it. | | "Where is this function called, and what tests cover it?" | The code map: file, line span and test names, at the commit it indexed. | | "What did we try last time this broke?" | Lessons and gotchas saved by earlier sessions in the same area. | | "Does this change go against anything we decided?" | The decisions and principles on record for the code it touches. | | "What is left from the last session?" | Its handoff note, in order. | | "Who decided this, and when?" | Every decision carries who made it, the date and what it replaced. | Example ## Where, and why, in one answer The agent gets the exact lines to read and the reason the code works that way. It reads the code itself before it changes anything. Korium:Engineering Example Where is the invoice export code, and why does it skip canceled orders? Invoice export Code map at commit 9f3c2a1, indexed this morning · 1 decision Where lib/billing/invoice\_export.ex 41 to 97 test/billing/invoice\_export\_test.exs 88 Why Finance disputed three canceled invoices in Q1, so canceled orders never reach the export. Lee decided, March 12. Watch out The April 2 change moved the filter from the view into the query. The old note is kept, marked replaced. The map says where. The memory says why. 01 Fewer tokens ### Read the right file first The code map sends the agent to the lines that matter instead of every file that might. 02 Masthead is open source ### The loop, packaged for Claude Code Its hooks make every session search before it edits and save before it stops. 03 Any agent ### Claude Code, Codex, any MCP client One memory, whichever agent your team uses this month. ## Stop explaining the codebase to every new person. [Start for free](https://app.kyroco.ai/pricing.md) [Get Masthead](https://github.com/kyroco/masthead/blob/main/README.md)