ARC Open GovernanceRun it yourself
The ΛRC field database
Every database in ordinary use stores rows in tables and reconstructs relationships afterwards, by joining tables, by maintaining indexes, or by bolting a graph layer on top of a store that was never built for relations. The ΛRC field database starts from the other end. Relation is the primitive. A field is a living web of entities and the typed relations between them, and the database computes natively over that web, so questions about what reaches what, what depends on what, and what a change would touch are answered by the store itself rather than rebuilt by the application above it. That inversion is what makes it a next-generation database rather than a faster version of the last one, and the workstation below is its interface, exactly as it opens in the current preview.
Relation is the primitive
Entities and typed relations are the storage itself. Nothing is a row with pointers at other rows, and no join is needed to recover the shape of the system.
Reachability is native
The store computes what is reachable from any entity, with depth and degree, as a first-class answer rather than a query plan assembled at runtime.
Evidence is built into the record
Every answer carries the digest of the field it was computed from and the contributions it stands on, so the result can be rechecked rather than believed.
Governance operates on the field
Authority, exposure, and settlement are relations in the same field, examined by the same engine that answers every other question about it.
State persists as a digest chain
The field survives between sessions and refuses tampering, because each state is chained by digest to the state before it.
You meet it in your own words
A relational intelligence layer sits beside you in the workstation, translates your words into the formal language, and shows you the exact question before it runs.
Download it and open it
The CLI travels as one package with installers for Mac and Windows inside it. There is no repository to clone and nothing to compile, and double-clicking the launcher opens the workstation above. It asks for Python 3.10 or later and Node, carries a single dependency, and runs entirely on your own machine.
Preview package, 39 files, SHA-256 c294f8392db4d593aee206a7d121a64f7ca684981d15e557c60c19da48c840bf. This build carries the relational field view and the native intelligence binding described below, and the frame above is its own render.
Start a field of your own
One command creates a project, and a project is a field. The field is a digest-chained record of your entities and their relations that persists between sessions and refuses tampering, and the database view shows it to you directly, in color, with the digest it stands on.
arc init my-project arc db arc field
Ask it real questions
The ARC Language is a formal grammar shaped like plain statements about relations, because an answer that carries consequence has to be provable rather than plausible. This is the first query the workstation itself suggests.
from agent where role == 'operator' select id, authority, constraints
Every answer arrives with the evidence it stands on.
See the field itself
A database of relations should let you look at the relations. The field view draws your field as the web it is, with the most connected entity at the center and every other entity placed on a ring by its reachability depth from that hub. Each node is labeled with its depth and its degree, each line is colored by the class of the relation it draws, and the metrics beneath the picture count the whole field, its entities, its relations, its relation classes, and the depth the web reaches. What you are looking at is computed from the same field the database answers from, and the render below is the current build drawing its demonstration field.
Talk to it in your own words
ARC is met in natural language from the first install. Open a project and the workstation greets you with the offer to connect the intelligence you already use. One command, arc connect, plugs it in, and the binding is platform agnostic. A provider model reached through its ordinary endpoint, an agent CLI such as Claude Code or Codex already signed in on your machine, or a model running locally on your own hardware all bind the same way, and signing in stays each provider's own ordinary flow. From there the intelligence sits beside you as your guide to the database. Ask in your own words and it translates your question into the ARC Language, shows you the exact query it is about to run, executes it through the read-only query path, and answers in plain language with the evidence standing verbatim beneath the answer. When a question is too loose to translate exactly, it asks you to sharpen it rather than guessing. The formal language remains there directly for technical work, and the natural-language door is the default human experience. The frame below is a fresh project at first open, with the invitation in place.
Data sovereignty
Your intelligence. Your data. Your authority.
The person downloading ARC is not just getting a database. They are getting a locally controlled computational environment where their information, the intelligence that accesses it, and the actions taken with it are governed through explicit relationships and authority.
Consider what an intelligence provider holds when a person works without such an environment. Everything the person pastes, uploads, and connects is processed on the provider’s machines, under the provider’s rules, alongside everything else the person has ever disclosed there. The provider can draw inferences across the whole of it, and the person keeps no record of their own showing what was used, what was inferred, and what was done with either. The risk is not any single disclosure. The risk is the accumulation, held by someone else, with no boundary of the person’s own anywhere in the arrangement.
Gate what the model may access
Your field lives on your own machine, as a file you hold, and a connected intelligence never browses it. The intelligence hears your question, proposes one exact query in the ARC Language, and shows you that query before anything runs. It then sees the answer to that query, with the evidence standing beneath the answer, and the field states its digest with every answer so a result can be rechecked rather than believed.
Gate what may be inferred
What the system derives stays labeled as derived forever. A derivation can never quietly become a recorded fact, and removing a premise marks everything built on it as invalidated, with the chain of reasoning kept. A query result grants no authority and says so in its own envelope, so an inference has no path from being noticed to being acted on as if it were knowledge with standing.
Gate what needs permission
Reading is not acting. A consequence is a separate governed step that passes through GMAP settlement, where authority is weighed against evidence before anything executes. What survives the weighing leaves a Statement that anyone can verify afterwards, and an answer, however confident, is never itself a permission.
Demonstrated on an ordinary phone
On October 16, 2026, the foundation ran this arrangement end to end with a field database on an ordinary phone and an intelligence on the other side of the boundary. The context prepared for one task admitted three relations and refused six. The restricted items were refused again when they were requested by name. A value admitted for one purpose was refused at the gate when it was offered to a second channel for another purpose. An inference offered as the sole evidence for a consequential action was refused by the governance engine itself, and the action never executed. The boundary in that demonstration runs at the composition layer, the engine’s own access control remains the work ahead, and the record of the run is kept with its limits stated inside it.
This is why the foundation treats data rights as civil liberties for the age of autonomous intelligence. A person should be able to take part in that age without surrendering sovereignty over their information and their decisions. The machine can belong to the individual. The intelligence can be interchangeable. The authority does not have to leave with the data.