Memory that understands
and stays bound to your code
Most AI memory is a pile of loose notes that never notices when the code moved on. SecondOS binds every note to the exact symbol it's about, so nothing quietly goes out of date, and every tool reads the same live map.
Memory intelligence
The whole category sells the same line: add memory to your agent. The hard part it skips is knowing when that memory is wrong. SecondOS scores it, dates it, catches it contradicting itself, and proposes it for you.
recall("how does auth hash?")
▸ "argon2id, m=64MB" trust 0.92 ✓ anchored, reused 7×
▸ "bcrypt, cost 12" trust 0.18 ⚠ stale · valid ≤ v1.2
≠ conflict: two answers, same scope → reviewConfidence / trust score
Every note gets one 0..1 score, folded from signals we already track: anchored to real code lifts it, going stale or aging sinks it, notes your agents reuse earn it. So a caller knows what to lean on versus verify.
Code-version validity
A memory can be marked no-longer-true as of a version and down-weighted in recall, not deleted. Hard validity windows sit next to soft temporal decay, so “true in v1.2” stays queryable instead of quietly lying.
Conflict detection
Same-subject notes that diverge are flagged for review by embedding distance alone, no model needed. Connect a completer and it upgrades to a real contradiction check that proposes which note supersedes which.
AI distillation
After a sync, SecondOS proposes durable memories from your codebase map. You accept or reject. Assisted, never auto-written, and map-only so it never reads your source. Proposals need a connected model; it degrades quietly without one.
Memory graph
Browse how notes attach to real symbols in a navigable graph, colored by trust so stale and low-confidence memory is visible at a glance. The memory finally has a map of its own.
Org / workspace memory
A workspace-scoped memory that isn't bound to one project: repo-spanning conventions that fold into every project's recall. One home for the rules your whole team keeps re-explaining.
A map of symbols, not a bag of chunks
SecondOS parses your repo with tree-sitter into real symbols, signatures, routes, imports and call-sites, then resolves the calls across modules so who_uses and impact_of answer will-break vs might-break, ranked by confidence. Your tools get structure they can navigate, not a fuzzy pile of text they hope is relevant.
- Exact symbols + signatures, resolved imports and re-exports
- Cross-module call graph for seven languages: TypeScript, JS, Go, Python, Rust, Java, PHP and Ruby
- Kotlin, C/C++, C#, Swift detected + searchable (symbol-level)
- Body-chunk embeddings so search hits logic, not just names
# the map, not the source UserService.authenticate(email, token) ← called by routes/auth.ts:31 (resolved) ← called by worker/session.go:12 (resolved) → reads users, sessions (drizzle) impact_of: 2 will-break · 1 might-break
Memory that knows when it went stale
Every note is anchored to a real symbol at a real sync. When the code it describes changes, the memory is marked stale instead of quietly lying to your next agent. Freshness is a property, not a hope.
- Notes bound to path:symbol, resolved against the latest sync
- Code moves → bound memory flagged stale, ranked down in recall
- Temporal decay: six-month-old advice loses to today's
remember("auth uses argon2id")
scope packages/auth/hash.ts:hashPassword
state verified ✓ (symbol resolved)
… later, hashPassword rewritten …
state stale ⚠ (bound symbol changed)Catch the mismatch before it ships
SecondOS runs three read-only drift checks: your code against the Drizzle schema, the environment variables your code reads against .env.example, and the packages you import against package.json. Each surfaces the undeclared and the likely-unused, with both locations, never a guess, never a silent change.
- Schema: a column you write that pgTable / pgEnum doesn't have
- Env: a process.env your code reads that .env.example never documents
- Deps: an import with no package.json entry, and declared-but-unused packages
drift: 3 checks, read-only
schema users → column "lastSeenAt" not in schema
code routes/ping.ts:44 · db/schema.ts:users
env reads STRIPE_KEY → missing from .env.example
deps imports "zod" → not in package.jsonEvery note is anchored, versioned, revertible
Writes are validated against the graph before they land. Supersede a note and the old one is kept, not deleted. You get a history axis and a one-call restore, so memory accretes instead of drifting.
- Validated writes: unresolved refs saved as unverified, never silently dropped
- History + diff for any note, restore an earlier version without data loss
- Belief-revision pass dedups contradictions instead of poisoning recall
GET /memories/42/history v3 today "retry: 5x, backoff 2s" ← current v2 3 weeks ago "retry: 3x" superseded v1 sync-0f2 "no retry" superseded POST /memories/42/restore → v4 supersedes v3
One sync. Every tool reads the same map
This is the whole point. You index once and Cursor, Claude Code, Copilot, Cline and the rest read the same structure-aware map over MCP: twenty-two tools across codebase, memory and context. No re-scanning per tool, no re-explaining per session.
- Twenty-two MCP tools, including prime, a memory-first orientation call, across codebase, memory and context
- secondos mcp-config prints ready-to-paste setup for Cursor, Claude Code, Claude Desktop, Windsurf, VS Code
- Connect GitHub in one click, every push triggers your own CI to keep the map fresh
- Portable and exportable: the memory is yours, not locked in one IDE
$ bunx @secondos/cli push . ✓ 342 symbols · 51 routes · 13 tables Cursor → reads map over MCP Claude Code → reads map over MCP Copilot → reads map over MCP one index, every tool.
A second brain for your codebase that writes and maintains itself
Bring a project in and SecondOS writes a whole family of readable docs from its structure + your team's memories, never your source (K‑S23). Every push updates them, rewriting only the sections whose map or memory changed. Docs that never rot, that no one maintains, that a new engineer or AI reads to understand the project instantly.
- Eleven docs, auto-written: overview · architecture · modules · dependencies · API · data model · knowledge · learnings · onboarding · changes · glossary
- Auto-created on the first sync, incrementally refreshed on every push, you maintain nothing
- Exploits what only SecondOS has: the call/import graph, routes and DB schema, docs no other tool can auto-write
- Not just a web tab: readable by any AI tool over MCP via read_living_doc (read-only, free)
- Map-only: written from structure, so your source never leaves the machine
$ secondos push . # or connect GitHub
🧠 knowledge base updated
✅ overview · architecture · modules
dependencies · api · datamodel …
→ 11 docs, always currentWe publish the methodology and the real-repo numbers (recall, search and graph resolution), including the ones that look low, because we'd rather say “unknown” than guess. The client that runs on your machine is source-available too, so you can read exactly what leaves it at github.com/Preatan/secondos-client. See the benchmark → · How we measure →
Index once. Let every tool remember.
> daemon: not just the names. I know what calls what.