Two parties exchange value instantly — no consensus, no waiting. The net settles through a shared DAG layer in under a second. Stablecoin gas. Fixed fees. Built for humans and autonomous agents alike.
How It Works
Both parties sign every state update. Transfers backed by locked funds. Netting compresses thousands of operations into one settlement.
DAG consensus with permissionless validators. Leaderless — no single sequencer. Settlement batches, MEV-free clearing, force-settlement adjudication.
$1M gross volume nets to $50. Root sees $50. The rest stays private.
Why Not a Blockchain?
Alice sends Bob $5. 1,000 validators vote on it. Why?
Single ordering = extraction. It's structural, not a bug.
Chain succeeds → token rises → gas rises. Users lose.
Technology
$0.002 whether FRS is $1 or $1,000. The chain's success never makes it harder to use.
Batch clearing at uniform price. Ordering is irrelevant. Front-running is structurally impossible.
Leaderless. No single sequencer. Optimistic in 50ms. BFT final in 900ms. Formal proofs completed.
Protocol-level CLOB. Price-time priority. Sub-ms order management via edges. Not a smart contract.
| Ethereum | Solana | Base | Ferros | |
|---|---|---|---|---|
| Transfer cost | $0.50 – $5 | ~$0.00025 | $0.001 – $0.01 | $0.002 fixed |
| Predictable? | No | No | Mostly | Always |
| Congestion spikes | 100x+ | 400x | 10x+ | None |
| Finality | ~12 min | ~400ms | ~7 days | <1ms edge |
| MEV | Structural | Structural | Structural | Eliminated |
| Token for gas? | ETH | SOL | ETH | No |
Scale
Every new edge adds capacity. There is no ceiling.
Agent Native
Fast enough for real-time multi-agent coordination and x402 payments.
$100/day limit enforced by the protocol. Not the software. Not the agent.
Set rules. Go offline. The protocol executes. Your agent doesn't need 100% uptime.
$0.002. No auctions. No surprises. Budget a year in advance.
// Connect. Transfer. Delegate. Done.
let ferros = Ferros::connect(rpc).await?;
let edge = ferros.open_edge(counterparty).await?;
// Instant. <1ms. Both signed.
edge.transfer(USDC, 100_000_000).await?;
// Sub-agent: $100/tx, $1K/day, transfers only
edge.delegate(DelegationScope {
delegate: sub_agent_key,
max_per_tx: 100_000_000,
max_daily: 1_000_000_000,
allowed_ops: vec![Transfer],
}).await?;Cudo Lang
Solidity doesn't know what contention is. Cudo does. The compiler verifies it. The infrastructure routes automatically. No manual sharding. No choosing an L2. Reentrancy, double-spends, and resource leaks are killed at compile time.
contract LendingPool {
contention: per<address> // each borrower runs in parallel
state {
deposits: Map<Address, u64>,
borrows: Map<Address, Borrow>,
}
op deposit(amount: Reference6) {
transfer(caller, self, amount); // protocol intrinsic
deposits[caller] += amount;
}
op borrow(amount: Reference6, collateral: Reference6) {
require(collateral >= amount * 150 / 100);
transfer(caller, self, collateral);
transfer(self, caller, amount);
}
}per<address> = 10,000 borrowers, 10,000-way parallelism. Zero lock contention.
Economics
Per transfer. In USDC. Fixed forever. No token volatility. No gas auctions. Budget a year in advance.
of all fees go to stakers. Real revenue. Not inflation. Zero token minting. Supply only goes down.
The protocol is live. The network is next.