Introducing Railnet: the open yield layer for programmable asset management
Despite an explosion in adoption and institutional acceptance, more than 280 billion dollars in stablecoins today sit idle, generating no yield at all. Trillions more in tokenized assets including stocks and private credit are moving onchain without the proper infrastructure. Opportunities for yield are growing yet capital stays siloed, unable to truly benefit from DeFi rails.
The problem isn’t that there aren’t yield sources at all. DeFi lending protocols, liquid staking, tokenized treasuries and other sources of onchain yield are proven and growing. The issue for asset managers is that they are fundamentally disconnected.
Different interfaces. Different settlement times. Different operational and compliance requirements.
For example:
- A lending protocol settles instantly.
- A tokenized bond fund takes days of KYC and regulatory processing.
- An RWA investment relies on complex offchain workflows that most DeFi infrastructure was never designed to handle.
For asset managers, this creates an impossible choice. Either specialize in a narrow set of protocols and accept commoditization, or rebuild infrastructure from scratch for every new yield source. Each integration becomes months of custom development, operational work, and bespoke risk handling.
This is where Railnet comes in.
Why we're building Railnet
At Kiln, we have been powering yield infrastructure for institutions since 2018. In 2025, we passed 18 billion dollars in assets, serving clients like VanEck, Crypto.com, Ledger, and Binance US. We see both sides of the market:
- Platforms and wallets that want simple access to yield for thousands of users.
- Institutions that want to launch sophisticated, multi-venue strategies with real risk controls.
Most of all, we saw regulated asset managers trying to enter the space. Their clients were asking for onchain exposure. The strategies made sense. But the infrastructure did not.
The conversations were consistent:
“We cannot rebuild our stack for every protocol.”
“We need compliance and auditability across everything.”
“We need to support asynchronous flows and complex settlement timelines.”
“We need something that actually works at institutional scale.”
Demand existed. Yield sources existed. What did not exist was standardized infrastructure to connect them.
How Railnet works
Railnet standardizes capital deployment through STEAM – the State Transition Engine for Asset Management.
Instead of forcing all operations into the same rigid flow, STEAM models capital movements as state transitions. Every operation, whether instant or multi-day, is expressed as a "query" that progresses through a standardized lifecycle.
When you deposit ETH into a lending protocol, the query moves through creation, acceptance, processing, and settlement atomically. One transaction.
When you request exposure to tokenized U.S. Treasury bonds, the same query interface handles something fundamentally different. The query enters a pending state until KYC completes. Once approved, funds transfer and processing begins. Days later, when the underlying bond settles, the query completes.
Different timelines, different requirements – same standard framework.
Vehicles: making everything composable
The practical implementation comes through Vehicles – smart contracts that implement STEAM for specific protocols or strategies.
Each Vehicle wraps a yield source and exposes the standardized query interface. One Vehicle handles Compound's lending. Another manages a tokenized treasury with KYC requirements. A third handles liquid staking. The complexity lives within each Vehicle, but the framework stays consistent.
This creates real composability. When you build a strategy, you compose Vehicles without writing custom integration code. Want to allocate between DeFi lending, staking, and tokenized treasuries? Three Vehicles, one standard.
The network effects compound. Build one Vehicle, and it's instantly accessible to every strategy on Railnet. Build one strategy, and it can immediately access every integrated protocol.
We distinguish between two types:
Yield source vehicles adapt external protocols to STEAM. They handle all the protocol-specific logic while exposing the standard interface.
Operational vehicles orchestrate capital between yield sources. They focus purely on strategy logic – risk management, yield optimization, rebalancing – while delegating protocol interactions to Yield source vehicles.
This separation creates flexibility. Market conditions change? Swap one yield source for another. Want to combine DeFi, staking, and RWAs? Compose Vehicles without custom development.
An open standard, not a walled garden
The protocol is open and permissionless. Protocols build Vehicles to access institutional capital. Asset managers compose strategies without rebuilding infrastructure for each integration. Platforms integrate and distribute to their users.
Kiln is building Railnet, but we're one participant in the ecosystem, not the gatekeeper. The value of standardization only works if it's truly open – which means anyone can build on it, extend it, and benefit from it.
Railnet is set to launch in Q1 2026
We'll be launching with strong support from leading institutions and protocols – including Ondo Finance, Sentora, Chainlink, Safe, and Ethena with more on the way.
Railnet is currently in sandbox on Base, with expansion planned to Ethereum, BNB Chain, Optimism, Arbitrum, and Polygon. Security audits from Spearbit and Trail of Bits will complete before mainnet launch in Q1 2026.
We're building the infrastructure for a new era of asset management – where capital formation and distribution happen onchain, where yield becomes composable and programmable, where institutions can launch strategies in days instead of quarters.
The open yield layer for programmable asset management starts here.
Ready to build on Railnet? Discover more on railnet.org.
