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

Context layer

v1.2Stable

W0rkTree Protocol

Efficient source control and context management for agent-driven development.

Available for
  • Rust
  • Python
cargo add w0rktree
w0rktree-protocol.rsRust
use w0rktree::Repo;
 
let repo = Repo::open(".")?;
 
// Sub-millisecond snapshot, scoped to the task
let view = repo.snapshot()?.scope(task.paths());
 
assert!(view.read_ratio() < 0.02);
Version
v1.2
Status
Stable
License
GPL 3.0
Implementations
Rust · Python
Stack layer
Context

What the spec defines

The guarantees, not the vibes.

  1. Copy-on-write snapshots — working trees in under a millisecond

  2. Scoped context views — a task reads under 2% of the repository

  3. Optimistic merge queues instead of locks under agent contention

  4. Branching that stays cheap at thousand-agent fleet scale

Overview

Why it's built this way.

Spec, schemas and conformance suite

The W0rkTree Protocol defines efficient source control and context management for agent-driven development. Conventional version control assumes a small number of careful writers; an agent fleet is thousands of concurrent workers making small, disposable changes. The protocol is built for the second workload.

Snapshots are the primitive: an agent gets a copy-on-write view that costs kilobytes to create and nothing to discard. Scoped context views serve just the files a task touches — under 2% of the repository on typical tasks — and expose that scoping to the model layer so prompts stay small too.

Contention is handled with optimistic merge queues rather than locks. Agents work on disjoint scopes most of the time, so conflicting writes are rare; letting them proceed and reconciling at merge time is the same bet that makes multi-version databases fast.

The Rust core is open source under GPL 3.0 — the same code that manages context across Tavoc and our internal tooling — and the protocol spec ships with a conformance suite for independent implementations.

Proven in production

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

Explore Tavoc

Implement it

Implementing the W0rkTree Protocol?

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