The gap
Every autonomous system must decide where it is, in the moment, on its own. An autonomous vehicle's control loop runs near 20 Hz on a sub-50-millisecond budget, while network round-trip latency runs to the hundreds of milliseconds. A per-decision call to a server is not slow. It is physically impossible. The same holds wherever autonomy is real. A Mars rover sits 20 light-minutes from its operators. Defense systems plan around denied and intermittent links. An agent that asks permission for every step is not autonomous. Autonomy is the property of acting without a round-trip to authority.
Yet our entire trust stack assumes a central point the system can defer to: identity providers, policy servers, certificate authorities, humans in the loop. Autonomy removes that point at the exact moment of decision. Today's answer is to bolt a governor onto the outside, whether a runtime-assurance monitor, a Simplex backup, a reinforcement-learning shield, or an LLM guardrail classifier. The governance lives outside the thing being governed, so it does not travel with the object, does not survive disconnection, cannot prove after the fact why it allowed what it allowed, and must be re-established at every boundary the object crosses.
The invention
Adaptive Query moves authority into the data. Authority is not granted by the host; it is carried by the object and presented to the host. That is the object-as-authority model capability security has shipped in production for decades (KeyKOS ran VISA transaction processing on it; Google's Fuchsia is built on it). The forcing function that finally makes it necessary is autonomy, not decentralization. A vehicle with a thousand datacenters behind it still has to decide onboard, in fifty milliseconds, carrying its own constraints. Autonomy needs the object to carry governed authority even when the infrastructure is fully centralized, which frees a fifty-year-old idea from its losing bet on decentralization.
Carried governance turns every trust function into a property of the object: an identity it can prove without a certificate authority; policy it checks before it acts, where refusing to act is a valid outcome and the object cannot quietly rewrite its own rules; an append-only, tamper-evident record of what it did and why; routing and discovery keyed to trust state rather than network addresses; and memory and constraints that persist across the disconnected, adversarial environments where autonomy actually operates.
The inventive step
The components already exist and are proven: signed objects, hash-based identity, append-only logs, capability-style pre-action checks, quorum protocols. The novelty is the recombination, and the recognition that no prior art assembles them for carried autonomy. The art consistently assumes, and is optimized for, a trusted central host. It does not merely fail to teach this combination. It teaches away from it, toward centralization. Nobody carries governance inside the autonomous unit; everybody bolts it on outside. The prerequisite claim follows directly: if the decision is local, everything it must be trusted against, including identity, policy, lineage, and the right to act, must be local too, or the trust evaporates the moment connectivity does.
On a hostile machine, no software can make a single adversarial host honest about itself, or hide a secret it must use locally. Those guarantees are hardware-bound, and the architecture composes with hardware roots of trust at the leaves. But a trust-scoped, host-signed, consensus-backed fabric makes every host's actions attributable, and subjects each state change to independent multi-party quorum that checks derivability from a trusted origin, the external witness that defeats a forged history. It then scores, routes around, quarantines, and revokes misbehaving hosts, failing closed when authority cannot be verified. The malicious host becomes a contained, attributable, out-routable problem rather than an unbounded, anonymous, trusted-by-default one.
Alone, and in composition
On its own, each layer is its own market: keyless identity, memory-native networking, anchor-governed indexing, cryptographic governance, and memory-resident execution each stand alone across heterogeneous, intermittently connected, and adversarial environments, and on the centralized infrastructure that still needs trust at the point of decision.
Composed, they are one substrate: deterministic where today's autonomy is probabilistic, auditable where it is opaque, governed from within where it is monitored from without, and carried, so it survives the disconnection that defines the autonomous condition. That is autonomy you can trust. The full argument is laid out in the white paper.
