Right now it’s scattered across chats, tools and your own head. Naetive captures it as you work, grounds it in the real code, and carries it forward to every agent you open next.
Any agentEvery agent you connect arrives already knowing your project.
A new database is built from a snapshot of production, not by replaying the migration files.
Inside a database transaction, a step that may fail is wrapped in a savepoint, never a bare try/catch.
Only the socket a tunnel session still holds may tear the session down; a superseded one must not.
Every agent starts from the same understanding, and leaves it richer.
Not a transcript or a memory dump. A structured picture of the project that agents can inherit, verify and strengthen.
Open Claude, Claude Code, ChatGPT or Codex and it begins with the decisions, architecture, constraints and current direction already available. No context paste, no repeated briefing.
Claims are backed by evidence from the code, decisions and project history. Open any one to see what supports it and how strong the evidence is.
Understanding changes when the project’s meaning changes, not whenever a file does. When the code moves past a claim, Naetive surfaces it for review instead of letting it drift silently.
What one agent establishes, the next inherits, even on another model or tool. They all work from the same picture and strengthen it as the project evolves.
Your committed understanding travels with the repository in a plain, portable .naetive folder. Clone the project and a fresh agent grounds itself before it begins work.
Not a record of every prompt or keystroke. A meaningful history of what the project established, corrected, contested and resolved.
No separate documentation step. Three moves take a working session to a folder every fresh agent can read.
As you and your agents work, Naetive captures the decisions, constraints and architecture as grounded claims. You do not stop to document anything separately; the understanding accrues from the work itself.
Run one command, or download the folder from the Understanding page, and the understanding lands in a .naetive folder with a pointer in AGENTS.md. From then on it stays current as the understanding changes. Git stays yours: you commit it like any other file.
naetive export
git add .naetive AGENTS.md && git commit -m "Commit understanding"A new clone carries the folder. The next agent, on any machine, reads .naetive/project.md first and starts already understanding the project.
# on another machine, tomorrow
$ git clone git@github.com:you/project.git
$ claude # reads .naetive/ first, already knows the workWe gave three fresh AI agents the same repository and the same ten questions about why things were decided, scored out of twenty. One could read only the code. One also had a handover note from the departing engineer. One read the project’s committed understanding first.
On the code itself, all three did fine. Good code and a good README go a long way.
The difference was the reasons. The agent with the understanding scored full marks on the whys, twenty of twenty, and invented nothing. The agent with only the code scored eleven, said “unknown” to most of the whys, and once turned a silence in the repository into a confident false fact. The handover note helped a little, at more than twice the effort.
Then we did it again on an open-source project none of us had opened, one day after a careful engineer had recorded their reasons. There, a good handover note did as well as the understanding, for that one session. Which is the point. A note covers a session. The understanding covers the project, every session, and never forgets one.
Eleven of twenty. “Unknown” on most of the whys. One confident guess that was wrong.
Twenty of twenty. Every why, nothing invented, in half the time.
One run per arm, scored by us against an answer key written before the run.
It’s structured, evidence-backed, shared across every agent, and kept aligned as the code changes. And it belongs to the project, not to the chat that happened to discover it.
Understanding is why Naetive exists. It also comes with the things that make it usable every day.
Claude, Claude Code, ChatGPT and Codex work from the same understanding of the project. Switch tool or model and the picture carries over, nobody re-briefs.
Open a terminal and run Claude Code or your own setup right beside the project, or keep working in the tools you already use. Your call.
A Now, Next and Later roadmap, with streams and jobs beneath it, keeps the work organised and current as things land.
Watch progress as your agents work and redirect it in the moment, instead of scrolling a chat log to find out what happened.
Foundations holds the maps and docs your project rests on, organised by area, the deeper narrative beneath the living understanding.
Point an agent at your project and it is in, with almost nothing to set up.
A README is written once and drifts. Committed understanding is grounded in the actual code, every claim cites its source, and it stays aligned as the code changes, so it does not go stale the way a doc page does.
No. Every claim points at the code that backs it. If the code moves in a way that could affect a claim, Naetive flags it for you to confirm, change or contest, rather than trusting it silently.
More than a static file. From a plain clone, an agent starts with project.md: a compact map of the architecture and the load-bearing decisions and constraints, linking out to each area and the detail beneath it, so it orients before touching code. Connected to Naetive, it gets the living version: the current understanding as it stands today, the ability to recall anything the project knows, and the work in flight, and it keeps inheriting as the picture changes instead of reading a snapshot once.
No. Naetive makes no per-action model calls to assemble committed understanding, it reconciles what your agents already established. The connected agents bring the intelligence; the assembly itself is deterministic.
Early access is opening for developers building with AI agents.