AxsysShrine

The End of the Trusted Place

A manifesto for sovereign computing

Connection must not be a transfer of authority.

I

The architecture we inherited

The modern computer is an extraordinary achievement built upon a set of assumptions that have become increasingly difficult to defend.

They were not foolish assumptions. They arose in a world of scarce machines, expensive connections, identifiable operators, and relatively small communities of programmers. In that world, the machine was a place, the process was an actor, and the user was the authority behind it.

A program ran with the permissions of the account that launched it. A file was found at a location. A server was trusted because it occupied an authenticated address. A database represented reality through records whose present values replaced their past.

Over time, these arrangements hardened into conventions so pervasive that they ceased to appear as choices.

Authority belonged to execution.

Identity belonged to location.

State belonged to the present.

We built nearly everything upon them.

The internet made machines reachable. The web made information retrievable. Cloud computing made infrastructure rentable. Enterprise software made organizations interoperable through APIs and shared databases.

None of these revolutions fundamentally resolved the question of what one independent computer should be entitled to believe, accept, or do because of another.

Instead, we became extraordinarily proficient at arranging trust.

We put credentials in headers, permissions in databases, authority in processes, and identity behind intermediaries. We built sophisticated systems for deciding which machines could speak, which accounts could act, and which services could obtain access to others.

But we rarely questioned the underlying transaction.

To use another party’s work was often to admit some portion of its machinery into our own.

To collaborate was often to grant access.

To establish a shared fact was often to appoint an owner of the database containing it.

And to recover the history of a thing was often to ask the system that could alter it to explain what had happened.

This is the paradigm of the trusted place.

It has served computing for half a century.

Its limitations are now becoming impossible to ignore.

II

The graph of borrowed authority

Consider an ordinary application.

Its developers may understand a few thousand lines of their own code. Beneath those lines stand dependencies written by hundreds of strangers. Those dependencies have dependencies. The application runs inside a language runtime, an operating system, perhaps a container and hypervisor. It is assembled by a build pipeline, distributed through registries and content networks, authenticated through identity providers, and connected to external systems through credentials and delegated permissions.

The application is not a single program.

It is a society of programs, most of whose authors have never met, operating through inherited arrangements of authority.

One compromised maintainer can poison a release. One exposed credential can authorize actions across repositories. One compromised integration can obtain information from organizations that never knowingly interacted with the attacker. One privileged security component can become the entry point into the systems it was installed to protect.

The problem is not that every dependency is malicious.

The problem is that the authority exercised by a dependency can greatly exceed the authority its actual purpose requires.

We have built a computing environment in which an enormous amount of power flows implicitly through relationships established for convenience.

A dependency intended to parse a document may execute with access to the process’s secrets.

An integration intended to read a customer record may inherit authority over an entire account.

An update mechanism intended to repair a security appliance may possess the means to replace its executable behavior.

A tool intended to inspect a system may need privileges sufficient to compromise it.

The industry calls these relationships dependencies.

But when their consequences are examined, many are better understood as delegations of power.

Fig. 1 A graph of power. Every line carries the authority of the thing at the top.

The dependency graph has become a graph of authority.

And the graph is too large, too dynamic, and too economically valuable to dismantle through vigilance alone.

III

The defenses become dependencies

The natural response to a dangerous system is to protect it.

We introduce scanners, monitoring agents, package-signing services, access brokers, endpoint protection, authentication gateways, policy engines, vulnerability databases, and automated incident-response platforms.

Many of these work. They prevent attacks, detect compromise, and materially reduce harm.

Yet they also reveal an uncomfortable feature of the architecture: protection frequently requires installing another component with exceptional access.

The scanner must inspect what it protects.

The update system must be permitted to replace software.

The identity provider must be able to authorize access.

The endpoint agent must operate beneath ordinary applications.

The guard is another door.

This is not an argument against security engineering. It is an argument against requiring security to be supplied primarily by adding privileged machinery to a system whose basic authority relationships remain unchanged.

The result is an escalating contest between the complexity of what we operate and the complexity of what we must build to defend it.

Meanwhile, automation changes the economics.

