colibri.stateless Production Release

The first fully stateless client for Ethereum and other Blockchains is released as production-ready. With a footprint of about 200kB, it is by far the smallest Ethereum client, able to fully verify all information locally without any trust assumptions.

TL;DR

Colibri.stateless brings trustless blockchain data to applications without running a full node. It verifies all data using consensus and execution proofs, eliminating reliance on RPC trust.
The production release supports Ethereum, with Gnosis, Optimism, and Base available as MVPs. The client works across mobile, web, and embedded environments and includes a verifier, a prover service, provider mode, bindings, a CLI, and documentation. It enables applications, wallets, agents, and IoT systems to use verified blockchain data in real time.

Context: Data Access in dApps

Applications in Web3 depend on blockchain data for every interaction. They read balances, contract state, storage values, logs, and execution results to drive their logic. This data flow defines how the application behaves and determines every on-chain action.

Most environments do not run full nodes. For now, it is common to rely on remote RPC endpoints for all reads, because devices and applications operate without local chain state. Wallets, DeFi platforms, and other application layers depend on the correctness of these responses. All of them need local validation to ensure that the received data reflects the actual chain state.

When a remote endpoint delivers altered or incomplete information, the application cannot detect it. This affects regular interfaces, contract dashboards, automated systems, and signature flows.

For autonomous agents and IoT systems, this issue is even more critical. These systems act on data without human review. Without verifiable data, the entire workflow depends on trust assumptions.

This gap motivated the development of stateless verification and the design of the first and smallest Ethereum Stateless Client, colibri.stateless.

Stateless Clients

A stateless client verifies blockchain data without keeping a local copy of the chain. Instead of syncing blocks or storing historical state, the client requests proofs for the data it has fetched. These proofs contain the information required to validate the consensus and state.

Consensus proofs enable the client to verify that the active sync committee signs a block and that the block is part of the canonical blockchain. This can be achieved through a chain of proofs for correct validator committee transitions, or it can be effectively summarized in a zero-knowledge proof.

Execution proofs provide Merkle proofs for account data, storage entries, and other execution-layer values. The client verifies these proofs locally and confirms that the data originates from a valid block.

With both proofs, a stateless client achieves the trust level of a full node or light client for the requested data, without holding chain state, performing full execution, or even syncing block headers or light client updates.

This creates a verifiable data path for applications on mobile devices, browsers, and embedded systems.

Need for Trustless Data

Blockchain execution is trustless, but the data paths of most applications are not. When an application receives data from an RPC endpoint, the information arrives without local validation.

This creates a single point of failure. If the endpoint provides altered balances, wrong contract state, or misleading execution data, the application cannot detect the discrepancy.

The impact grows when systems act autonomously. IoT devices, agents, and automated workflows rely on input data to trigger actions. Without verifiable data, these systems have no reliable foundation.

Trustless data access removes this dependency. Local verification ensures that all information used by the application matches the current state of the chain.

The direction aligns perfectly with the ideas in the Trustless Manifesto. The document is backed by the Ethereum Foundation and contributors, including Vitalik Buterin, and promotes direct verification as the basis for secure interaction with blockchains. Join this movement by signing the manifesto, too.

Overview colibri.stateless

Colibri.stateless verifies blockchain data using proofs rather than relying on remote endpoints. The client validates consensus information via sync-committee signatures and verifies execution data via Merkle proofs, as described above.

The system uses a modular architecture. The verifier always runs locally and checks all proofs. Proofs can be created locally or provided by a trustless proof provider. Such a proof service provides proofs on demand and improves performance by offloading proof generation without introducing new trust, since the verifier checks every proof locally.

The client has a tiny footprint and does not store chain state nor synchronize any block information. It works in mobile devices, browsers, and embedded systems as well. The design fits environments with limited bandwidth, limited memory, and intermittent connectivity.

Bindings to C/C++, JavaScript/TypeScript (WASM), Python, Kotlin/Java, Swift, and more are in development and will be released soon, and APIs allow integration with various application stacks. The client can provide verified data to wallets, dApps, agents, IoT devices, and any system that needs reliable chain information.

Release Contents

The production release of colibri.stateless delivers a complete verification stack for consensus and execution data. The release includes:

• Ethereum support in production.
  Additional L1 and L2 networks, such as Gnosis and Optimism, are available as MVP implementations but not yet released for production.
• Verification performed through a combination of consensus proofs and execution proofs.
• A local prover and a prover service that generate proofs for headers, accounts, storage entries, and other chain data.
• A provider mode that applications and wallets can use as a replacement for trusted RPC endpoints.
• Bindings for multiple languages and environments.
• A CLI for creating and verifying proofs during development and testing.
• Documentation covering architecture, specification, and integration steps.
• Build tools for desktop, mobile, and embedded targets.

Usage and Participation

Colibri.stateless can serve as a verification layer in applications, wallets, AI Agents, IoT devices, and services. The client replaces trusted RPC calls with locally verified data. The workflow stays the same, but every data point is checked through proofs.

Developers can install the client, run the prover service, or connect to an external prover. The verifier checks every proof, so the setup introduces no new trust. (see developer guide)

The repository is open. Contributions are welcome in proof generation, verifier logic, performance improvements, new bindings, and support for additional chains.

Projects can integrate colibri.stateless to ensure that all reads from the chain are verified before use.

Next Steps

Further development focuses on broader chain support, more efficient proof systems, and deeper integration into constrained environments. Upcoming work includes:

• Support for additional EVM chains.
• Optimized consensus proofs and recursive proof aggregation.
• Integration solutions for IoT systems with intermittent connectivity.
• API extensions for autonomous agents and automated workflows.

These steps expand the use cases of colibri.stateless and extend the reach of verifiable blockchain data.

For more information about** colibri.stateless** , and how to use it or to contribute, visit our website or follow us on social media (x ,telegram ,LinkedIn ).

---

colibri.stateless Production Release was originally published in Corpus.Core Insights on Medium, where people are continuing the conversation by highlighting and responding to this story.