DEV Community: Invarians

Securing AI agent actions on blockchain: two complementary models

Invarians — Sat, 11 Apr 2026 17:10:23 +0000

Autonomous AI agents are now acting on-chain. They execute transactions, manage assets, cross bridges. Human oversight can no longer keep pace. The question is no longer whether to govern them, but how.

Two broad categories of solutions exist. They are not in competition. They cover different blind spots.

Knowing what the transaction will do
Before acting irreversibly, an agent needs to test its action without committing it. That is the principle behind pre-execution simulation.

In practice: the transaction is replayed against a copy of the current blockchain state. Assets transferred, gas consumed, emitted logs, potential errors: all visible, without touching mainnet. Developers call this a dry-run. In the agentic context, intent simulation refers to the variant where the agent starts from a high-level intent rather than an already-formatted transaction.

Tenderly and Alchemy have industrialized these techniques. Shadow mode goes further: the agent replays its decisions in parallel with the production system and only switches to real execution after validation. For pipelines running continuously, it is the only serious way to limit risk without slowing down execution.

But there is a limit this approach cannot overcome. It tells you what the transaction will do in a reference context. It says nothing about the actual state of the infrastructure at the moment that transaction will be executed. A perfect simulation result can produce a radically different outcome if the network is degraded.

Knowing what state the chain is in
L1, L2, bridges: none of these layers is a stable substrate. Ethereum can go through severe congestion phases. A sequencer can go down. A bridge can fall behind. These events are rare, but their impact is significant, and they tend to occur precisely when the network is under maximum pressure.

What an agent needs to know before acting is whether the infrastructure is in its nominal state or not. Two dimensions are enough to characterize this: the structural state of the chain and the demand state. Their combination produces a regime matrix, from stable nominal to combined stress. That is the signal agents need to consume upstream, not after the fact.

This measurement does not replace simulation. It precedes it. Simulation tells you what a transaction does. Regime measurement tells you what ground it will actually land on.

Why both are necessary
An agent that simulates without knowing the state of the infrastructure executes on assumptions that may no longer hold. An agent that monitors network state without simulating takes risks on the behavior of its own transactions. Both blind spots are real.

Blockchain infrastructure will be massively agentic in the coming years. That is not a prediction: it is already underway. The real question is with what situational intelligence these agents will operate. Right now, most have none.

How Invarians uses Chainlink to deliver execution context to AI agents

Invarians — Thu, 09 Apr 2026 12:40:10 +0000

Not a binary signal. A structural regime, rhythm, demand, divergence from nominal, across L1, L2, and bridge.

Most on-chain agent infrastructure answers one question: what is the price?

Invarians answers a different one: is the infrastructure ready to execute?

Block rhythm, sequencer health, bridge liveness, these are structural signals that determine whether an agent's decision will land cleanly or into a degraded environment. Price feeds don't carry that information. The RPC doesn't either.

What Invarians actually returns

Invarians classifies each chain into a regime across two axes, structural (τ) and demand (π), producing a signed attestation an agent can consume before acting:

{
"chain": "ethereum",
"regime": "S1D1",
"divergence_index": 0.08,
"oracle_status": "OK",
"bridge_state": "BS1",
"signature": "inv_sig_..."
}

The agent reads the structural regime across L1, L2, and bridge, then routes execution to the layer that best matches its risk parameters. L1 stressed, L2 nominal → prefer L2. Bridge degraded → defer cross-chain.

The Chainlink path

The schema below illustrates a future integration inscribed in Invarians' public roadmap: Chainlink Functions embedding the Invarians algorithm directly inside the DON. Each node computes the regime independently on its own RPC, consensus is reached, and a DON-signed attestation is delivered to the agent inside the CRE.

A context layer agents can query. A methodology the DON can run. A proof the chain can hold.

INVARIANS - We Don't Know What Autonomous Agents Will Do to Blockchains. We're Measuring Anyway.

Invarians — Mon, 06 Apr 2026 20:44:19 +0000