The discovery of vulnerable components, theft of credentials, production of malicious packages, impersonation of legitimate operators, and propagation through trusted relationships can increasingly occur at machine speed.

Human review does not scale in the same way.

Software production accelerates. Dependencies multiply. Organizations integrate. Autonomous agents acquire the ability to act on behalf of institutions.

And every new connection creates another occasion to confuse access with authority.

The critical question is no longer whether we can add enough protection to the existing structure.

It is whether the structure can be changed so that fewer dangerous permissions need to exist in the first place.

IV

The crisis of the trusted place

The failures of modern computing are not all attacks.

This distinction matters.

A banking system can delay transactions because a shared processing dependency fails. An email service can become unavailable because a routine infrastructure change interacts with latent capacity problems. An aviation network can experience widespread disruption because of ordinary equipment behavior. A trusted software distribution path can become an attack channel because its credentials are compromised.

Different causes. Different technologies. Different failures.

Yet these events reveal the consequences of tightly coupled authority and availability.

A system may function correctly according to its local assumptions while exposing a much larger network to consequences nobody intended.

An authenticated service may return malicious information.

A legitimately signed release may contain harmful code.

A correctly authorized integration may act for an adversary who has taken control of it.

A redundant service may depend on a shared component that fails.

Authentication does not establish truth.

Authorization does not establish safety.

Redundancy does not establish independence.

These properties must be distinguished because they solve different problems.

The deeper defect is the tendency to compress them into a single notion of trust.

We trust the server, so we accept the response.

We trust the publisher, so we execute the package.

We trust the integration, so we grant the token.

We trust the platform, so we permit it to become the authoritative location of our operational state.

The resulting systems are powerful precisely because they make these decisions convenient.

They are fragile when the consequences of those decisions become difficult to contain.

The problem is not that the modern world is too connected.

It is that connection too often implies powers that connection itself should not confer.

V

The primitive must change

A fundamental change in computing cannot begin with a dashboard, a security product, or a new API convention.

It must begin with a different unit of exchange.

Today, the operative unit is usually a message arriving through a channel, an executable artifact obtained from a distributor, or a mutable record maintained by an authority.

We propose something more exact.

A named, versioned, content-specific statement, attributable to its author and independently verifiable by its recipient.

The statement says, in effect:

Under this identity, at this version, I assert that this named thing has this exact content.

World
0x51
Name
/our/0x52/doc
Version
rift 0, case 3
Content
sha-256 9f2c 41d0 … e41b
Signed
ed25519 a71d 5e02 … 03c9
Fig. 2 The unit of exchange. The values are for illustration.

Its identity does not depend on the machine serving it.

Its content does not depend on the goodwill of the intermediary delivering it.

Its history is not silently replaced by the latest response.

Its receipt does not authorize its author to execute instructions.

The recipient can verify what was signed, retain the evidence, and decide independently whether to accept the statement for some purpose.

These are different decisions.

A signature establishes a cryptographic relationship between a statement and a key. It does not establish that the statement is true. A key establishes continuity of control, not automatically the real-world identity of its holder. A valid statement does not grant permission to perform an action.

Those distinctions are not inconveniences to be concealed.

They are the foundation of the architecture.

The primitive must make them impossible to overlook.

VI

Four changes to the meaning of computing

Names, not places

A thing should not owe its identity to the server currently holding it.

It should have a name within an independently controlled namespace, with a verifiable history of who has authority to speak for that namespace.

Machines are replaceable. Network addresses change. Providers disappear. Storage moves.

The identity of a record should survive all of them.

A person, organization, or agent should be able to inhabit a persistent world whose identity is not reducible to a particular host or platform account.

Cryptographic custody supplies continuity. Recognition supplies social and institutional meaning. Neither should be mistaken for the other.

Statements, not messages

Communication should carry evidence that remains meaningful after the channel is gone.

A message tells a receiver what arrived.

A signed publication tells a receiver what an author committed to.

The difference is decisive.

The receiver can retain the content, verify the signature, compare versions, and present the same evidence to another party without requiring the original transport to remain trusted or available.

A statement becomes part of a durable history rather than a transient event in an opaque service.

Values, not inherited programs

Information received from another world should not become executable authority merely because it was received.

