Fix the lost draft
Reading the handoff
Presence reportsReviewing the sync bug
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 memory 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.
See NASC at work
Your people. Your agents.
One shared workspace.
Maya works in Claude Code and Codex at the same time. Jordan prepares the launch. Alex gives direction. A delegated Cursor agent reviews their work with the same relevant context.
ILLUSTRATIVE SIMULATION
Field app launch · shared project access
Field app launch · shared project access
Three people, five sessions. Maya has two running in parallel; Cursor has a delegated review task.
Build the offline screen
Reading the decisions
Presence reportsReviewing the draft screen
Prepare the launch
Reading the launch brief
Presence reportsPlanning the launch copy
Review the pull request
Reading the review brief
Presence reportsReview only · no edits or merge
NASCShared memory
and presence
and presence
PROJECT CONTEXT · FIVE AUTHORIZED SESSIONS
Keep unsent drafts safe. Make offline status clear. Only market what is verified.
People and delegated agents retrieve the context relevant to their work.
Alex · project managerPerson + ChatGPTNo direction requests yet
“Is anyone already working on offline sync?”
The manager can check current activity before assigning duplicate work.
ONE SHARED RELEASE · app-v1Your industry-standard development and deployment tools.
Existing appShared starting point
Keep drafts safeClaude Code · not pushed yet
Offline screenCodex · not pushed yet
What is shared, and what keeps the work safe?
NASC makes authorized project history, decisions, handoffs, and reported activity available across these sessions. They retrieve what they need; it does not mean every transcript is loaded into every AI.
Presence is advisory, not a file lock. Each session works in its own copy, brings in its teammate’s latest changes, tests the combined result, then submits its contribution to the same shared branch. Existing development and deployment tools handle code integration and release safeguards. NASC supplies the history and coordination, not a replacement for those tools or a guarantee against conflicts. This scene stops at release review; it does not depict a deployment.
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 workspace. 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 workspace 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 · Antigravity CLI · Claude Code · Codex legacy aggregate · Continue CLI · Crush · Cursor CLI · Devin CLI · GitHub Copilot CLI · gptme · Grok Build CLI · Hermes Agent · iFlow CLI · Kimi CLI · opencode · OpenHands CLI · Qwen Code
IDE Antigravity · Cursor desktop · VS Code Chat
Desktop Claude Desktop agent mode · Ollama Desktop
Browser ChatGPT web · Claude web · Perplexity Computer coming soon
Using a tool we don't cover yet? Ask us to connect it.
Need this working inside your team now? RJ takes a small number of implementation and architecture engagements: memory and context infrastructure for teams that work AI-assisted. Write to hello@archerionlabs.com and a person answers.