Overview

What is WAVS?

WAVS is a WASI runtime for building AVSs (Autonomous Verifiable Services). With WAVS, you can create, manage, and operate high-performance AVSs using the languages you already know and love (like Rust—more languages coming soon). By providing a base layer of AVS infrastructure, WAVS lets you focus on implementing the core logic of your service. WAVS compiles that logic to WASM, and lets you deploy it as lightweight service components.

Better yet, WAVS solves the trust problem in off-chain compute: it separates services from the operators that run them. Builders create their components, and operators run them in WAVS runtime at near-native speed. Then, operators sign the results of the off-chain computation and place them on-chain. Boom: off-chain compute with on-chain verifiability.

In simple terms, WAVS streamlines the process of building and managing an AVS.

Finally, WAVS utilizes restaking (via EigenLayer) to secure its AVSs. A service of services, WAVS is composable by nature, allowing an AVS to dynamically run and manage multiple components that work together to build flexible and intelligent applications.

Use cases

WAVS supports a wide range of AVS use cases, enabling powerful, verifiable off-chain computation across different domains:

• Decentralized AI: WAVS unlocks decentralized AI that is deterministic and verifiable, enabling trustless decision-making and autonomous governance through DAO-controlled AI agents.
• Oracles: Create and dynamically deploy new oracles as easily as uploading a component to your service to verifiably bring data from any source on-chain.
• Zero Knowledge Proofs: ZK verifiers, ZK Prover Marketplaces, and ZK aggregation layers can be deployed as lightweight WAVS service components, making it simple to build modular and composable proof services.
• Crosschain Bridges: Build secure, decentralized bridges with WAVS. Lock assets on one chain, trigger a verifiable service component, and mint them on another—all with trust-minimized execution.
• Dynamic applications: WAVS combines on-chain and off-chain services to build a cross-chain, decentralized application layer.
• Intelligent protocols: Build protocols that are verifiably aware of on-chain and off-chain events without relying on centralized infrastructure. Compose services and applications to enable complex webs of decentralized transaction flows.

Building a service

WAVS removes the complexity of building an AVS, making it easy to develop and deploy custom services. With built-in AVS infrastructure and developer tooling, WAVS powers a new multichain ecosystem of composable, decentralized, and verifiable applications.

This example will cover a basic AVS with three parts: a trigger, a service component, and submission logic.

Defining triggers

Triggers are the actions or events that prompt your service to be run. Currently, WAVS supports triggers from on-chain events (with support for cron schedules and off-chain triggers coming soon). On-chain event triggers can be used to pass arbitrary data as the inputs for service components to be run. Operators running a service listen for specific trigger events and run the corresponding service component.

To learn more about triggers, visit the How it works page.

Service components

Service components are the core logic of an AVS. They are written in Rust (with more languages coming soon) and compiled to WASM as lightweight WASI components. WAVS provides a base layer of AVS infrastructure, allowing you to focus solely on the logic of your service.

Service components can contain logic for processing input data from triggers. If an on-chain trigger passes data, a service component can use that data as input. For example, a simple service component could contain logic for receiving a number as input and returning the square of that number as output.

To learn more about service components, visit the How it works page. Check out the WAVS tutorial to learn how to create a service component.

Submission logic

Along with your component, you'll also need to define how the results of your service are submitted on-chain. With WAVS, you can use submission contracts to define this logic.

Run your Service

Once a trigger, a service component, and submission logic are created, you can deploy your service. Operators will then listen for the triggers specified by your service. Once triggered, operators will run your service off-chain, where data from a trigger is passed to a service component and run in a sandboxed WASI environment. Operators sign the result of the service computation and the verified result can be returned as an on-chain response.

With WAVS, service updates are streamlined: updates to services can be made by AVS builders directly without needing to coordinate with operators. Operators only need to upgrade if there is a change to the WAVS node software itself.

Multichain capability

WAVS is built to be multichain. A service can be triggered by events on one chain, run by operators off-chain, and write verified responses to another chain. This interoperability is what makes WAVS so flexible, creating a decentralized computational layer that can function across multiple chains.

Security

The WAVS platform is secured via Ethereum restaking on EigenLayer, which provides a base security layer for AVSs built using WAVS. Restaking refers to the utilization of staked Ethereum to secure AVSs by imposing additional slashing terms on the staked Ethereum for operator misbehavior. In this way, the cryptoeconomic security of Ethereum is extended to WAVS AVSs.

Full-Stack Decentralization

WAVS enables full-stack decentralization by unifying off-chain computation with on-chain verifiability. The chain layer connects to Ethereum and other chains, while the security layer extends cryptoeconomic security via EigenLayer restaking. At the AVS layer, lightweight WAVS powers WASM-based services to process off-chain computations triggered by on-chain events. Operators validate, sign, and commit the results back on-chain, ensuring verifiability and trust-minimized execution. This architecture makes WAVS a scalable, decentralized framework for full-stack applications.

Edit on GitHub