NASC · live
Memory that outlives the model
Every AI conversation your team has is work: decisions get made, context builds up, problems get solved. Then the tab closes and the model forgets all of it. The next session starts cold, and somebody pays the bill in re-explaining.
NASC catches those sessions in one workspace no vendor owns, a brain that belongs to your team, and hands every new session what came before. Not a notes app you have to feed. A memory that feeds itself.
How it works
Connect
NASC is an MCP server. MCP is the open protocol AI tools use to reach outside services, and the serious tools already speak it: Claude, ChatGPT, Cursor, and a growing list. You add one connector URL, sign in, and your tool is wired to the team's brain. No workflow change, no agent to babysit.
Work like you already do
Open a session and say "nasc start." That's the whole ritual. The conversation is captured as you work; nothing to log, nothing to remember to save. Close the tab whenever you're done.
The memory writes itself
At session end, the decisions you made, the work you did, and the knowledge worth keeping are synthesized from the conversation automatically and published to the brain. Nobody writes a status update. The status update is a byproduct of working.
The next session starts warm
Tomorrow, on a different machine, in a different AI tool entirely, the session opens with the last handoff, the decisions that stand, who else is working right now, and search over everything your team has done. The AI is replaceable. The memory isn't.
What a session inherits
SESSION OPENED ··· inherited, not cold LAST HANDOFF ····· billing webhook verified on prod DECISIONS ········ deploy from main only LIVE NOW ········· Andrea, editing checkout functions NOTIFICATIONS ···· 2 waiting on you
Shaped like the real thing. This is the first screen of every NASC session: the handoff, the standing decisions, the live board.
The knowledge graph
Ask a team where its knowledge lives and you get a wince: a wiki nobody updates, docs that lag the code, the one person who just knows. In April 2026, Andrej Karpathy sketched the fix he wanted and called it llm-wiki: an interlinked wiki over your raw sources, maintained by the LLM itself, so the curation happens without a curator. The sketch collected thousands of stars as a text file. We think it's the right answer. In NASC it isn't a sketch: every workspace grows a knowledge graph, pages for your systems, decisions, and people, written and cross-linked by the synthesis pass, session by session.
The part an idea file can leave open, a product for teams can't: trust. A wiki the AI edits is a wiki the AI can silently wreck. So under our graph, truth is append-only. Sessions, decisions, and transcripts are never edited in place; the wiki is a derived view over them, with page history, provenance, and role-based access. When a page looks wrong, you can walk it back to the sessions it came from. We shipped the governed version of the pattern while it was still an idea file, and we run our own company on it.
There are good tools now that build a graph like this by indexing your repo. Their graph tells you what the code is. Ours is built from the sessions, so it also holds what never lands in a file: why the decision went that way, what was tried and abandoned, who is mid-flight where. They index the artifacts. We capture the work.
Speaks OKF
In June 2026, Google published the Open Knowledge Format: agent knowledge as plain markdown files, standardized at the file level, with storage, retrieval, freshness, and concurrency deliberately left out of scope. Out of scope is another way of saying "bring a runtime." NASC is that runtime: the live memory layer for the format, with the search, sessions, presence, and provenance the spec doesn't try to cover.
And it cuts both ways, on purpose. Your workspace exports as a conformant OKF bundle and ingests one back; we verified the round trip against Google's own sample bundles, byte for byte. The memory NASC keeps for your team is not locked to NASC: it walks out the door as files any OKF tool can read. We'd rather keep you by being good at this.
It works anywhere MCP works, which is to say: the AI tools your team already argues about. Switch models, switch vendors, switch editors. The brain doesn't care, and nothing is lost in the move.
It also doesn't compete with the memory your tools already ship. Claude keeps its files, ChatGPT its memories, your editor its rules, and NASC sits on top of all of it, capturing the work itself. Each tool's memory makes that one tool sharper. The brain is the copy your team owns, and the one that survives the switch.
We built NASC because we needed it, and we run our own work on it every day. It went live in 2026 and is onboarding its first teams.
Captured automatically
Sessions in these tools land in the brain on their own: nothing to log, nothing to export. This list is served straight from the live registry, not kept by hand, so what you see here is what actually ships.
Command line Aider · Claude Code · Codex CLI + desktop · Continue CLI · Crush · Cursor CLI · Devin CLI · GitHub Copilot CLI · gptme · Grok Build · Hermes Agent · iFlow CLI · Kimi CLI · opencode · OpenHands CLI · Qwen Code
IDE Antigravity · Cursor · VS Code Chat
Desktop Claude Desktop agent mode · Ollama Desktop
Browser ChatGPT · claude.ai · Perplexity coming soon
Using a tool we don't cover yet? Ask us to connect it.