inkentry
git tracks what changed. inkentry remembers why.
inkentry is your project’s memory. It works in the background, keeping the decisions that shape your codebase next to the code they shaped, and hands them back at the moment they matter. Built for people and for the agents working alongside them.
Removing the legacy cost
A project moves by thousands of small decisions. Some get written up in docs, some land in the wiki, some live in tickets, and all of them eventually reach the code, but unevenly. Nobody rewrites the whole project to match the latest decision; its impact stays local, in one corner of the codebase, at one moment in time.
A few years of that is what people call legacy. The fix that went in at four in the morning during an incident. The workaround that outlived the bug it was written for. None of it is anyone’s fault, and all of it slows the next change down.
inkentry keeps those decisions. It answers why the project looks and works the way it does, in context with the code, so you can change things with confidence, including the parts that predate your arrival.
The decision made by someone who left six months ago, still load-bearing, now recorded and in context.
One working day
You do not change how you work. The day below is the one you're already used to. inkentry just means neither you nor your agent walks into it cold.
You start by catching up
First thing, same as every day: what happened since you last looked? What is still open, what got decided? Your agent begins its session the same way, and this is its first command. One brief serves you both: yesterday’s handoff, the open questions, the decisions that still bind. Nobody re-derives Tuesday’s reasoning on Thursday.
inkentry contextyour agent’s first step in a session; works at your terminal too
You hit a number nobody remembers choosing
Mid-morning, the usual wall: a value with no comment, no ticket, no author still on the team. Before, you would ask around and hope. Now one search returns the function and the decision that set it, together. It answers the same way whether it is you asking at the terminal or your agent asking mid-task.
inkentry search "why does retry wait 800ms"
You decide, and it gets recorded
You settle a question in review and move on. That is the moment the why has always been lost: obvious to you, so never written down. Here the agent covers for you: as you decide, it records the decision and the reasoning, because writing it down costs the agent nothing.
inkentry memory addyour agent runs this; you just decide
You commit, and the record keeps up
You commit the way you always commit. A hook re-indexes and captures in the background, never blocking git. And because memory lives in git notes, your teammates inherit the day when they pull. Human and agent alike benefit, and sync converges the decision log across the team.
inkentry hooks installonce
Nothing about the workflow changed. You caught up, searched, decided and committed, the same as yesterday. The day just stopped losing the why.
Three commands
There is more under the hood, but three commands carry most of the work. Learn these and you have the value.
inkentry context
The state of the project before work starts: handoffs, open questions, decisions, conventions. It is not a replacement for your harness rules or your style guide; those are mostly static. This is the dynamic layer, the same job a standup does. Getting everyone on the same page.
inkentry search
grep tells you where something is, and search is not trying to replace it. It answers the two questions grep cannot: how does this work, and why is it the way it is? The why is not a string in your code. It comes from memories attached to code changes, returned beside the code they explain, even when the logic is spread across three modules. Linked projects answer too, clearly attributed. And no model runs at query time, so the answer today matches the answer last week, unless a new decision landed in between.
inkentry memory
Where decisions enter. One deliberate detail: a decision is never deleted, it is superseded. The old line stays, struck through, with the new one beneath it. That is how code nobody has refactored yet keeps its context, and how there is an answer for whatever happened to that decision you remember from a meeting a year ago.
superseded by #41 · 2026-07-12
How we’re different
Deterministic
Ask most AI tools the same question twice and you get two different answers. inkentry returns one: same query, same answer, until a new decision changes it. That is what makes the answer safe to act on. And it needs no key, no account and no network.
Memory in your git history
Entries live in a git notes ref inside your repository, so you can always get to it. The record clones when the repo clones, and it stays yours if you stop using us.
For people and agents both
The same commands serve both. Agents get structured, token-efficient output and a skill that teaches the tool from the first session, and the memory belongs to the repo rather than to any harness. Change agents without amnesia.
Not an agent
inkentry does not review pull requests, does not supervise, and does not reason for you. It retrieves context; you or your agent reason over it. That boundary is the design, not a limitation we are working on.
Pricing
Local
Free
The CLI and the agent skills are open-source, MIT-licensed. Everything described on this page, on your machine, no network required. Memory is stored in SQLite files locally and written through to git notes, so it travels with the repository.
Team server
Free, self-hosted
A team can start from the git notes already travelling with the repo, but a team server is the better answer: it takes over converging memories and decisions across people and machines. The CLI stays local either way, so losing the network never stops the work. The server is MIT-licensed too. Run it behind your firewall.
inkentry cloud
Hosted by us
A hosted team server with finer-grained access control, built for scale, and a web interface for reading the decision log in a browser. For teams who would rather not run the server themselves.
Install
Install, then initialise inside a repository. In minutes the repo is searchable, and pointing harvest at your git history turns years of decisions into a queryable log by lunch. The semantic layer deepens while you work, most important code first. It will keep continuously improving the memory from now on.
curl -fsSL https://get.inkentry.com/install.sh | sh
inkentry init
inkentry harvest