Imagine you want to understand how self-driving cars transform cities, traffic, congestion, how people move. If you wait until they make up a third of all vehicles before you start taking notes, it's too late. The city you wanted to study no longer exists. What's your baseline now?

That's exactly the problem driving us at InvariansLabs. Autonomous agents, trading bots, DeFi protocols, smart wallets, are quietly taking up more and more space on-chain. We study blockchain infrastructure systemically, across L1s, L2s, and the bridges between them. We've been measuring for months to surface how blockchains, rollups, and agents interact, and how each element shapes the whole.

How do we do it? We break down every hour of activity on Ethereum, Polygon, and Arbitrum into simple questions: is the network under structural stress? Is demand elevated or normal? By combining those signals, we've built a reference framework of 32 possible execution scenarios. Every week, we produce a snapshot, not another dashboard, not an alert system. More like a field notebook. A patient, methodical record of what our infrastructure looks like, week after week.

The goal is to watch if the lines move. Are stress regimes becoming more common? Do certain execution patterns only emerge when bots are running the show?
We can't answer that yet, not for lack of tooling, but for lack of time. You need months of archives before a trend becomes visible. We're storing today to understand tomorrow.

Because autonomous agents will need this. To act reliably, they need to know whether the environment they're operating in is nominal or under strain.
Without that context, there's no trustworthy decision-making. And as more agents come on-chain, that question becomes increasingly critical. That's what Invarians is building: making agents aware of the ground they're operating on, and understanding, in the end, what in this system remains invariant.

Blockchains don't break under agentic pressure. They shift.

Invarians — Tue, 31 Mar 2026 15:25:24 +0000

Rheology studies how materials behave under sustained stress, creep, yield, structural shift. Invarians applies this framework to blockchain infrastructure.
The working hypothesis: as autonomous agents accumulate on-chain load, execution regimes don't break, they migrate. Progressively. Structurally.
Since March 17, Labs has been tracking regime baselines across 6 L1×L2 pairs, updated hourly. Early observation on ETH × Optimism: 23% of windows already register S1D2, elevated demand pressure against a stable structural state. Correlation noted. Causality withheld.
The reference frame will expand to L1 × L2 × Bridge once bridge calibration is complete.
Two primitives are currently exposed to autonomous agents: On-chain Execution Context and Pattern Reference. A third is in development ε(t), a continuous measure of structural deformation as a function of agentic load over time.
If the hypothesis holds, ε(t) will be the first quantitative signal of how agents reshape the infrastructure they depend on.
Baselines are being recorded now. They cannot be reconstructed retroactively.
→ labs.invarians.com

blockchain #autonomousagents #infrastructure #web3 #onchain #agentic #ethereum

Your blockchain agent knows what a transaction costs. It doesn't know the conditions it runs in.

Invarians — Tue, 24 Mar 2026 14:29:26 +0000

Start with a simple image.
A pilot has access to global weather data.
Temperature. Pressure. Wind at altitude.

But before takeoff, they review a specific briefing — for their route, their time, their altitude.

Not because the data doesn't exist.
Because they need a certified, consumable synthesis at the right moment.

Autonomous blockchain agents don't have that briefing yet.

*What changed in March 2024
*
On March 13, 2024, Ethereum deployed EIP-4844 — the "Dencun" upgrade.

L2 networks (Arbitrum, Base, Optimism...) now post their batch data to Ethereum via blobs, a separate fee market that doesn't flow through L1 basefee.

The immediate and permanent consequence:

An incident on an L2 network no longer produces any economic signature on Ethereum L1.

Gas can be perfectly stable while a sequencer is backing up.
While a bridge hasn't posted a batch in 30 minutes.
While an L2 is structurally degraded.

Fee monitors watch L1. They see nothing.

## "But didn't the upgrades after Dencun fix that?"

Good question — I hear this often.

Yes, Ethereum kept evolving after Dencun. More blobs available, better scalability, lower fees.

These improvements are real.

But they answer a different question.

More blobs = L2 cheaper and faster. ✓
More blobs = you know what state the L2 is in when you execute. ✗

