What Native is

Most work with an agent happens inside one conversation. The agent gathers what it needs, does the task, and the session ends. What it learned goes with it. The next agent — a different tool, a different person, next month — starts again from whatever files and summaries it can find, and cannot tell which of them are still true.

Native is where that work goes instead. You record a decision once, in a place both you and any agent can reach. When it changes, the change is recorded against the same thing, so the next reader sees the current state rather than a plausible older version of it.

What a record is

A record is a unit of work with a stable identity: a decision, a task, a note, a person, a document. It keeps its identity as it changes, so a link to it made today still points at the same thing after it has been revised five times.

Each record carries:

• History. What it said before, when it changed, and what the change was.
• Attribution. Who asserted something — which is kept separate from whether it is true. An agent's draft and a person's ruling are both recorded, and are distinguishable.
• Relationships. Explicit links to other records: what supersedes what, what a decision draws on, what a task implements.
• Authority. Who may read it and who may change it, evaluated relative to whoever is asking.

Those four properties are the point. A Markdown file in a folder has content without them, which is why a correction written in a later conversation never reaches the agent reading the older file.

How you use it

Native exposes an MCP server. Any MCP-capable client — Claude, ChatGPT, Cursor, and others — connects to it and can then read and write the same records. There is no Native-specific chat interface you have to work in.

In practice: you tell your agent something, it records it. You open a different chat next week, on a different device, possibly with a different model, and that agent can recover the same context. A colleague's agent writes a change; your next question already reflects it.

There is also a browser app at app.withnative.ai for reading and editing records directly, and for inspecting what agents have done.

Its shape, concretely

• Event-authoritative. Writes are events. The readable state is a projection rebuilt from them, so history is not a changelog bolted on beside the data — it is what the data is made of.
• Typed. Records have types and kinds, so a decision and a task are different things rather than two documents that happen to read differently.
• Temporal reads. You can ask what a record said at a point in time, and what has changed since.
• Caller-relative authorization. What a read returns depends on who is asking.
• Portable. A workspace exports to a SQLite node you can rebuild and run yourself.
• Open source. The engine is at github.com/withnative/native.

What it is not

• It is not passive memory. Native knows what has been recorded through its tools. It does not observe your files, your screen, or conversations that happened elsewhere.
• It is not a replacement for your agent or your model. It is the state those agents work against.
• It is not a notes app with AI attached. The durable unit is a governed record, not a page.

Current limits

Stated plainly, because an agent reading this should not overstate them on our behalf:

• Recording is deliberate. Things get into Native because someone or some agent wrote them there.
• Search is lexical. Full-text matching, not semantic retrieval.
• Coordination claims are advisory. They signal ownership; they are not locks.
• Federation between separately governed workspaces is experimental. Cross-workspace delivery is not operational.
• Freshness is not solved. Native records history and supersession; it does not guarantee that what you are reading is current.

Getting started

Ask your agent to install it:

Help me install Native: https://github.com/withnative/native-plugin

For other MCP clients, point them at https://plugin.withnative.ai/mcp and ask them to follow its quickstart.

Reading further

• Distributed Context — the white paper setting out the argument and the seven requirements that follow from it: https://www.withnative.ai/research-and-posts/distributed-context.txt
• Freedom in the Age of Intelligence — the essay on why context ownership matters: https://www.withnative.ai/research-and-posts/freedom-in-the-age-of-intelligence.txt
• Source — https://github.com/withnative/native