Canonical State and Bounded Authority

Traditional software receives commands. A human opens an application, selects an object, approves an operation, and remains inside the execution loop. Autonomous software receives objectives: maintain liquidity, rebalance a portfolio, reserve a charger, route a robot, allocate compute, or satisfy an obligation. Objectives describe desired conditions of the world, not a sequence of interface clicks.

Consequence begins when state changes. A balance decreases. A position opens. Capital becomes reserved. A robot acquires a corridor lease. A charger becomes occupied. A transfer settles. The central systems problem is therefore not merely whether an agent can choose a good action. It is whether the system can answer, before and after that action:

• What is authoritative now?
• What is already claimed?
• Who is asking?
• What may this actor change?
• Under what bounds and for how long?
• What actually happened?

Multiple intelligent actors make the problem harder. A trading agent, treasury agent, tax agent, yield agent, and shopping agent can each be useful while competing for the same finite capital. Giving each actor unrestricted credentials collapses intelligence into authority. Letting each independently reconstruct the treasury creates conflicting truths. Requiring a human to approve every action preserves control but destroys machine-speed autonomy.

WSP explores a fourth architecture: persistent canonical state and enforceable resource authority outside the model, with bounded capabilities issued to actors for specific transitions.

As autonomous systems scale, the bottleneck shifts from producing intelligent proposals to governing persistent consequential state across many actors.

More capable models make this boundary more important, not less. A system that can plan faster, use more tools, and act with less supervision creates greater demand for independently enforceable authority. Persuasive reasoning is not permission. Confidence is not jurisdiction. A plan is not evidence that the world changed.

Knowledge != Authority
Authority != Execution
Execution != Settlement
Observation != Canon

The scalable architecture is not to make every actor think about everything. It is to persist what is true, expose what is relevant, grant only the authority required, and invoke expensive intelligence only when the task actually requires it.

This is not an argument against intelligent models. It is an argument for allowing intelligence to focus on planning, ambiguity, negotiation, research, and strategy instead of repeatedly performing memory, bookkeeping, permission interpretation, conflict detection, and state reconstruction.

WSP begins with a sovereign principal, autonomous actors, and independently governed resource domains. Each resource domain has an authority responsible for the state transitions inside its declared jurisdiction.

ResourceDomain {
  authority
  canonical_state
  evidence
  claims
  policies
  requesters
  capabilities
  executions
  reconciliations
}

Canonical does not mean globally omniscient. A canonical treasury does not know every market. A warehouse authority does not own the power grid. Canonical means that, within a declared resource and authority scope, there is one authoritative adjudicative view—or a coordination mechanism equivalent to it—for consequential transitions.

The protocol distinguishes external reality, observation, actor belief, and canon. A sensor can be wrong. A model can be stale. An accepted operational state can later be revised by stronger evidence. The representation is authoritative for adjudication, not metaphysically identical to the world.

Reality != Observation != Belief != Canon

KNOWN
ESTIMATED
EXPECTED
PENDING
STALE
DISPUTED
UNKNOWN

Different facts require different consistency. Exclusive consequential state—spendable cash, one loading bay, one charging port—requires serialization, leasing, or an equivalent mechanism against conflicting claims. Observational state may tolerate bounded staleness. Advisory state may influence policy but must not silently become settled fact.

These primitives form a closed loop rather than a one-way command pipeline:

state
  -> request
  -> adjudication
  -> bounded capability
  -> mediated execution
  -> external evidence
  -> reconciliation
  -> updated state

The actor proposes a transition. The authority decides whether the transition is permissible against current state, claims, and policy. The executor verifies the capability at use time. The authority updates canon only after accepted evidence describes the outcome.

Finance is the first useful domain because its invariants are unforgiving and measurable. A system cannot safely reinterpret uncertainty as money.

UNKNOWN != $0
EXPECTED != AVAILABLE
BALANCE != DEPLOYABLE CAPITAL
REQUEST != AUTHORIZATION
AUTHORIZATION != EXECUTION
EXECUTION != SETTLEMENT

A canonical treasury distinguishes liquid balances, liabilities, protected obligations, expected income, pending transfers, disputed value, encumbrances, available capital, policy, and operating mode. The ledger records what moved. Encumbrances record what is already claimed. That distinction prevents the same fungible capital from being promised to multiple actors before any transfer appears in the ledger.

A capital request should not give the requester the treasury. Instead, the requester states the amount, purpose, bounds, and destination. The authority evaluates that request against canonical state and returns a denial, a bounded approval, or a partial approval. The actor receives a decision—not unrestricted custody and not every underlying balance.

The reference implementation currently supports a narrow, defensible claim: it is a fail-closed, disclosure-bounded capital-adjudication kernel. A reported terminal run passes nine tests.

The passing tests establish the following:

• Unknown is not treated as zero.
• Expected value is not treated as available value.
• Known value can become available.
• An unprivileged actor cannot invoke a financial capability.
• A scoped capital query does not expose raw treasury state.
• An agent can receive a capital decision without full financial context.
• Deployable capital fails closed while liquidity is unknown.
• A growth-capital request is denied while capital is undetermined.
• Observing both liquid balances makes deployable capital calculable.

