Sov · The Foundation — An Explainer
The Sovereignty Foundation
A Neutral Architecture for Governing Intelligent Systems
Artificial intelligence is rapidly becoming infrastructure.
AI systems are beginning to write software, operate tools, access databases, communicate with other systems, make recommendations, execute transactions, and act on behalf of people and organizations.
As these systems become more capable, an important question follows:
How do we govern systems that can act?
Technology companies are already building answers.
They create safety policies, authorization systems, monitoring infrastructure, evaluations, access controls, and internal rules governing how their systems operate.
That work is necessary.
But it creates a larger structural problem.
A company can govern its own technology. It cannot define governance for everyone else.
Microsoft cannot reasonably define the rules by which Google must operate.
Google cannot define them for Apple.
An AI company cannot unilaterally establish the rules that governments, hospitals, banks, universities, competitors, and the public should accept.
And governments face the inverse problem: they can create laws and regulations, but they generally do not build the technical infrastructure through which intelligent systems identify actors, delegate authority, evaluate actions, and produce verifiable evidence.
There is a gap between governing an organization and building shared infrastructure for governance.
The Sovereignty Foundation exists to explore that gap.
Section IThe problem is bigger than any one company
The internet works because competing systems can agree on certain things without agreeing on everything.
Different companies can build different products.
Different organizations can establish different policies.
Different countries can establish different laws.
Yet underneath those differences, shared technical standards allow independent systems to communicate.
We believe intelligent systems increasingly need a similar layer for governance.
Not one universal policy.
Not one company controlling everyone else.
Not one government operating the world's AI infrastructure.
A common architecture through which different organizations can express and enforce their own authority while still sharing fundamental ways of answering questions such as:
Who or what is acting?
Whose authority are they acting under?
What are they authorized to do?
What conditions apply to the action?
What actually happened?
Can another party independently verify it?
Those questions cross organizational boundaries.
The answers therefore cannot depend entirely on infrastructure controlled by any single participant.
Section IINeutrality is infrastructure
This is where the Sovereignty Foundation begins.
The Foundation is being developed as an independent research and standards organization for governed intelligent systems.
Its purpose is not to govern AI companies.
It is not to govern governments.
And it is not to determine what intelligent systems should think, believe, or say.
Its purpose is to develop and provide neutral technical infrastructure through which governance can be expressed, tested, implemented, and independently verified.
That distinction matters.
A hospital should determine its own medical policies.
A bank should determine its own financial controls.
A technology company should determine how its systems operate.
A government should determine the rules that apply within its lawful authority.
The Foundation does not need to make those decisions for them.
Instead, the Foundation can work on something underneath those decisions:
the architecture that makes those decisions enforceable and verifiable across intelligent systems.
Section IIIFrom principles to infrastructure
AI governance is often discussed through principles.
Systems should be safe.
Systems should be accountable.
Systems should respect authority.
Systems should behave within defined boundaries.
Those are important objectives.
But principles alone do not tell a computer what to do.
A machine needs architecture.
If we want accountability, the system needs a way to establish who or what acted.
If we want authorization, it needs a way to represent what authority an actor possesses.
If we want boundaries, it needs mechanisms capable of determining whether an action may proceed.
If we want auditability, it needs evidence showing what actually happened.
If we want independent oversight, that evidence needs to be verifiable by someone other than the organization that produced it.
The Sovereignty Foundation is developing an architecture around these problems.
It rests on three things: an identity primitive, an identity pipeline, and a modular stack for governance.
The Foundation's proposition is straightforward:
Governance should not exist only as policy around the machine. Where possible, it should become architecture inside the machine.
Section IVThree primitives
The architecture can be read from the ground up or from the top down. From the ground up: an identity, a pipeline that carries it, and a stack that governs what is done with it.
WISP: the identity primitive
Most systems answer who is acting with a credential: a login, a key, a token. A credential proves that something was presented. It does not say who is there.
A WISP is a different kind of object: a representation of an actor's identity at a moment, derived from what the actor is observed to be rather than from what it holds. It can be committed, compared with the one before it, and bound to an action, so that an action carries the identity that took it rather than a claim about it.
It is small on purpose. A primitive is something other things are built from.
Logos: the identity pipeline
Logos is what carries a WISP through time and through action.
It observes an actor, commits its identity as a chain of WISPs, and binds each action to the identity at the moment it was taken: the decision made on it, the boundary it crossed, and the result that came back. The result returns to the same chain it left on; we call that return the rebound.
The chain is the answer to who acted: not a claim made at the door, but a continuous record from identity to decision to execution to result, where each link can be checked against the one before it. When an action is refused, the chain says which link failed. It is the same chain whether the actor is a person or an agent acting under a person's authority.
The Sovereignty stack: a modular architecture for AI governance
Identity alone does not govern anything. The Sovereignty stack is the environment in which actions are authorized, decided, bounded and recorded, for agents and people alike.
Its parts each do one thing: represent authority, hold policy, decide whether an action may proceed and say why, check at the moment of execution that identity, authority and policy still hold, and record what happened as evidence another party can verify. They are modular. An institution can run the whole stack, or take the parts it needs and keep the rest of its own.
An agent enters the stack the way a person does: as a character with a stated policy, working uninterrupted within what that policy allows, asking a person only where the policy says so, and unable to widen its own policy. A hospital's system, a bank's agent and a person's own machine can each run the stack under their own policies and still answer the six questions above in the same way. That is what across trust boundaries means: not a shared policy, but a shared shape for identity, authority, decision and evidence.
Section VLocal, and private
One property of this architecture is easy to miss and matters more than any component.
The stack runs where the actor is: on a person's own machine, on an institution's own infrastructure. It does not run on the Foundation's servers, and it does not report to them.
The signals that establish an identity are the most private data there is: how a person types, what their machine is doing, the rhythm of their work. Under Logos, those signals never leave the device. They are observed locally, committed into an identity locally, and discarded. What leaves is not the data but the evidence: a committed identity, a decision, a receipt, a signature, a time.
Verification is designed around that separation. Another party can check that an action was taken by a continuous identity, under stated authority, within a stated policy, with a result that returned to the same chain, without ever seeing the private signals the identity was built from.
Governance that requires surveillance is not governance. The evidence crosses the boundary; the person does not.
Section VIA common layer without common control
Neutral infrastructure does not require everyone to follow the same rules.
Quite the opposite.
A useful governance architecture should allow different institutions to maintain different policies while sharing a common technical language for expressing them.
Consider three organizations using autonomous agents.
A hospital may prohibit an agent from modifying a prescription without physician authorization.
A financial institution may require additional authority before an agent can move funds.
A manufacturer may allow an autonomous system to control equipment only within a defined operating envelope.
Those are different policies.
They do not need a central organization deciding which policy is correct.
What they may benefit from sharing is an architecture capable of expressing:
This is the actor.
This is its authority.
These are the conditions under which it may act.
This is the decision that was made.
This is the evidence of what occurred.
In the architecture above, the first line is a WISP, the chain Logos carries is what makes it the actor's, and the rest is the stack doing its job: the authority, the conditions, the decision and the evidence each held by a part built for it.
A common architecture can support different rules.
Interoperability does not require uniformity.
Section VIIWhy an independent foundation?
If this infrastructure is going to cross institutional boundaries, where it comes from matters.
A governance architecture controlled entirely by one technology company asks its competitors to trust infrastructure owned by a competitor.
A system controlled entirely by government creates a different dependency: technical governance becomes tied directly to governmental authority.
A proprietary architecture that cannot be independently examined asks everyone else to trust claims they cannot verify.
The Sovereignty Foundation proposes another model.
The Foundation can provide a neutral forum in which technologies, architectures, tests, and standards are developed publicly and subjected to outside scrutiny.
Companies can participate.
Governments can participate.
Researchers can participate.
Standards organizations can participate.
Independent engineers can participate.
The public can examine the work.
No participant needs to surrender control of its own systems simply to participate in the development of common infrastructure.
The Foundation's independence is therefore not merely an organizational preference.
Neutrality is part of the architecture.
Section VIIITechnology that can be challenged
Neutrality alone is not enough.
An organization can call itself independent and still ask everyone to trust its conclusions.
The Foundation is pursuing a stronger model.
Its technologies are intended to be placed into public research and validation processes where claims can be examined, tested, challenged, reproduced, and improved.
Research can produce a proposal.
Public testing can challenge it.
Working groups can develop it.
Standards can define interoperable behavior.
Conformance testing can determine whether implementations actually behave as claimed.
Certification can provide a recognizable signal when those requirements have been demonstrated.
The objective is not:
Trust the Sovereignty Foundation.
The stronger objective is:
Do not require trust where verification is possible.
That principle applies to the Foundation's own work as much as it applies to the systems the Foundation studies. It is the same principle the architecture applies to every action: a claim that cannot be verified is not evidence.
Section IXAn architecture for cooperation
The larger opportunity is not to build one governance system that everyone must adopt.
It is to create enough common ground that independently governed systems can interact.
A company should be able to build its own AI infrastructure.
Another company should be able to build something completely different.
A government may impose requirements neither company would have chosen independently.
An institution may establish additional policies appropriate to its own environment.
Those differences can remain.
But underneath them, shared primitives and standards can allow these systems to understand identity, authority, provenance, evidence, and governed actions in compatible ways.
That creates the possibility of something the industry does not automatically produce through competition:
shared governance infrastructure without shared control.
Section XA public forum for intelligent systems
The Sovereignty Foundation is therefore more than a collection of technologies.
The technologies are contributions to a larger process.
The Foundation proposes a public forum where researchers, companies, governments, institutions, and independent participants can examine how intelligent systems should establish identity, carry authority, constrain actions, and produce evidence.
Its working groups provide a mechanism for developing those ideas collaboratively.
Its research provides proposals that can be challenged.
Its technologies provide implementations that can be tested.
Its standards provide a path toward interoperability.
Its validation infrastructure provides a way to determine whether claims survive contact with reality.
And its certification work can provide a mechanism for communicating demonstrated conformance without requiring the Foundation to operate the systems themselves.
This creates a separation that we believe matters.
Companies build products.
Governments establish law.
Institutions establish policy.
The Foundation develops and validates neutral infrastructure through which those authorities can be expressed and verified.
None needs to become the other.
Section XIThe proposal
We do not believe the governance of intelligent systems should ultimately depend on one company asking the world to trust its rules.
Nor do we believe every organization should have to invent an entirely separate governance architecture from the ground up.
There is another possibility.
We can develop common technical primitives: an identity, a pipeline that carries it through every action, and a modular stack in which actions are authorized, decided, bounded and recorded.
We can run them where the actor is, so that private signals stay private and only evidence crosses a boundary.
We can test them publicly.
We can allow competing implementations.
We can establish working groups around unresolved problems.
We can define standards where agreement emerges.
We can build conformance tests that determine whether implementations actually meet those standards.
And we can provide technologies that allow governance to become something systems can execute and outsiders can verify.
That is the architecture the Sovereignty Foundation is proposing.
Not a central authority over intelligent systems.
A neutral foundation beneath them.
A place where competing organizations can cooperate without surrendering control.
A technical architecture through which different forms of authority can operate without becoming one authority.
And a public process through which the infrastructure governing increasingly consequential intelligent systems can be examined by more than the organizations that built them.
AI governance will require rules.
But rules alone will not be enough.
We also need infrastructure capable of carrying them.
That is the work of the Sovereignty Foundation.
