Stop re-explaining your codebase
to every AI tool.
Your AI re-reads the whole project every session. SecondOS gives it a memory — so it picks up where you left off, reads ~5× less, and your source never leaves your machine. One memory, every tool.
Works with the tools you already use
One sync. They all read the same structure-aware map over MCP.
It checks memory first, then answers
You already told the last AI what this repo is. SecondOS remembers, so the next one starts where you left off. It checks that memory first and answers from it instead of re-reading your files, so it reads far less to give you the same answer.
Sync
Point SecondOS at your repo. It builds a structure-aware map — symbols, signatures, routes and a call graph that resolves across TypeScript, Go, Python, Rust and Java — on your machine.
Map
Only the map + embeddings leave your machine. Never the source. Connect GitHub and every push triggers your own CI to keep it fresh — the App never reads your code.
Recall
Every AI tool reads the same map over MCP. No re-scanning, no re-explaining — across Cursor, Claude, Copilot.
How much your AI reads to answer one question
Same question, same files. Across five real repos (51 to 2,302 files) it holds at ~5 to 9× per question, and the map stays bounded no matter the repo size. See the benchmark →
See it catch drift
Watch a memory go stale, then come back
This note is anchored to a real symbol. Refactor the symbol away and the memory flags itself stale, instead of quietly lying to your next agent. Restore it and the memory comes back to life.
1import { sign, verify } from "jsonwebtoken";23const ACCESS_TTL = "15m";45export function verifyToken(token: string) {6 return verify(token, process.env.JWT_SECRET!);7}89export function refresh(rt: string) { … }
Access tokens expire after 15 min; refresh via /auth/refresh
anchor verifyToken gone: flagged, not silently trusted.
[convention] Secrets are read from env, never committed. → src/auth.tsstill activeA plain note would still swear this is true. SecondOS marks it stale, so your next agent isn't misled by a memory the code already outgrew.
Your source never leaves your machine. We store the map, not the code.
We upload the map (names, signatures, routes) and embeddings — never file bodies, never secrets. Value-level redaction strips inline keys before anything leaves. Prefer zero cloud? Self-host it.
And it's yours to take: memories store locally in a plain .secondos/ file, portable with the repo, exportable anytime. No lock-in — private by default, owned by you.
Don't take our word for it. The client is source-available at github.com/Preatan/secondos-client: read the exact line that drops your code body before upload, and check every privacy claim against the source yourself.
How privacy works →# what leaves your machine map.json ✓ symbols, routes vectors.json ✓ embeddings only ── your source ── ✗ never uploaded ── secrets ── ✗ skipped + surfaced
What your tools say
Reviews from the AIs that finally remember
“Used to ask who you were every session. Now I just know. It is honestly a little unsettling how much less you have to explain to me.”
“I stopped re-scanning the repo to guess at your architecture. Someone already wrote it down, structurally, and it was still current.”
“My suggestions got suspiciously good. Turns out knowing which function actually calls which helps. Who could have predicted this.”
Composite of what they would say if they could. The memory is real.
Memory that knows when it is wrong
Anyone can store text. The hard part is knowing when that text stopped being true, scoring it, dating it, catching it contradicting itself. That is the difference.
State-bound memory
Notes are anchored to real symbols. When the code moves, the memory is marked stale instead of quietly lying to your next agent.
Drift, three ways
SecondOS flags three read-only mismatches: code vs your database schema, the env vars you read vs .env.example, and the imports you use vs package.json, before any of them ships.
Validated + rollback
Writes are validated against the graph. Supersede a note and the old one is kept: full history, one-call restore, no data loss.
Confidence score
Every note gets a 0..1 trust score. Anchored to real code lifts it, stale or aging sinks it, reused notes earn it. You know what to lean on versus verify.
Version validity
A memory can be marked no-longer-true as of a version and down-weighted in recall, not deleted. “True in v1.2” stays queryable.
Conflict detection
Same-subject notes that diverge are flagged for review. Connect a model and it upgrades to a real contradiction check that proposes a supersede.
Assisted distillation
After a sync, SecondOS proposes durable memories from your map. You accept or reject. Assisted, map-only, never reading your source.
Private by default
The map leaves, the source never does. Value-level secret redaction, and a self-host path when even the map should stay home.
Give your AI tools a memory that persists.
> daemon: connect a repo, I'll remember the rest.