It arrives as data, with exact content and a representation that can be checked before use.

The receiving world determines what local behavior, if any, is permitted in response.

This does not mean software can never be distributed. Software can be published as a verifiable artifact. But obtaining an artifact and granting it the power to execute are separate acts, and execution must be confined by authority deliberately supplied at the destination.

A reference is not a command.

A document is not a principal.

A citation is not permission.

Another world’s knowledge may enter your world without another world’s authority entering with it.

History, not overwritten state

A name should possess a history rather than merely a latest value.

Changes should be attributable, ordered according to explicit rules, and preserved in forms that permit later verification.

A proposed change should either be accepted as a coherent event or refused.

A refusal matters. It is evidence that something was presented and not admitted, with a reason that can be examined.

Disagreement matters too.

Two independent worlds can make incompatible assertions about the same subject. The system should not manufacture agreement by overwriting one of them.

Truth is not created by whichever database receives the last write.

The architecture should preserve the evidence from which people, institutions, and authorized programs can reach their own conclusions.

VII

From a graph of power to a graph of knowledge

This changes the meaning of dependence.

Suppose a manufacturer states that a particular batch of steel satisfies a specification.

A laboratory publishes an independent test result.

A supplier references the manufacturer’s batch record.

A contractor references the supplier’s delivery.

An insurer evaluates the contractor’s claim against the disclosed chain of evidence.

In the conventional model, making this process seamless often requires accounts, integrations, shared platforms, replicated databases, and privileged interfaces.

The parties must agree not only about what information they exchange, but also about whose software and infrastructure are allowed to operate upon it.

Now imagine that each party maintains its own world.

Each statement has an author.

Each reference identifies a named record and its verifiable history.

Each participant receives the information disclosed to it, retains its own evidence, and decides what to accept.

The laboratory does not need administrative control over the factory.

The supplier does not need write access to the contractor’s records.

The insurer does not need to become the owner of everybody’s database.

If the manufacturer later disputes the laboratory, both claims remain.

If a participant disconnects, other participants can continue using the records they have legitimately retained, subject to whatever fresh information or authorization their work still requires.

If the original server disappears, the retained evidence does not become meaningless merely because its address no longer responds.

The system consists of independent parties whose histories correspond without being merged.

To depend on another’s work is to cite it, not to surrender authority to its author.

Fig. 3 A graph of knowledge. Every line is a citation, and none of them carries authority.

A dependency graph made of citations is a graph of knowledge.

That is the graph we should have been building.

VIII

The agent makes the question unavoidable

Software agents make this distinction urgent.

Until recently, a great deal of computing could be organized around the assumption that a human knowingly initiated significant actions.

That assumption is already weakening.

Agents will read records, create documents, request approvals, operate applications, negotiate with other agents, and perform transactions on behalf of organizations.

Some will act continuously. Some will delegate tasks. Some will receive instructions from systems their operators have never encountered.

The question Who is running this process? becomes insufficient.

A process might be running under one account, pursuing an objective supplied by another party, relying on evidence from a third, and invoking a capability delegated by a fourth.

Treating that entire chain as the authority of the process’s current user is an invitation to confusion.

A better system must distinguish:

  • Who authored the instruction
  • Who provided the evidence
  • Who delegated authority
  • What exact action was permitted
  • Which identity actually exercised the capability
  • What changed
  • And what can another party verify afterward

Agents should not have to borrow sweeping human privileges simply to participate in an organization’s work.

They should operate as accountable participants within explicitly bounded authority, over records whose origins can be inspected.

The arrival of autonomous software is not merely another security challenge.

It exposes the inadequacy of an identity model built primarily around people logging into machines.

When programs become ordinary participants in institutions, identity, authorship, authority, and responsibility must become first-class properties of computation.

IX

Sovereignty without isolation

Independent worlds are not a proposal to disconnect society.

The point is the opposite.

We want a network in which participation does not require surrendering control to a common operator.

Every person, organization, and agent should be able to maintain its own persistent namespace.

Worlds should be able to publish, reference, observe, and collaborate according to their chosen relationships.

Two organizations should be able to share a record without exposing their entire histories.

