What is Naetive? Your project's understanding, native to the code.
9 September 2026
Most tools for AI coding try to give the agent more. More context, more memory, more files stuffed into the prompt. Naetive starts somewhere else. It gives the project an understanding of itself, and lets every agent inherit it.
Here is the distinction that matters.
Code is not understanding
Your repository holds what the project is. Every file, every function, the whole history in git. What it does not hold is what the project means. Why it is built this way, which decisions are load-bearing, what you already tried and rejected, what is still an open question.
That understanding is real, and it is valuable, and right now it lives in the worst possible place. In one chat window. In one tool. In your head. It does not travel to the next agent you open, you cannot check whether it is still true, and it is gone the moment the session ends. That problem is worth its own look: why your project's understanding should not live in one chat.
Git preserves what the project is. Naetive makes sense of what it means.
What Naetive actually does
Naetive captures your project's understanding as you work, grounds it in the real code, and carries it forward to every agent you open next. Three things make that more than a notes file.
It is captured as you work. You do not stop and write documentation. As you and your agents make decisions and hit constraints, the understanding is committed alongside the code, in the moment, while it is still true.
It is grounded, not vibes. Every claim points at real code you can open, down to the file and line. When the code moves underneath a claim, Naetive surfaces the drift for review instead of letting it quietly go stale. You are never trusting a summary you cannot check.
It belongs to the project, not the chat. The understanding is not locked inside the tool that discovered it. Point Claude, Claude Code, ChatGPT or Codex at the project and each one inherits the same picture. That is possible because of the decision to build on MCP.
Clone the code, inherit the understanding
The understanding lives in the repo, in a portable .naetive folder. That is the part that surprises people. Clone the code and you clone its understanding with it. A fresh agent on a clean checkout, with no chat history, can read what the project is for, how it is built, what is contested, and which files matter before touching an area.
That is the whole promise in one line. Clone the code, inherit the understanding. Here is how the portable .naetive folder actually works.
What Naetive is not
It helps to be precise about what this is not. There is a longer piece on exactly what Naetive is and is not, but briefly:
- It is not a memory layer. Memory is a log of what was said. Understanding is a grounded, current model of what is true, kept aligned with the code.
- It is not a workspace or a dashboard. It is not another place to go and manage things.
- It is not an orchestration tool. It does not run your agents. It gives whatever agents you already use one shared understanding to work from.
It also does not replace your CLAUDE.md. That file is good at stable, hand-written rules, and it should stay. Here is how the two divide the work.
Why this sits above the model
The model you use will keep changing. There is a new one every few weeks. But a better model is still an agent opening cold on everything that is not in the repo. It does not know your decisions any more than the last one did.
Understanding sits above the model, which is exactly why no model release solves it. Switch from Claude to ChatGPT mid-project and the understanding comes with you. Nothing starts over.
That is Naetive. Not more context crammed into a prompt. A living understanding that belongs to your project, and every agent inherits.
Have you naetivised your project?