(SxDx)_Lx + Bsx

This notation is intentionally compact, as Invarians is designed for:

AI agent economies · A2A · On-chain cross-layer · Toward decentralised certification

But it relies on a critical rule: the symbol x does not have the same meaning depending on where it appears.

Understanding this distinction is fundamental.

(SxDx)_Lx — layer-level reading

This expression describes the state of a given layer.

It captures, in a compact form, the relationship between:

• the structure of the system

• the pressure applied to it

A) x in Sx and Dx = regimes

In Sx and Dx, x represents a regime.

For structure:

• S1 → nominal state

• S2 → structural stress

For demand:

• D1 → nominal demand

• D2 → elevated demand

Example:

(S1D2)_L1
→ nominal structure, elevated demand on a layer 1

B) x in Lx = layer type

In Lx, x does not represent a regime.

It defines the type of layer:

• L1 → layer 1

• L2 → layer 2

Example:

(S2D1)_L2
→ structural stress on an L2, with nominal demand

Each layer is observed independently.

For example:

• Ethereum on L1

• its rollups on L2

A system can therefore exhibit different states across layers.

C) x in Bsx = bridge state

Here, x represents the state of the bridge:

• Bs1 → nominal

• Bs2 → tension / instability

Bridges handle transfers between systems:

• L1 ↔ L1

• L1 ↔ L2

But more importantly, they carry:

• constraints

• delays

• systemic risk

A non-ambiguous reading

The full model is expressed as:

(SxDx)_Lx + Bsx

With three distinct meanings for the same symbol:

• x (in S, D) → regimes

• x (in L) → layer type

• x (in Bs) → bridge state

Example

A system state can be described as:

(S1D1)_L1 → nominal L1
(S1D2)_L2 → L2 under demand pressure
Bs1 → stable bridges

Or:

(S2D2)_L1 → compounded stress on L1
(S1D2)_L2 → high demand on L2
Bs2 → bridge tension

Invarians - execution context attestation

Invarians does not return raw metrics.
It returns a structured system regime & state, directly usable by agents.

A single call is sufficient:

GET /attestation/execution-context

A discrete, cross-layer state

proof_of_execution_context {
  l1_regime: "S1D1",
  l2_regime: "S1D2",
  bridge_state: "BS1"
}
signature: "inv_sig_4xKm9zR2pL..."
issued_at: "2026-03-28T14:22:01Z"
expires_at: "2026-03-28T15:22:01Z"

Mapping to the Invarians model

Each field directly maps to:

(SxDx)_Lx + Bsx

l1_regime → (SxDx)_L1

Example:

"S1D1"

• S1 → nominal structure

• D1 → nominal demand

→ L1 operating in a stable state

l2_regime → (SxDx)_L2

Example:

"S1D2"

• S1 → stable structure

• D2 → elevated demand

→ pressure on the L2

Important:

L2 can diverge independently from L1

bridge_state → Bsx

Example:

"BS1"

• BS1 → nominal

• BS2 → tension / instability

→ bridge condition (batch posting, finality, inter-layer latency)

What the AI agent reads with Invarians

The AI agent does not read a blockchain.

It reads:

(S1D1)_L1
(S1D2)_L2
BS1

→ a structural snapshot of the system

Signature and verification (V1 - SDK API)

Each attestation is signed:

HMAC-SHA256

signature: "inv_sig_4xKm9zR2pL..."

It can be verified via:

/verify

Temporal validity

Each state is time-bounded:

• issued_at → time of measurement

• expires_at → validity limit

→ the context is perishable

An agent must always act on fresh state.

Why this structure matters

Everything depends on one rule:

one symbol, three different meanings

If this is ignored:
→ the model becomes inconsistent

If respected:
→ the model becomes precise and actionable

An evolving granularity

Today:

x =1 or 2 for regime or state

But this granularity will evolve:

• S3, D3…

• Bs3…

As the Blockchain Deformation Observatory accumulates data.

Final

Invarians does not simplify blockchains.

It makes them readable for AI agents.

(SxDx)_Lx + Bsx

A minimal abstraction, sufficient to detect system deformation.

A language model without context produces generic responses, sometimes wrong, sometimes absurd. We call it hallucinating. The solution is known: give it context. Documents, history, fresh data. The model improves.

But there is another type of agent. Not an assistant that answers. An agent that acts.

It does not produce text. It executes transactions. It manages funds. It triggers protocols. And it too needs context. A different kind of context. The context of the infrastructure it operates on.

What an agent sees, and what it doesn't

A concrete example.

On Jun 20, 2024, the Arbitrum sequencer went down. For 37 minutes, transactions were no longer processed in normal order. Simultaneously, the basefee on Ethereum reached 1649 times its baseline level.

A rebalancing agent that triggers at that exact moment knows none of this. It observes an asset price, it sees an opportunity, it sends a transaction. The transaction lands in a degraded context: abnormal latency, unpredictable cost, reduced execution guarantees.

The result is not what was expected.

This is not a bug in the agent's logic. It is a decision made without infrastructure context.

The structural problem

Autonomous agents operate on public blockchains. These blockchains are not fixed rails. Their behavior varies: congestion, gas cost, validator activity, bridge state between chains.

These variations are measurable. They are structured. They follow regimes: stable or degraded states, recognizable and classifiable.

But this information is not natively accessible to an agent. There is no standardized interface today that tells it: "Infrastructure is in nominal regime" or "The Arbitrum bridge is degraded, wait."

An experienced human can read the signals. An agent cannot. Not without help.

The hypothesis Invarians is tracking Autonomous agents modify the infrastructure they operate on.

Not individually. At scale. Hundreds of thousands of agentic operations per hour, concentrated on certain chains, at certain moments, produce measurable pressure on execution regimes.

This is a hypothesis. Invarians has been tracking it since March 30, 2026, with live data across five chains: Ethereum, Arbitrum, Base, Optimism, Polygon.

If the hypothesis holds, agentic load is itself a context signal. Agents operating at scale create the deformation that subsequent agents will need to factor into their decisions.

Invarians calls this measure epsilon(t). It is the third primitive under construction, following L1 structural attestation and pattern reference.

What Invarians does Invarians classifies blockchain execution regimes in real time.

For each covered chain: a structural state across two dimensions, at every moment. These states are certified, timestamped, verifiable. Not floating scores. Qualified contexts.

The complete reference frame is L1, L2, and Bridge. The three layers that compose the infrastructure of a multi-chain agent. When all three layers are classified, the agent has a complete view of the environment it is about to act in.

This context can be consumed via API, integrated into an SDK, or exposed directly to agents via MCP.

The gap this fills

An LLM without context hallucinates.

An agent without infrastructure context acts in the dark. It may execute a transaction at the wrong moment, on a degraded network, through a bridge under stress, with costs that match no prior estimate.

This is not a logic error. It is a context error.

Without context, an LLM hallucinates. Without context, an agent destroys value.

Invarians — On-chain Execution Context for Autonomous Agents

invarians.com