Neuroloom

Your coding agent has opinions.
Now it has receipts.

The lifecycle knowledge engine for coding agents.

Neuroloom observes what your agent does, extracts typed knowledge from its work, and builds a graph that ages, contradicts, and supersedes. Every thread traces back to its origin — the exact tool call, the session it occurred in, the file it touched, and the decisions it relates to.

No credit card required
Built for Claude Code; MCP-compatible with Codex, Cursor, Windsurf & Augment Code

Your instruction file is for facts. Everything else drifts.

Project structure, naming conventions, build commands — those belong in your agent's instruction file. But the moment you start tracking things that change, like architecture, patterns, etc. — it becomes documentation you have to babysit. At some point, it drifts.

The decision existed. The type didn't.

Your agent decided to use JWT in March, yet in May it suggests session cookies — because the March decision was stored as an untyped string that ranked below a newer, unrelated observation. No type. No supersession trail. No receipt.

Your search found the topic. Not the answer.

You searched for authentication architecture. You got 40 results: every thread that mentions auth, sessions, or tokens, ranked by how much the words overlap. The top five were debugging notes. The architecture decision was sixth.

Every tool stores knowledge.
None of them know when it stopped being true.

They store text blobs with no type, no lifecycle, and no lineage. A decision and a debugging note look identical. A superseded pattern sits next to its replacement with equal weight. It's not a knowledge system — it's a pile with a search bar.

Observe. Extract. Weave. Trace.

Observe

Neuroloom hooks into your coding agent at the tool-call and session levels. Every meaningful action becomes a discrete observation with a timestamp, session, and branch. It's not just a transcript summary — it's the actual work.

Extract

Each observation is extracted into typed knowledge: decisions, patterns, conventions, architectural choices, discoveries, and incidents. The type determines how it ages, is retrieved, and what it means contextually.

Weave

References, contradiction, supersession, and more — the graph builds itself through discovery heuristics. Related knowledge connects automatically, surfacing how decisions evolved and where threads diverge.

Trace

When context is needed, the retrieval pipeline finds the right kind of knowledge — weighted by confidence, aged by type, and traceable to the exact tool call that produced it. What's still true, with receipts.

The receipts, typed.

Knowledge with a lifespan

Your instruction file can hold facts. It can't hold architecture decisions that get superseded, or patterns that evolve — because a flat file has no type and no expiry. Type determines lifespan: superseded knowledge drops in rank automatically; contradicted knowledge gets flagged.

Every thread has a receipt

When the agent says "we use JWT for auth tokens," you can trace that to the session, the exact tool call, and the supersession trail — what it replaced and what's contradicted it since. Not "I read this somewhere." Here's where, when, and why.

Nine types. One right answer.

When you ask "how do we handle auth?", you don't get forty threads sorted by proximity. You get one architecture decision, one convention, one incident — each the kind of knowledge that question actually calls for. Neuroloom's types aren't labels. They're operational parameters.

Extracted from the work, not the conversation

Neuroloom hooks at the tool-call level — file reads, edits, searches, and shell commands become discrete observations. What your agent does, not what it narrates. Just the work itself, captured and typed as it happens.

Not what was stored. What's still true.

Start free. Knowledge graph and CodeWeaver included at every tier. No credit card required.