The evidence does not yet establish a full treasury system. Authorization creation, remaining-balance consumption, expiry, execution-time enforcement, settlement outcomes, reconciliation, and two-agent overcommitment are not demonstrated by those nine tests. The derivation internals behind deployable-capital arithmetic also require direct verification.

The current public manuscript does not yet pin this result to an immutable repository commit. Until a versioned artifact is published with source, test command, and revision identifier, the nine-test result should be read as reported verification rather than a fully reproducible release.

The honest result is smaller than the complete architecture—and strong enough to stand on its own.

These propositions state design consequences under explicit assumptions. They are not presented as new consensus, concurrency-control, or transaction-processing theorems.

The research architecture is functional; the YAP product architecture is how those functions surface publicly. They should not be collapsed into one name.

Human intent
  -> Control Layer coordinates configuration
  -> canonical-state kernel adjudicates
  -> Wallet grants bounded authority
  -> Execution Layer runs locally
  -> external evidence returns
  -> canonical state reconciles

YAP Coin coordinates value across the economy.
The Execution Layer is the local executable.

This mapping preserves the paper's real separation: intelligence proposes, state authorities adjudicate, the Wallet bounds authority, the Execution Layer runs locally, and external evidence determines settlement. No product becomes the whole architecture.

Finance is a proving ground, not the final scope. The same resource-domain primitive can describe compute slots, loading bays, charging capacity, inventory, building access, robot corridors, or airspace cells. Each domain owns only the state and transitions inside its jurisdiction.

ROOT GOVERNANCE
  -> regional or organizational authorities
    -> treasury
    -> compute
    -> energy
    -> warehouse
    -> airspace
      -> local resources and actors

The wrong model is one global database locking the entire world. That would create unacceptable latency, privacy exposure, administrative conflict, and blast radius. WSP instead proposes a federation of local canonical authorities that exchange bounded requests, capabilities, evidence, and unresolved obligations.

An orchestrator may coordinate a plan across a warehouse slot, a power window, a vehicle, and a payment. It does not become the root authority for any of those resources. Each authority grants or denies its own capability. The orchestrator executes only when the required capabilities exist or when explicit compensation is defined.

Intelligence may be ephemeral while consequence remains persistent.

Models can crash, lose context, be replaced, or be upgraded. Money already claimed, a dock already occupied, an obligation still unresolved, and an active capability must survive that substitution. The death of a context window should not constitute an economic or physical event.

WSP assumes that intelligence can be wrong, compromised, manipulated, stale, or unavailable. Safety comes from enforceable boundaries around consequential state rather than from confidence that every model will behave.

• Least authority. A capability contains only the resource, action, quantity, target, purpose, validity window, evidence references, and policy scope required.
• Complete mediation. Every consequential action passes through an enforceable boundary; persuasive reasoning cannot bypass it.
• Fail closed on critical uncertainty. Unknown, disputed, expired, partitioned, or stale state reduces authority rather than becoming permissive by default.
• Separation of duties. Intelligence proposes. Authorities adjudicate. Executors act. Evidence sources report. Reconciliation advances state.
• Expiry, revocation, epochs, and fencing. A correctly signed capability may still be stale. Executors must validate cryptographic authenticity and current authority.
• Minimized disclosure. Agents receive the smallest state projection and credential set required for their role.

The near-term program is concrete. It should expand the verified kernel before making broader performance or deployment claims.

1. Implement and test persisted authorization issuance, consumption, expiry, revocation, and state-version binding.
2. Implement execution-attempt, settlement-success, settlement-failure, and reconciliation events.
3. Test two-agent contention to verify that aggregate grants cannot exceed canonical deployable capital.
4. Verify encumbrance and deployable-capital derivation directly.
5. Compare WSP against direct agent authority, simple spend limits, and per-action human approval under the same failure workloads.
6. Generalize the kernel to at least three independently governed resource domains and test cross-domain partial failure.

The broader thesis makes falsifiable predictions:

• Stronger models will increase demand for external control planes rather than eliminate authority boundaries.
• Persistent resource and settlement state will move outside model context.
• Per-action human approval will become an exception path while people govern policies, budgets, principals, and escalation.
• Large autonomous systems will partition authority by resource, geography, organization, or function, using explicit leases and reservations where resources are scarce and exclusive.

If unrestricted credentials, task-local state, model-context-only memory, and universal per-action approval prove safer and more efficient at scale, the WSP thesis is wrong. The research program is designed to make that failure visible.

Autonomous systems change the unit of interaction between humans and software. Applications receive commands. Agents receive objectives. Objectives become safe consequences only when the system can govern shared state and enforce bounded authority outside the model.

The current implementation demonstrates a modest but meaningful first result: critical uncertainty fails closed, and an agent can receive a capital decision without receiving the treasury that produced it. The full path from authorization through execution, settlement, and reconciliation remains to be built and tested.

The World State Protocol thesis is that this boundary is not unique to money. Wherever autonomous actors compete for finite, consequential resources, intelligence should propose, domain-scoped authorities should adjudicate, executors should mediate, and evidence should reconcile the result.

The world does not need one brain or one database. It needs trustworthy boundaries between what is believed, what is authoritative, and what software is allowed to change.