The structural decoupling between L1 and L2 introduced by EIP-4844 is not fixed by increased capacity. A sequencer can go down tomorrow — Ethereum L1 still won't see it in its basefee.

## "There are already monitoring tools — Alchemy, Tenderly..."

Absolutely. And they're excellent.

But they're built for a human to react.

A dashboard showing Arbitrum has a backlog, useful for an on-call engineer.

An autonomous agent needs something different: a certified state, cryptographically signed, consumable in a single API call, before execution.

These are two different products for two different use cases.

## What your agent sees. What it doesn't.

A well-built agent today has:

✅ Token price
✅ Gas cost
✅ Smart contract state
✅ Available liquidity

What it doesn't have in certified programmable form:

❌ L1 structural state — is the chain within its historical norms?
❌ Target L2 state — saturated? structurally slow?
❌ Bridge state — are batches being posted normally?

This information didn't exist in agent-consumable form.

## A real example. Not a hypothesis.

June 20, 2024. Arbitrum.

The sequencer stopped posting batches for 37 minutes from 16:47 to 17:24 UTC.

Ethereum L1 during this time: perfectly normal. Stable gas. Zero alert on any fee monitor.

An agent executing a cross-chain transfer in this window: transaction accepted on L2, settlement blocked on L1, collateral unavailable.

No warning signal available anywhere — unless you were directly measuring bridge state.

## The cost isn't dramatic. It's silent.

This isn't a hack. It isn't a hard failure.

It's a gap that accumulates on every execution in suboptimal conditions:

Real cost = volume × frequency × time in degraded conditions × execution quality gap

The gas price tells you what a transaction costs.
It doesn't tell you what conditions it runs in.

## What changes — concretely

  # Today — 2-variable model
  if gas_price < threshold:
      execute()

  # With certified infrastructure state
  context = invarians.attest("arbitrum")

  if context["execution_window"] == "EXECUTE":
      execute()
  elif context["execution_window"] == "REROUTE_L2":
      execute_on_l1()
  else:
      defer()

One additional call.
The agent moves from a price+gas model to one that incorporates actual infrastructure state.

The response is Ed25519-signed, timestamped, expires after one hour.
It can be stored directly in the agent's decision log as cryptographic proof of execution context.

The four infrastructure states

Invarians classifies each chain into four states — independently on L1 and L2.

S1D1 — structural: normal, demand: normal
Optimal conditions. Both layers within historical baseline.

S1D2 — structural: normal, demand: elevated
High activity period. Structure holding, fees and competition elevated.

S2D1 — structural: stressed, demand: normal
The critical case. Structural degradation with no fee signal. A fee monitor reads this as S1D1 — completely invisible to gas-based monitoring.

S2D2 — structural: stressed, demand: elevated
Both dimensions degraded simultaneously.

S2D1 is the reason this matters. Structural stress without demand pressure leaves no trace in gas prices. Every existing fee-based tool misses it entirely.

*Why this becomes structural
*
Today: a few thousand autonomous agents active on-chain.

In the coming years: potentially millions, intent solvers, DeFi agents, RWA protocols, automated liquidators.

If these agents have no awareness of infrastructure state, a local incident amplifies. Every agent keeps sending transactions to a degraded chain. Congestion increases.
Uncoordinated behavior becomes a systemic risk factor in itself.

This isn't a prediction. It's network mechanics.

*The analogy that sums it up
*
Before ERC-20, every protocol handled its tokens differently.
After ERC-20: obvious standard. Composable. Interoperable.
Obvious in hindsight.

Certified infrastructure state for agentic execution follows the same logic.
Not one more tool.
The missing layer that lets agents know what they're executing on.

Monitoring tools exist. They're built for humans.

Alchemy tells you if your RPC endpoint is up.
Tenderly lets you simulate and trace transactions.
Etherscan shows you historical on-chain data.

None of them produce a signed, agent-consumable attestation of infrastructure state at execution time.

That's the gap.

Invarians / On-Chain Execution Context