Skip to content

Products

GPU CloudAMD MI325X and NVIDIA H200 by the hour or on reservation.
Dedicated ClustersPreviewPrivate, interconnected GPU clusters for sustained workloads.
SandboxesPreviewIsolated, short-lived environments for developers and AI agents.
Serverless GPUPreviewGPU containers that scale with requests, down to zero.
Serverless InferenceOpen models behind one OpenAI-compatible endpoint.
Dedicated EndpointsReserved serving capacity for one model, billed per GPU-hour.
PlaygroundSend a prompt to any model your workspace can reach.
Model DeploymentsPreviewImmutable deployments with instant promote and rollback.
Fine-tuningLoRA fine-tunes on the open models in our catalog.
Model TrainingPreviewFoundation-model training runs, managed end to end.
EvaluationsPreviewBenchmark suites and model comparisons you can rerun.
DatasetsManaged and synthetic training data, versioned and ready to use.
Data ManagementPreviewDatasets, connections and storage, with lineage across the platform.
PipelinesPreviewVersioned DAGs that automate data, training and deployment.
Data RoomsPreviewSecure document sharing with guests, NDAs and an audit trail.
NokuvaPreviewThe AI-native design editor.
TavocPreviewA Rust-native code platform: IDE and desktop apps.
FoltracComing soonMulti-cloud deployment with autonomous operations.
W0rkTreeComing soonVersion control for agent fleets.
Identity & AccessMembers, roles, policies, SSO and audit for every workspace.
Billing & CostUsage, invoices, credits and budgets in one place.
Logs & MonitoringRequest logs, latency and error rates across services.
Project CanvasPreviewSee and change a project's resources on one live canvas.

Pages

Home/
Platform/platform
All products/products
Pricing/pricing
GPU pricing/pricing#compute
Inference services/services/inference
Model training services/services/model-training
Protocol design/services/protocol-design
Research partnerships/services/research-partnerships
Protocols/protocols
Datasets/datasets
Documentationdocs.legionedge.ai
Changelog/changelog
News/news
Research/research
Blog/blog
Articles/articles
Events/events
Startup Program/programs/startup
Ambassador Program/programs/ambassador
Partner Program/programs/partner
Event Program/programs/events
Company/company
Careers/careers
Partners/partners
Contact/contact
Statusstatus.legionedge.ai
Terms of Service/legal/terms
Privacy Policy/legal/privacy

Rendering layer

v1.4Stable

Virtual Browser Protocol

A simulated browser that gives models accurate rendering context.

Available for
  • Rust
  • TypeScript
cargo add legion-vbrowser
virtual-browser-protocol.rsRust
use legion_vbrowser::{Session, Viewport};
 
let mut session = Session::new(Viewport::desktop());
let frame = session.render(&vdom_tree)?;
 
// Verify before a human ever sees it
assert!(frame.matches(&expected_layout));
Version
v1.4
Status
Stable
License
Open specification
Implementations
Rust · TypeScript
Stack layer
Rendering

What the spec defines

The guarantees, not the vibes.

  1. Deterministic layout resolution — real boxes without a real browser process

  2. Viewport, scroll, and interaction state expressed as plain data

  3. Verification hooks that compare intended layout against resolved layout

  4. Orders of magnitude cheaper per iteration than driving headless Chrome

Overview

Why it's built this way.

Spec, schemas and conformance suite

The Virtual Browser Protocol defines a simulated browser environment that gives models accurate rendering context — layout, viewport, and interaction state — without the cost of driving a real browser. Rendering resolves deterministically from the document and viewport description, so the same input always produces the same boxes.

That determinism is what makes verification practical. Paired with the Virtual DOM Protocol, it lets Nokuva check every generated interface against its intended layout before a human sees it: the resolved frame either matches or the diff names the node that drifted.

The cost profile is the point. A real browser process per generation iteration is the single largest expense in naive generative-UI pipelines; a protocol-level simulation runs the same check in a fraction of the compute. Less compute per iteration, more iterations per idea.

The spec and the Rust reference implementation are published openly, with TypeScript bindings for web tooling. The verification hooks are the same ones our own canvas uses in production.

Proven in production

If a protocol can't survive contact with a real product, it isn't finished. This one ships inside Nokuva.

Explore Nokuva

Implement it

Implementing the Virtual Browser Protocol?

The conformance suite is public, and the team that wrote the spec reads its issue tracker. Independent implementations are the point.