Crypto today is fragmented. Liquidity, users, and state are siloed across networks, forcing each protocol to operate like its own island. Valence has a simple thesis: the endgame must be a single, networked economy where applications can seamlessly access assets and users, regardless of where they originate.
But a thesis is not a product. A vision does not solve real engineering challenges. We need to build the infrastructure we wished already existed.
Why We're Building Valence
Valence exists to solve a problem we know intimately because we've lived it: building applications across multiple blockchains is fundamentally broken.
We learned this firsthand while developing early cross-chain products. Our team built Covenants (a trustless liquidity sharing system) and Rebalancer (an automated treasury management tool). With each attempt, we ran headfirst into the limits of the existing cross-chain development stack:
- Asynchronous Execution: Managing retries, callbacks, and state consistency across networks is a major engineering burden.
- Fragmented Trust: Every chain and bridge has its own security assumptions. Building robust applications on top of this patchwork is risky and error-prone.
- Integration Overhead: Each additional chain, bridge, or protocol adds significant ongoing maintenance costs to the codebase.
- Testing Complexity: Simulating multichain workflows and catching edge cases requires custom QA infrastructure, often a project in its own right.
These are not isolated pain points. They're endemic challenges that every multichain team faces. If crypto is to scale into a truly networked economy, developers can’t continue rebuilding the same fragile infrastructure from scratch.
So we took a step back. Instead of building new applications on shaky ground, we decided to build the foundation.
What is Valence
Valence reduces cross-chain program development into a few core building blocks. These primitives are minimal by design, but together they create a powerful distributed runtime that treats each connected chain as a local compute node. You can think of the “sub program” running on each of these domains as a shard.
The on-chain portion of a Valence program is composed of the following primitives:
1. Authorizations
The Authorization contract is the security gatekeeper. It verifies user intent before any execution occurs by checking configured policies such as allow-lists, time locks, or quotas. Only valid messages are dispatched to the Processor.
2. Processor
The Processor is the execution engine. Each supported domain hosts a Processor contract that executes authorized messages. It supports both atomic execution, where every operation in a batch must succeed or fail together, and non-atomic execution with per-function retries for more fault-tolerant workflows.
3. Functions
Valence exposes modular packages of on-chain business logic as functions. Each handles a single responsibility, like interacting with a bridge, depositing into a lending protocol, or transferring funds between Accounts. Developers can compose workflows from existing functions or write their own to extend the system.
4. Accounts
Accounts are chain-native smart contracts that hold tokens or structured data. Each cross-chain program owns a number of accounts that serve as a consistent, chain-agnostic container for managing assets and state across networks.
Valence programs are created by combining these on-chain primitives with an off-chain strategist. The strategist is responsible for advancing the program’s state machine and synchronizing state between shards. To minimize trust, developers use the Authorizations contract to strictly constrain the authority of the strategist, or any other actor that interacts with the program.
What can you build with Valence?
Initially, we built Valence as internal infrastructure to make cross-chain development easier for ourselves. But we’ve realized that the primitives we designed did more than just solve our pain points. We see a massive latent design space for new decentralized systems and economic structures that simply cannot exist in a single-chain world. This realization prompted a shift in our mission: from building applications to building a platform. We believe the most impactful protocols of the next cycle will be natively cross-chain, and we want to collaborate with top teams to unlock this potential.
Another way to ask what can you build on this platform is asking what our predictions are for the networked economy? Here are a few:
Markets will integrate as cross-chain asymmetries decay
Today’s multi-chain landscape is composed of inefficient, isolated markets. Price and yield discrepancies persist because capital cannot move efficiently to close the gaps. We predict that protocols that perform cross-chain yield arbitrage, automatically routing user deposits from low-yield environments to high-yield ones, or execute complex, multi-leg arbitrage paths will thrive in the coming months.
A concrete example of this is cross-chain vaults. For example, a user could deposit USDC into a vault on a low-fee L2, and the Valence Program would automatically bridge the assets to a different chain, deposit them into a high-yield lending protocol, and manage the position. The entire complex process of bridging, swapping, and depositing is abstracted into a single transaction for the user.
Increasingly composable DeFi and DePIN services
If you think about the multi-chain world today, it's a mess from a systems perspective. It’s a collection of disparate microservices written by different teams with no shared service discovery, no common message bus, and wildly different consensus rules and finality guarantees. One of the underappreciated problems with this is that launching a project requires taking on massive platform risk. Is the L1 I’m launching on going to have users in 2 years? Is the protocol that I’m integrating with going to exist tomorrow? Will I be able to bridge liquid tokens from elsewhere? Valence flips the model. When execution becomes portable and coordination is native, it doesn't matter where you launch. Protocols can evolve beyond local dependencies, composing infrastructure from anywhere, without re-platforming.
Adaptive monetary policy as a core protocol capability
For a protocol to effectively manage its economy, be it a stablecoin, LST, or governance token, it must be able to enact its monetary policy across its entire multichain footprint. Per-chain stability modules are insufficient in a world where users and liquidity move freely.
We have already been guiding teams on interchain peg stabilization programs that monitor prices across chains and automatically execute arbitrage trades to defend a peg. Additionally, we have helped protocols take an active stance in managing the liquidity profile for their tokens across chains by deploying owned liquidity.
Towards A Unified Execution Fabric
Our journey with Valence is just beginning. Over the last couple months, we have been developing an experimental ZK Coprocessor, based on a simple but powerful idea: proofs are the universal interface for trust-minimized computation. This will allow us to shift logic between chains or even off-chain entirely, moving toward a truly chain-agnostic developer experience — write once, deploy anywhere.
The first words we wrote together when we started this project were “tools for longterm, permission-less collaboration.” That spirit still guides us. We are developing Valence in the open and looking for ambitious teams to build alongside us.
If you’re working on internet-native finance, we’d love to build it together.