TL;DR:

Problem: High training costs stall research iteration. Post-training a 30B model costs thousands per run on standard clouds.
Solution: Echo-2 decouples centralized learning from distributed rollouts, using async RL with bounded staleness to orchestrate distributed, unreliable GPUs.
Performance:
- Cost: Reduced from $4,490 to $425 (10.6x research throughput).
- Velocity: Completed in 9.5 hours, exceeding traditional cloud speeds.
- Future: Roadmap to further reduce training cost by 40-50% with potential low precision training and rollout quantization.
Impact: With significantly higher research throughput under same budget, researchers and teams can run sweep after sweep instead of betting on a single run.
Availability: RL-as-a-Service (Logits) waitlist opening for students and researchers.

Reinforcement learning (RL) has become the primary engine for post-training frontier models. From OpenAI o1 to DeepSeek-R1, the next leap in model intelligence comes from teaching models to think, verify, and iterate—rather than just feeding them more internet text.

But today, the pace of AI research is capped by the cost of failure.

To solve complex reasoning tasks, researchers need to run massive ablation studies, tune reward functions, and explore edge cases. Post-training a 30B model on current commercial platforms can cost thousands. For a 600B model, costs exceed $100K. Research teams are forced to pick safe experiments instead of the right ones, keeping serious RL work concentrated in a handful of well-funded labs.

We built Echo-2 to change that.

Echo-2 is a distributed RL framework that fundamentally changes the physics of training. By separating centralized learning from distributed rollout generation, we offload the sampling phase—which accounts for 80% of RL compute time—to cheaper, geographically distributed resources.

The barrier isn't algorithmic; it's infrastructure. Echo-2 removes that barrier.

Headline Results: 10.6x Research Throughput with Echo-2

To prove Echo-2's efficiency, we benchmarked the training of a Qwen3-30B-A3B model on the DAPO-17k dataset. We ran the exact same training job across three different platforms to compare cost and velocity directly.

Echo-2 Setup:

Learner: 4×H200
Actors: Dynamic orchestration of distributed, unreliable H200s

The Results:

Platform	Training Time	Total Cost	Speed Factor	Cost Factor
Fireworks	124h	$4,490	1.0x	10.6x
Tinker	23.5h	$1,122	5.3x	2.6x
Echo-2	9.5h	$425	13.0x	1.0x

Convergence Without Compromise

While the table demonstrates over 10x economic efficiency, the plot above validates algorithmic fidelity. In distributed learning, cost reduction often leads to instability or divergence caused by spotty hardware and naive orchestration.

Echo-2 eliminates this trade-off. By rigorously managing bounded staleness, the system mirrors the learning dynamics of the expensive Fireworks baseline. The reward trajectories are statistically indistinguishable, confirming that our asynchronous architecture introduces zero performance degradation.

We have demonstrated that enterprise-grade convergence is achievable on unreliable compute, proving that the primary barrier to accessible RL is not hardware quality, but architecture.

How It Works

Echo-2 solves four core infrastructure problems to make distributed RL not only feasible but ultra-efficient:

1. Async RL with Bounded Staleness

Traditional RL runs in lockstep: publish policy → wait for rollouts → train → repeat. This creates constant idle time.

Echo-2 breaks this coupling. Rollout generation, policy dissemination, and training proceed asynchronously. Actors generate rollouts under whatever policy version they currently have. The learner consumes any rollouts within a staleness budget S (typically 3-6 training steps behind).

Key insight: We treat staleness as a control parameter, not a bug. For modern RL objectives like GRPO, moderate staleness doesn't degrade training quality, it buys system efficiency. This converts a hard synchronization constraint into a capacity planning problem.

2. Lattica: Peer-to-Peer Neural Broadcast

Getting 60+ GB model weights to hundreds of distributed actors is a massive bottleneck. Naive HTTP downloads grow linearly with fleet size.

We leveraged Lattica, a peer-to-peer communication protocol released earlier, where the learner streams model chunks to "seed" actors, who then forward them to others in a tree structure.

Effect: Dissemination time grows logarithmically, not linearly. For our 30B benchmarks with 24 actors, this reduced tail latency from ~25 minutes to ~14 minutes.

3. Three-Plane Modular Architecture

Echo-2 decouples algorithm, task, and infrastructure into independent planes:

Rollout Plane: Distributed actors generate (prompt, response, reward, version) tuples
Learning Plane: Centralized learner consumes versioned trajectories and updates policy
Data Plane: Task adapters define prompts, rewards, and training signals

With Echo-2’s modular design, switching training tasks becomes a configuration change, instead of a code rewrite.

4. Software-Defined Resilience on Volatile Compute

Roughly 80% of RL wall-clock time is spent on rollout generation: inference-only forward passes that are embarrassingly parallel and latency-tolerant. While traditional RL is fragile and halts if a single node fails, forcing researchers to rent expensive "bulletproof" clusters, Echo-2 is designed to thrive on chaos.

Echo-2 treats H200 clusters, consumer 5090s, and other idle instances as a single logical compute mesh. By utilizing efficient Asynchronous RL with bounded staleness, we can orchestrate these distributed, unreliable GPUs—hardware that is significantly cheaper because it lacks guaranteed availability. When a node drops out or prices shift, the scheduler automatically reroutes tasks and adjusts the mix. This allows us to convert raw, volatile compute power into stable, enterprise-grade training throughput.

Stress Testing Echo-2

To verify Echo-2’s ability to handle distributed, heterogeneous hardware, we ran an internal validation using consumer-grade GPUs via Parallax.

Task: AIME24 mathematical reasoning (Models: Qwen3-4B and Qwen3-8B).
Setup: 4×A100 centralized learner, distributed RTX 5090 rollout actors.

Results (Qwen3-8B across 5 benchmarks):

Benchmark	verl (centralized)	Echo-2 (S=3)
AIME24 (avg@64)	47.92	48.80
OmniMath (Pass@1)	41.92	40.31
JEE (avg@8)	32.31	39.51
HardMath (Pass@1)	25.33	26.87
IMO-A (Pass@1)	29.00	23.25
Mean	35.30	35.75

Echo-2 achieved a 33-36% cost reduction compared to a centralized 8×A100 baseline while maintaining comparable scores across 5 math benchmarks.

Staleness tolerance varies by task. For math reasoning, S=3-6 works reliably. At S=11, we observed complete divergence. Default conservatively (S=3-4) and increase only with empirical validation.

Agentic Tests:

Beyond the 8B model training run, we observed the same ~35% cost savings when training Qwen3-4B. We also pushed the framework beyond static math problems to interactive domains, successfully training a Qwen3-0.6B agent to outperform LLM opponents in No-Limit Texas Hold'em. From scaling model sizes down to 0.6B to handling complex game theory, Echo-2 proved that unreliable compute can deliver reliable, reproducible research results.

For full implementation details and more benchmarks, read Echo-2 paper: arXiv:2602.02192

What's Next: Train on Logits

Echo-2 proves that research velocity is no longer capped by budget. If a training run drops from $4,490 to $425, you can run ten times more experiments. You take more risks, and iterate faster.

We are now bringing this infrastructure to production with Logits, the first RL-as-a-Service platform.

Logits abstracts away the complexity of distributed orchestration, offering:

Managed Infrastructure: Seamlessly handle centralized learners and distributed rollout fleets.
Global Scale: Integration with Parallax to tap into global inference capacity.
Model Ownership: Stop renting intelligence through APIs. Fine-tune open models on your proprietary data and own the weights.

The Logits waitlist is now open to university students and researchers.

👉

Join the waitlist: logits.dev