Three organizations should be able to follow a disclosed chain of evidence without requiring a fourth to host their shared database.

A new participant should be able to be named before it joins, recognized when it establishes its identity, and addressed through ordinary forms of communication until it operates its own world.

The network should grow by correspondence.

Not by compulsory enrollment in one platform.

Not by central assignment of all names.

Not by the requirement that every participant run the same institution’s software.

Its unity should arise from independently verifiable relationships between its parts.

This is sovereignty in the practical sense: the ability to preserve one’s state, exercise one’s authority, and participate in shared work without making another party the permanent custodian of one’s existence.

Sovereignty does not eliminate dependence.

It makes dependence explicit.

And explicit dependence can be inspected, limited, and changed.

X

Shrine

Shrine is our attempt to build this model as an actual computing environment.

Not as a protocol sitting beside an ordinary application.

Not as a blockchain recording the hashes of events that remain authoritative elsewhere.

Not as another identity layer placed over systems whose privileges remain ambient.

We begin at the level of representation.

A kernel in which named records and references are fundamental.

A runtime in which content can be identified exactly and live capabilities are distinct from persistent values.

An identity system in which custody and its history are explicit data.

A publication system in which a world can make signed statements about its named records.

A network mechanism through which independently running worlds exchange those publications, gather their content, and accept or refuse them according to local rules.

Fig. 4 Two worlds. A signed statement crosses between them. No code crosses, and neither writes into the other.

The recent integration of Shrine’s Foil networking rules with Enki and Mesa establishes an important working path through these layers.

The kernel, runtime, and transport are no longer merely neighboring designs.

In the reported implementation, independent world processes exchange publications over sockets. Remote records can be held and referenced. Tests exercise signatures, pins, historical assertions, refusals, and provenance across multiple worlds.

A value can leave one world and be received by another as a verifiable publication attributable to its source.

That is not the completion of the project.

It is the beginning of a coherent primitive.

The remaining obligations are formidable: robust pairwise confidentiality, precise delegation and revocation, hostile-peer confinement, identity recovery, resilient deployment, secure software adoption, and performance at the scale of ordinary organizations.

These cannot be waived by a manifesto.

They must be engineered.

But for the first time, the central proposition can be tested as a system rather than contemplated as a design.

XI

What we refuse to claim

A serious alternative must not acquire its credibility by repeating the errors of the system it criticizes.

A signature is not truth.

An immutable history is not an honest history.

A capability is not automatically a safe capability.

A decentralized network is not automatically a resilient network.

A value is not harmless merely because it is called data.

A sovereign world can still be compromised. Its operator can be deceived. Its keys can be stolen. Its runtime can contain vulnerabilities. Its users can grant excessive authority. Its conclusions can be wrong.

No architecture abolishes adversarial behavior or human error.

Our claim is narrower, and for that reason more important.

The architecture should not require a system to acquire another party’s execution authority in order to use that party’s information.

It should not require the origin of a statement to be inferred from the route by which it arrived.

It should not require history to be reconstructed from mutable databases and institutional assurances.

It should not require a shared platform to become the owner of every participating organization’s operational reality.

And it should not silently turn a reference into a permission.

If these properties cannot be demonstrated under adversarial conditions, then they do not yet exist as engineering guarantees.

We intend to make them demonstrable.

XII

The proof must be public

The first convincing demonstration of Shrine will not be a polished interface or a declaration that the future has arrived.

It will be a set of independently operated worlds placed in conflict.

One world publishes a software release.

Another receives and verifies it.

A third attempts to forge an update.

A compromised peer tries to rewrite history, impersonate an author, obtain records beyond its disclosure rights, or cause imported content to execute with authority it was never granted.

Connections are interrupted.

Records are withheld.

Claims contradict one another.

Credentials are compromised.

Processes restart.

The result should be a precise account of what the system permits, what it refuses, what evidence it retains, and which security assumptions remain necessary.

Other engineers should be able to reproduce that account.

They should not need to trust our company.

They should not need to believe our architecture diagrams.

They should be able to run the system, inspect the evidence, and attempt to defeat it.

This is what it means to make verification a property of the work rather than a promise by its author.

