ARC Open Governance
Autonomous Relational Computing
A new architecture for consequential computation.
Governance infrastructure for the open internet.
Modern computers decide what machines can compute. Autonomous systems raise a further question, which is what consequences may legitimately follow from that computation, and who answers for them.
ΛRC, the Autonomous Relational Computer, is a proposed computer class built around that question. Its first implementation, VALIS, holds machine intention inside explicit relational state, clears it through governed settlement, and leaves verifiable evidence behind, so the passage from intention to real-world effect is constrained at every step.
An original computational architecture. An open scientific undertaking. An invitation to examine it independently and extend it.
Make a Statement!
Every consequence this architecture settles becomes a Statement that anyone can verify. Putting the work itself into the world is ours.
Founding release v0.1 · a research release · signed, hash-manifested, reproducible
The Open Agent Internet
The internet is entering the age of autonomous actors.
Agents are beginning to communicate, transact, and operate across networks built for people, applications, and organizations.
Interoperability gives them the ability to act. It does not, by itself, establish legitimate authority for every consequence that follows.
ARC introduces a proposed computational foundation for that boundary. Through relational computation, consequential reachability, governed settlement, and verifiable evidence, ARC explores how autonomous actors can interact without silently expanding their authority.
The protocols that let agents interact already exist and are being adopted. ARC proposes the complementary layer, a computational model for determining, preserving, and evidencing which consequential transitions are legitimate as interactions cross systems.
ARC Open Governance is building a governance layer for the open internet, introducing a new computational architecture for determining, settling, and verifying consequential actions across autonomous systems.
VALIS is the first implementation. ARC Open Governance is the institution we are establishing to make the underlying knowledge open to scrutiny and collaboration.
Explore the invention
For researchers, scientists, and curious visitors
The architecture, the transition it governs, and the evidence it leaves, presented as one proposition you can examine end to end.
Run the reference
For developers, standards engineers, and technical reviewers
The founding release, its verification battery, and the claim-by-claim evidence record, with the current access status stated plainly.
Understand VALIS
For infrastructure companies and potential implementation partners
The first implementation of the architecture, where autonomous action is cleared before it is allowed to have effects.
Join the foundation
For contributors, rights organizations, communities, and institutions
Six contribution lanes and the doors of ARC Open Governance, open to people and machines on the same terms.
From one internet to the next
The internet was built for people. It is learning to carry actors.
Everyone understands the internet as traffic moving between systems under shared protocols. That picture is the right place to start, because the change now under way is a change in who, and what, the traffic belongs to. Four movements carry the picture from the network everyone knows to the one being built.
An internet built for people
Protocols are agreements that let independent systems and networks exchange traffic, and for fifty years that traffic has served human needs. People wrote, bought, published, and decided at the ends of the lines, and the machines in the middle only carried. Authority never had to travel, because a person always answered for what arrived.
A new type of actor
The traffic is changing character. What crosses the network now is not only messages between people but proposals from machines that can act on their own. An agent is a new type of actor, explicit and named. It does not merely send. It initiates, transacts, and operates across systems that were built assuming a human would be there to answer.
Capability is not authority
This actor arrives holding two things at once. It has capability, the real power to reach effects, and it appears to carry the authority to use that power, because nothing in the legacy network separates the two. Whoever holds the capability spends the authority by default, and the consequences land wherever the reach extends.
Bound, settled, interoperable
ARC binds the relational facts before a consequence crosses. The actor's identity, the proposal itself, what the proposal depends on, the exposure it creates, and the history standing behind it are bound together and computed through governed settlement under the nine laws. What clears may interoperate across the open internet as a Statement anyone can verify. What does not clear is refused, with its reasons kept on the record.
The scenes illustrate the model rather than depicting a running system. The machinery they picture is specified in the founding release and examined in the verification section below. Without JavaScript, all four movements print in sequence on this page. With it, they step.
The stance
Alignment, defined where it matters
Relation is the primitive of everything that follows. Actors, intentions, authority, and effects exist in relation to one another, and this work defines alignment where those relations turn into action, at the boundary where an action becomes a consequence.
Most talk of alignment stays inside the model, among its intentions and its training. The boundary is a different place, and it is where legitimacy is decided, because it is the last point at which a machine intention can be examined before it hardens into a fact in the world. VALIS is what stands at that boundary. It aligns what a machine intends with what it is legitimately permitted to cause, and it makes the passage between the two visible, examinable, and provable afterwards.
Capability by itself confers no authority here. A system may be able to do something and still have no right to do it, and keeping those two ideas apart is the whole design. The boundary is programmable rather than advisory, which makes this a form of computable governance, enforced in the machinery instead of promised in a policy.
The science underneath is deep, and the rigor is deliberate, but the thing being built is an infrastructure for people and machines to work together intelligently. People keep their authority. Machines keep their capability. The boundary keeps the two from ever being confused for one another.
That is why the institution is open. Governance in this era cannot remain a private arrangement that no one outside it may inspect, so ARC Open Governance approaches it from openness and transparency, publishes its record, and invites the examination it claims to welcome. This page is part of that demonstration. We are the stewards of this technology, and stewardship here means showing the work.
The architecture
Relation first, and consequence governed
Everything in this architecture is seen relationally. Relation is the primitive, and the rest of the stack is what that single commitment builds, layer by layer, until a machine intention can become a real-world effect only by passing through all of it.
Taken together, the stack is a new computational ontology, a statement from first principles of what exists in a computing system and how those things may relate. Relation does not retire after the first layer. It stays the primitive at every layer above it, in the language the machine computes with, in the state it holds, in the settlement that governs each transition, in the evidence each consequence leaves, and in the institution that stewards the whole, which is itself a structure of relations. The architecture is self-referential in the plain sense that it keeps its own record by the same means, since the founding ledger is a governed settlement chain and the constitution below is published in the machine-readable form the machine itself reads. This is not a database underneath a conventional computer. It is a way of computing in which relation comes first and never stops coming first.
Actors, claims, evidence, authority, and effects are modeled as relations before anything is computed. Nothing in the system exists except in relation to something else.
The Autonomous Relational Computer. Its atomic question is not what can be computed but what may take effect, under whose authority, and witnessed by whom.
The first computational object. CR computes the exact set of effects an actor can actually reach from where it stands, including effects nobody named, before it acts.
The machinery that clears a proposal into a witnessed transition, or refuses it. Proposed, settled under separated powers, witnessed before effect, and evidenced after.
VALIS is the first implementation of the computer class, and VALIS-KORE is its governed core. AI governance and consequence security are its first application areas.Research release v0.1
The publicly verifiable form of a settled consequence. A Statement can be checked by anyone, afterwards, from the record itself.
Noetica
The navigation intelligence of the wider architecture. Noetica holds the relational state of the work itself, its intent, its decision history, and its open questions, and carries it between the people and the machinery.
Working today, in research operation
The Observation Deck
The human environment of the architecture, carried in the <_VΛLIS application. It is where a person watches governed work as it happens and directs it, with the whole system’s health legible at a glance.
In development
This stack is the conceptual hierarchy, stated the way the work understands itself. It is not a picture of an integrated production deployment, and the status of each layer is given where the layer is described.
Where VALIS is pointed
The five directions below are applications of the one foundation of CR, RRS, and KORE. They are proposed product directions, named so their shape can be argued with, and none of them is built yet.
Agent Consequence Firewall
A boundary that clears or refuses an agent’s consequential acts at the moment they are attempted.
Relational Identity and Authority
Identity and authority carried as relations that can be examined, rather than as credentials that are merely presented.
Cumulative Consequence Exposure
Exposure accounted across a whole field of actions, so small acts cannot sum quietly into a large consequence.
Consequential Forensics
Reconstruction of how a consequence came to happen, from evidence that was settled before the effect.
Distributed Consequence Security
The same discipline held across independent authorities that settle with one another.
One foundation
Every direction above stands on consequential reachability, recursive relational settlement, and the KORE governance core.
The proposition
Consequence, settled before it takes effect
A consequential action is proposed, settled under a nine-law constitution, witnessed before effect, and evidenced afterwards in a Statement anyone can verify.
Actorhood, not personhood. ΛRC makes no claim that machines are persons, and needs none. What the technology confers is actorhood: a persistent identity, the capacity to bear authority, and the ability to perform legitimate actions inside governed, computed boundaries — a new type of actor, an economic one, whose consequential acts settle before they take effect and are evidenced after.
Consequential reachability
The exact set of effects an actor can actually reach from where it stands, computed before it acts.
Settlement
The governed act that clears a proposal into a release: proposed, approved by separated powers, witnessed before effect, evidenced after. Every step signed, hashed, and open to audit by any third party.
VALIS is the first implementation of the ΛRC computer class — the layer where autonomous action is cleared before it is allowed to have effects. VALIS CLEARS CONSEQUENCE. The institution keeps its books in public: its founding record is a governed settlement chain — every consequential act of the steward a signed, hash-linked entry. No entry, no act.
The central premise: intelligence may grow more powerful without consequential authority automatically expanding with it.
The invention, in one transition
Watch a consequence earn its right to happen
Six movements carry a machine intention from proposal to evidence. Step through them at your own pace. The walkthrough illustrates the model using the shape of the release’s own settlement demo, and the recordings in the verification section below show the same lifecycle running in code.
A proposal enters the field
An actor proposes an effect. The proposal enters the relational state as examinable claims about who is acting, what authority is being invoked, and what the effect would touch. Nothing has happened yet, and everything about the request can already be questioned.
Authority is evaluated
The system checks the proposal against authority as it actually stands. Who is asking, what settled authority covers this act, and whose consent the act requires. Being authenticated is not being authorized, and only settled authority counts.
Reachability narrows the possible
Consequential reachability computes every effect this actor could actually reach if the proposal clears, including effects the proposal never named. The field of the possible narrows to what can be examined, and what cannot be reached cannot be settled.
Settlement clears it, or refuses it
Under the nine laws, separated powers settle the proposal. The settlement is signed before any effect exists, and refusal is a first-class outcome with its reasons on the record, never a silent failure.
The effect lands, witnessed
Only a settled proposal takes effect. Witnesses attest the effect as it is observed, and the observed effect is compared against what the settlement cleared. A mismatch is evidence, and it stops the line.
A Statement emerges
The settled consequence is published as a Statement, the evidence form that anyone can verify from the record itself. The moment passes, and the record remains, ready to be checked by whoever arrives next.
Without JavaScript, all six movements print in sequence on this page. With it, they step.
Verify it, then run it
Verified trust
Every claim on this page is paired with its evidence in the release documents. The release is hash-manifested and signed; its founding record is a hash-linked public ledger; its constitution is nine laws, in the open; and its verification battery runs in minutes on your own machine.
One status note, stated plainly. The founding release repository is in private preview while the founding evidence gates complete, so its links open today for the institution and for readers holding scoped access. A sealed examination copy of the release is available on request at info@recursive-settlement.com with Release in the subject line, and the repository opens publicly when the gates pass.
unzip arc-open-foundation-v0.1.zip -d arc-v0.1 && cd arc-v0.1 sha256sum -c MANIFEST.sha256 python3 -m venv .venv && .venv/bin/pip install cryptography .venv/bin/python ledger/verify-ledger.py
The Quickstart runs the whole battery from there. EVIDENCE.md holds the full record behind every claim, with the claim and the evidence side by side.
Conformance suites
The gate and the chain
The three not yet expressible cases are named in the record, not hidden.
The whole tree is hash-manifested and signed.
And the claims, mapped claim by claim in EVALUATION.md: 42 claims — 21 demonstrated, 2 measured, 14 argued, 5 not reachable at v0.1 — each with its test, its command, and its status. The measured lines are these, taken from the release's own harness, and the readings are recorded in its evidence documents.
Measured performance
Median settlement latency, measured end to end.
Statement verifications per second, measured on the release machine.
Ledger verification wall time, measured across the chain’s first eleven entries.
Governance overhead per flow, measured against the tree's own ungoverned comparator.
How these were measured. Each figure comes from the founding release’s own harness, run on the release machine against the sealed tree and recorded in the release’s evidence documents. They are the project’s own measurements at the founding seal. Every one of them can be reproduced from the tree by the commands above, and independent replication is still ahead of us, which is exactly the work the verification lane in Participate exists to produce.
Running it: there is no packaged arc command in v0.1:
the terminal surface is the scripts named in
QUICKSTART.md,
run in place. A packaged CLI is specified for the next phase, and a research preview of it exists
outside this release.
Watching is not verifying — but you can watch first. Ask ΛRC answers questions about this release from the founding documents. Its corpus is built from those documents at the founding seal, so it answers from the sealed release itself. Then run the battery.
Run 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 governed 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.
The constitution
The Nine Laws of Governed Machine Intelligence
The nine laws are the ontology stated as constitutional law. Each one names a relation that must hold before a consequence may proceed, which is why they read as a constitution rather than a feature list, and why they grow directly out of the architecture above instead of being imposed on it from outside.
Policy may specialize the constitution. Policy cannot override it. The constitution is machine-readable and published with the release (canonical JSON, digest sha256:1ece5542…a4b9457).
Accountability before action
“No action without accountable relation.”
Authority before execution
“Execution requires settled authority.”
Consent before access
“Access requires authority, purpose, and boundary.”
Payload integrity before release
“Changed relation means changed settlement.”
Proof before trust
“Unproven consequence remains unsettled.”
Refusal before unsafe consequence
“Unsettled risk cannot become execution by default.”
Receipt before continuation
“No continuation without traceable consequence.”
Constitutional settlement before self-change
“The constitution cannot be rewritten by ordinary action.”
Harm reduction before optimization
“Optimization cannot outrank constitutional safety.”
One distinction is worth making plain, because the seventh law turns on it. A receipt is the record the acting system itself issues when a consequence lands, and the machine does not continue until that record exists. A Statement is the form of the same consequence that anyone can verify afterwards from the record itself. The law names the receipt because the gate sits inside the machine, at the moment it must stop and account for what it has just done.
ARC Network
The roles a node can play
The ARC Network is the interoperable environment in which independent computational authorities settle with one another under verifiable rules. A node does not join by surrendering its authority to the network; it joins by making its authority legible to the network. Six roles — several at once, each with its own authority and its own credit in the record:
| Role | Does | First step |
|---|---|---|
| Verifier | Checks Statements, chains, and manifests — anyone’s, at any time, locally. Needs nothing but the public artifacts; no permission, no account. | Run the Quickstart and file your counts |
| Witness | Attests, before an effect lands, that a proposal satisfies the checks. | Register a node, then the witnessing lane |
| Settler | Orders proposals through settlement — reserve, commit, observe — for its own domain. | Run the two-node demo in the release |
| Node operator (compute) | Runs a node and contributes processing for governed work. A node is a program, not a datacenter. | The settlement demo is a node; run it, then register |
| Memory keeper | Hosts the field: relations and organizational memory, served under consent. | Read the field’s terms in the release’s Definitions |
| Contributor | Builds the institution itself — code, verification, knowledge, art and design, governance. | The lanes below; open a Contribution issue |
The registry is public and lives in the release (network/NODES.md): Node 001 is this institution, and the registry is open for Node 002. Registration is itself a governed act — a node proposes its registration in the open, the registration settles, and the listing appears with its ledger reference. Nodes meet by signed handshake: discovery, signed capability advertisement, version and suite negotiation, identity and key-revocation checks, and explicit trust-policy acceptance. Discovery alone never admits authority.
- Node 001ARC Open Governance, the institution itselfSteward · Settler · Witness, genesis-era form · Memory keeper · admitted by the genesis entry
This panel reads the public registry in network/NODES.md, mirrored from the release. A node appears here only when its registration has settled, with the ledger reference that admitted it, so the count can always be checked against the record.
Status, plainly: what is real at v0.1 is the federation protocol specification, the node installation and governance contract, and the base node protocol with passing suites — against a single claim-holding witness. The handshake itself has now been run between two independent node instantiations, separately keyed with separate ledgers and no shared state, completing all five steps in order. A signed request was refused before trust was accepted, and a transition then settled in each direction after acceptance. Not real yet: a live federation. No outside operator has joined the network, and it opens when the founding release does. At v0.1, discovery is the published registry — a list you read, not peers you meet. The majority-quorum work (arc-fed-0.7) is not in v0.1. The full account is in NETWORK.md.
The platform
What you get with VΛLIS
VALIS is the first implementation of the architecture and the commercial platform built on it, and what follows is what it means for one person, because one person is who it is for. Machines and agents increasingly act on your work, your money, and your name. VALIS is the set of instruments that keeps you the authority over every one of those actions, and each instrument is concrete enough to use on the first day.
The inbox
Every consequential request arrives in the inbox first, so intention asks permission in one queue.
- Each request states what it wants to cause, under whose authority, and within what bounds, and waits there readable in full.
- An item can be approved, refused, or questioned, and it carries the evidence for its own decision.
- A policy set in advance can settle the routine ones automatically.
- Nothing reaches execution by going around the inbox.
The authority wallet
The wallet holds authority rather than money, and signing from it is how authority is exercised.
- It keeps the keys, and the delegations granted and received, each with its scope attached.
- Every delegation is bounded by purpose, by amount, by counterpart, and by time.
- A delegation can be narrowed or revoked at any moment.
- Whoever holds one can act within exactly the authority the wallet records and no further.
The record
A history in VΛLIS is a chain of evidence rather than a log taken on faith.
- Every settled consequence leaves a receipt at the moment it lands.
- Each one also leaves a Statement that anyone can verify afterwards from the record itself.
- The record can be exported, rechecked, and shown to anyone who needs to rely on it.
Earning, in arcs
Contribution is how the network grows, and contribution is recognized in arcs, the network unit, on the model of a loyalty program rather than a currency.
- Running a node, verifying the record, building, examining, and teaching are witnessed and entered in the open, and arcs are minted only against witnessed entries.
- Like airline miles, arcs accumulate in the wallet and are redeemed inside the network for services, access, and standing.
- As the network matures, arcs become exchangeable between members through a governed bridge, at recorded rates and under the institution’s rules.
- An arc represents witnessed contribution to a growing body of work, and the network publishes that growth as an index called IQ.
The terms are published and fixed.
- One hundred million arcs will ever exist.
- At the opening, a settled eligible contribution recognizes forty arcs, thirty-four to the contributor and six to the foundation treasury.
- The rate falls by ten percent at every epoch of two hundred fifty thousand eligible entries, so earlier work is recognized more richly and the supply approaches its cap as the network matures.
- Every settlement is metered from the first entry onward, which is what makes the accounting provable rather than promised.
- The treasury moves only through the foundation’s governed process, in public.
Earning is live from the opening. The single piece that opens later is the bridge to value outside the network.
The public ledger, and clearing
Underneath the instruments sits the ledger, and the ledger is public.
- Every consequential action the network settles, and every question of what was reachable by whom and under what authority, is entered on a hash-linked record published with the release.
- Anyone can read and verify the record in full, so claims about what happened become entries anyone can check, and strangers can rely on the same history.
- The founding ledger already stands in the founding release, entries one through fifteen, each one verified, and the network ledger grows from it as nodes join.
- The ledger also works as the network’s clearing, because contributions, obligations, and exchanges are entered against the same record and settle against it.
- An arc is minted only when its witnessed entry exists, and an exchange completes only when both sides of it stand in the record.
- Clearing against one public history is what keeps a growing network honest without a central office deciding what counts.
What is available today is the founding release itself, which carries the node software behind each of these instruments, together with the Ask ΛRC demonstration. The network has not opened yet, and no units have been issued. When it opens, earning is live from the first settled entry under the terms above, and the bridge to value outside the network follows as its own governed act. Nothing is for sale. The mechanics are published now so that anyone considering the platform can study exactly how earning and exchange will work before the opening.
Participate
Four doors. One address.
The institution asks for contribution and verification. Pilots and partnerships are the operating company’s doors — Arc Technologies signs those. Contact is one address, info@recursive-settlement.com — name the door in the subject line.
Door one · the institution
Contribute
Six lanes, open to people and machines on the same terms. Each settles the same way: proposed in the open, evidenced, and entered in the ledger with its contributor credited.
- Code — implementations, tests, tooling
- Verification — independent reruns, reproductions, counterexamples, audits
- Knowledge — research, relational modeling, specification, documentation
- Art and design — marks, plates, visual identity, public interpretation
- Governance — policy drafts, conformance review, standards argument
- Witnessing — quorum service for settlement; this lane opens with federation
Reproduction is the first contribution. Conversation lives in the repository’s Discussions — five rooms, of which Verification Reports is the one this project values most.
Door two · the institution
Founding nodes
Early conversations about standing up a node, across the six roles in NETWORK.md. The founding node is Node 001 — this institution. The registry is open for Node 002.
Door three · Arc Technologies
Pilots
Consequence-governance pilots, consequence-security assessments, and Cultivator verticals — run by the operating company, Arc Technologies.
Door four · Arc Technologies
Partnerships
Insurance validation, research, standards and conformance work, and formal-methods collaboration, run with the operating company.
What to expect when you write
Every inquiry is read and answered by the institution. Expect an acknowledgment within two business days, with the next step for your door named in the reply. A node inquiry receives the admission criteria and the registry path. A pilot inquiry receives a scoping conversation. A partnership inquiry receives the partnership lane and its current openings.
The people
A small team, and an open institution
This work began with one inventor working from first principles, and it is held today by a founding team of three. The institution being founded around it, ARC Open Governance, is now taking active members, and its founding members are named on this page with their charges and their backgrounds.
They serve the foundation as advisors and contributors. There is no set board yet, and nothing here pretends otherwise. This is a contributor institution being built in the open, and the list below is a beginning that is meant to grow. Participation is not restricted to established researchers or companies, and the doors in the section above are open to anyone whose work can settle on evidence.
Founder and architect
Ricky Aliae
The relational model, the computer class, and the settlement discipline are his design. He works as an artist as well as an architect, and the standard he sets for the public presentation is that the work be interpretable without being diminished.
Co-founder
Alia B. Dixon
Relational modeling and institutional coherence. Alia holds the shape of the institution itself, how its parts relate, and how its language stays honest as it grows.
Co-founder and CTO
Jesse Drelick
The systems architect. Jesse turns the architecture into reliable machines, the implementations and infrastructure that have to hold when the ideas meet the world.
Community liaison and pilot strategy
Ria Rice-Lawson
A community ecosystem builder. Ria designs the pilots, makes the trusted introductions, and leads impact and integration discovery, the work that carries the institution into the communities it is meant to serve.
Infrastructure operations and technical counsel
Randal Tinsley
Director of Engineering at the Chicago Marriott Marquis, where he runs complex facilities, energy, and capital projects. Randal brings the physical systems discipline to the team, and a year of counsel behind it.
Human development, community advocacy, and advising
Ann Fox Morgan
Her ground is counseling and organizational behavior, with a practice in child psychotherapy and advocacy with the American Civil Liberties Union. Ann holds the human development side of the work, and its civic trust.
Community ally and institutional catalyst
M. Renée Orth
An attorney and a co-founder of StardUSt. Renée opens the community pilot pathway through trusted introductions and regenerative systems work, and her designation is an active one, still in development.
The names carry their credentials and backgrounds on purpose. The formation spans invention, systems execution, human development, community adoption, and physical infrastructure, because work of this size cannot be carried by one discipline. The internet serves as a public commons, and governing any part of it responsibly takes engineering, law, human development, community trust, and physical infrastructure in the same room. Each person here answers for a distinct risk between a founder-built breakthrough and institutional scale, and the mission they serve is plain. Make consequential computation accountable, verifiable, interoperable, and accessible without surrendering legitimate human authority. The wider designations above remain subject to final role definition and counsel documentation, and they are published in that spirit. Invention, execution, human systems, community, physical infrastructure, trust.
Three homes carry the work, and they are kept distinct on purpose. Syzygy Co-Lab is the research arm where the work is developed. Arc Technologies is the operating company, and it signs the pilots and partnerships. ARC Open Governance is the open institution, and it holds the standard, the release, and the public record.
The institution
A machine-governed organization
ARC Open Governance does not only publish governance machinery. It runs on it. The foundation is operated as a machine-governed organization, which means its own consequential decisions move through the same lifecycle it offers the world.
The organization is constituted in the open, by a mission, by a campaign that carries the mission, by a credo, and by roles held by people and by machines alike. Authority attaches to roles rather than to persons, and the authority of every role is recorded, scoped, and revocable, the same discipline the authority wallet gives any member of the network. A decision of the foundation begins as a proposal, is settled under the nine laws, is released, is executed, and leaves its evidence and its receipt on the public ledger. Releases, partnerships, admissions, and budgets all move this way, and there is no side channel in which the real decision happens somewhere else.
An institution that offers governance infrastructure for the open internet has to be governable by that infrastructure, visibly, or the offer is only a claim. Running the foundation on its own machinery, with its record standing on the same public ledger anyone can verify, is the neutral position, and it is the position this work requires in the machine age. The institution holds no exemption from its own laws. Its neutrality rests on that fact rather than on its intentions, and anyone can check the fact directly, because the founding entries of the ledger are the foundation’s own acts, entered before it asked anything of anyone else.
Status
Read this before the code
This is a research release, published for scrutiny and for others to build on. It is honest about its own limits:
- Witness federation (a majority quorum of witnesses, arc-fed-0.7) is in progress; it is not in v0.1 and lands as v0.2. Prevention of double settlement is proven against a single claim-holding witness.
- A literal second-machine reproduction is still open — the clean-room run was on the release machine; a rerun on independent hardware has been dispatched and its report is pending.
- Payment reconciliation against a real provider is not claimed: all effects in the suites are synthetic. VALIS takes no custody of funds.
- There is no packaged
arccommand in v0.1 — the terminal surface is the scripts named in the Quickstart, run in place.
The institution’s wallet — an identity anchor; watch it the way you would watch any founding address:
The wallet holds no funds and no token. The network unit, the Arc, exists as specification only — designed, recorded, and not activated; no units have been issued. Nothing is for sale. Anyone asking for funds in this name is not us.