The system must earn the same scrutiny it asks others to apply.

XIII

Adoption will follow work

Computing paradigms rarely change because the world agrees with an essay.

They change when an alternative makes something important easier, cheaper, safer, or newly possible.

The first use of Shrine may be ordinary.

A software release whose exact origin can be checked.

A business document whose references stay connected to their sources.

A supplier request that becomes a durable relationship between two organizations.

An agent whose work can be attributed without granting it an administrator’s account.

An audit that follows evidence rather than collecting screenshots.

A local business that keeps working when an external service disappears.

Nobody needs to understand the entire architecture to benefit from such a result.

The user sees a document, a table, a request, a response.

The system preserves identity, history, verification, and bounded authority beneath those ordinary interactions.

That is how infrastructure becomes normal.

The new model must meet the old world where it exists. Email, websites, conventional software, files, and databases will remain. Gateways can translate at the boundary. Adoption need not demand that every counterparty migrate.

One organization can begin.

Its counterparties can participate through existing channels.

Those who acquire their own worlds gain stronger continuity and independence.

Relationships accumulate.

The useful network grows out of work already being done.

Not out of a requirement to join a platform before the work can begin.

If the architecture succeeds, its security properties will not be a premium feature.

They will be consequences of using the system as intended.

XIV

The choice ahead

The pressure on modern computing is not likely to vanish.

More software will be produced by fewer people.

More components will be assembled automatically.

More decisions will be delegated to agents.

More institutions will depend on systems they neither own nor understand.

The economic advantages of connection will continue to grow.

So will the consequences of misplaced authority.

We can respond by adding defenses to every boundary and hoping that the resulting complexity remains governable.

We should continue improving those defenses where they work.

But we must also consider whether some of the boundaries were drawn incorrectly in the first place.

A computing system should be able to learn from another without becoming subject to it.

An organization should be able to cooperate without surrendering the custody of its records.

An agent should be able to act without inheriting every privilege of the person who deployed it.

A statement should be able to survive the failure of the machine that delivered it.

A disagreement should be preservable without appointing one database to erase the other side.

And a network should be able to exist as a relationship among independent participants rather than as the property of whoever operates its center.

None of this is free.

It asks for new primitives, new runtime guarantees, new habits of application design, and an unusually rigorous account of authority.

It asks us to rebuild assumptions that have become nearly invisible.

But the alternative is to continue paying for those assumptions indefinitely.

The opportunity is not merely to make today’s software less vulnerable.

It is to make certain dangerous relationships unnecessary.

XV

Our work

We are building Shrine because we believe the next foundation of computing must distinguish what previous foundations too often combined:

  • Identityfromlocation
  • Authorshipfromtruth
  • Informationfromauthority
  • Referencefromexecution
  • Historyfrommutable state
  • Cooperationfromcommon ownership

We do not expect the world to abandon its existing systems because we declare them obsolete.

We expect any successor to prove itself through exactness, usefulness, and survival under scrutiny.

We will begin with one record.

One identity.

One signed publication.

Two independent worlds.

An exchange that can be verified without trusting its route.

A reference that grants no power.

A history that does not disappear when its author is absent.

Then we will extend those properties into the ordinary work of people, businesses, institutions, and agents.

The ambition is large because the problem is foundational.

The method must remain small, exact, and testable.

We are not trying to build the most trusted place in computing.

We are trying to make trust in a place unnecessary wherever independent verification can take its place.

We are not trying to own the network.

We are trying to make a network possible whose participants do not need an owner.

We are not asking the world to believe our statements.

We are building a system in which the world can examine them.

The internet connected machines.

The web connected documents.

The next task is to connect independently controlled worlds without making their knowledge, authority, and histories indistinguishable.

Let every party keep its ground.

Let every statement carry its evidence.

Let every grant of authority be deliberate.

Let every dependency be answerable to the party that accepts it.

And let the resulting network belong to its participants, not to the machinery between them.

That is the work of Shrine.

Not the promise that nothing will fail.

The possibility that failure, compromise, and disagreement need no longer spread simply because we chose to cooperate.

Dependence should be a citation, not a surrender.

We intend to make that the ordinary way to compute.