Skip to content
Open Frontier Labs mark: a glowing green arc over a road that leads to a star
Run 0 is formingRead the manifesto

Open infrastructure for collective frontier intelligence.

Open compute. Open training. Open weights.

A community lab building fully open models on pooled, distributed community compute. Data, code, recipes, checkpoints, logs and weights, all public. Early stage: nothing has been trained yet.

  • 1Contributors on GitHub, 2 on the waitlist
  • 0GPUs in network
  • Run 0Forming
  • 0Open artifacts

The open frontier

A more open foundation for frontier AI.

Community-driven infrastructure to train and advance world-class models in public, with every step logged and every result shared. None of it is built yet.

Open Compute

Pool GPUs from many contributors and donated clusters into one training fabric.

Open Training

DiLoCo-style pretraining and asynchronous RL with open tools, open data and open recipes.

Open Weights

Every checkpoint and the final weights are planned for release under Apache-2.0.

Heterogeneous Participation

Planned: big nodes for pretraining, and any GPU for evals and RL rollouts.

Manifesto

The Open Frontier Manifesto

Frontier intelligence is the most important technology of our lifetime, and right now a handful of companies own it. They train on all of us: our writing, our code, our questions, our art. Then they lock the result behind an API and call it safety.

We think there's a better way. We think the frontier should belong to the people who built it.

We build in the open, all of it. Not just the weights. We publish the data, the code, the recipes, the training logs and every checkpoint along the way. If you can't reproduce it, it isn't open, and if it isn't open, nobody can check what it does.

We train together. No one of us has a datacenter, but all of us together might. A gaming PC in Osaka, a lab cluster in São Paulo and a spare GPU in a dorm in Lagos all count, and they all add up. Every machine that joins makes the run faster, and every person who joins makes the model theirs too.

We show our work, including the failures. We'll publish every loss spike, every bad run and every dead end, in public, as it happens. We will never fake a number to look bigger than we are. Today we're just getting started: Run 0 is forming, and you can see exactly where it stands.

We share the credit. Every contributor of compute, code, data or evals is named in the ledger. What we build together belongs to everyone, released under licenses that keep it that way.

We do this because we care. Not for an exit or a moat. We do it because we want to understand these systems, because we think humanity's most powerful tools should be inspectable, and because building something enormous with thousands of strangers is one of the best things people can do.

OpenAI was supposed to be this. We'll be it instead.

Frontier intelligence. Built together.

Bring a GPU. Bring an idea. Bring yourself.

The manifesto on its own page

How it works

From idle compute to open frontier models.

Islands of GPUs train locally for many steps, then sync compressed updates rarely. Slow links cost little, and nodes can join or leave without stopping the run. This is the design; none of it has run yet.

  1. Your Idle Compute

    A spare machine or GPU, offered to a run.

  2. Distributed Training Network

    Islands will join through a small coordinator and object storage.

  3. Shared Checkpoints

    Every checkpoint will be published as the run goes.

  4. Open Models

    Final weights will be open for anyone to use, build on and improve.

  5. Public Evidence

    Configs, logs and a credit ledger will be open to check.

Try it today

Don't take our word for it. Run it.

The scaffolding is real. Clone the repo and the smoke test trains a tiny model with the pinned OLMo-core trainer, then runs a reference DiLoCo across two workers. CPU only, no GPU needed.

openfrontier
# clone, then everything is a make target$ git clone https://github.com/OpenFrontierLabs/openfrontier$ cd openfrontier$ make setup   # uv sync from uv.lock$ make doctor  # GPU, CUDA, network, disk, clock$ make smoke   # tiny OLMo-core run, then DiLoCo$ uv run ofl run0 launch --dry-run# prints the real Run 0 command$

Works today

  • CPU smoke run of the pinned OLMo-core trainer
  • Reference DiLoCo on two CPU workers
  • Run 0 launcher, config and pinned upstreams
  • A doctor that checks your node

Not built yet

  • Joining a shared training run
  • Coordinator and node agent
  • Dropping updates that hurt the loss
  • Any trained checkpoint or weights
What works and what does not

The stack

Eight layers, from your GPU to open models.

Today only part of the web platform is live: sign-up and the waitlist. Every other layer is planned.

  1. 8

    Outputs

    Open models, open weights, open checkpoints, open datasets, open research and open training evidence.

    Planned
  2. 7

    Hosting

    Cloudflare Workers and D1 for the site and app; Durable Objects, R2, regional relay VPSs and Hugging Face publishing come later. The website can be centralized; the training network should not be.

    Planned
  3. 6

    Web platform

    This site. Sign-up with GitHub, the waitlist and its questionnaire, the contributor workspace and the Operator Console's Review Queue work today; node, run and receipt data wait for the Node app.

    Live, partly
  4. 5

    Storage and evidence

    safetensors with manifests, public checkpoints, dataset shards, evidence receipts and an audit trail, on Hugging Face and mirrors.

    Planned
  5. 4

    Training engine

    Mode A: DiLoCo-style async data parallel with compressed, low-bandwidth sync. Mode B: sharded training with stage placement and elastic recovery. Only a CPU smoke test exists today.

    Planned
  6. 3

    Decentralized network

    rust-libp2p over QUIC/TCP: bootstrap peers, membership, peer discovery, relays and NAT traversal, signed protocol messages.

    Planned
  7. 2

    Open Frontier Node

    Runs on contributor machines: hardware discovery, resource limits, checkpoint recovery, local logs, CLI and desktop UI, signed device identity.

    Planned
  8. 1

    Contributor hardware

    NVIDIA GPUs (CUDA, PyTorch, Triton), Apple Silicon (MLX, Metal, incl. M5/M6), AMD GPUs (ROCm), CPU and test nodes.

    Planned

How it works

  1. 1Contributors join
  2. 2The Node app profiles their hardware
  3. 3The network assigns work
  4. 4Training runs across peers
  5. 5Updates are validated
  6. 6Checkpoints and evidence are published
  7. 7Open models are released

See the full stack diagram (AVIF)

Platform support

Built for a diverse, high-performance ecosystem.

The goal is to welcome the hardware people already own. None of these platforms work yet: this is what we want to build, and we need help.

Planned

Apple Silicon / MLX / Metal

  • Apple M5
  • Apple M6
  • MLX
  • Metal

Planned: Apple M5 and Apple M6 Macs as first-class contributor nodes, training through MLX on Metal. Not built yet.

Help us build it
First target

NVIDIA / CUDA / RTX

  • CUDA
  • RTX
  • GeForce

Launchers for single CUDA nodes are written. None has run on a GPU yet.

Be the first to run it
Planned

Heterogeneous GPUs

  • AMD
  • Intel
  • Others

A flexible platform for any consumer or prosumer GPU. Not built yet.

Help us build it

Open community

A global, open-source effort.

Build, train and advance frontier intelligence together, in the open. Credit goes to everyone who contributes, by name.

Open Repos

Launchers, configs, data manifests and a compute ledger schema, public today.

Public Checkpoints

Planned: every checkpoint released as it is produced.

Community Governance

Decisions in public; merged work earns commit rights. A nonprofit foundation is planned.

Research Collaboration

Methods, evals and negative results, shared openly.

Global Contributors

Open to builders, researchers and compute providers anywhere.

Research and protocol

An open protocol for distributed AI.

The foundation we are designing for large-scale, community-driven training. Specified in the open; not yet implemented.

Peer-to-Peer Networking

Planned: decentralized coordination of training across contributors.

Content-Addressed Artifacts

Planned: models, checkpoints and data identified by their hash.

Verification

Planned: nodes whose updates hurt the loss are dropped automatically.

Auditability

Planned: every step logged, results traceable to configs and code.

Elastic Participation

Planned: join, leave or scale compute without stopping a run.

Network growth

The network starts with you.

Nothing has been trained and no GPU has joined yet. This chart will plot real numbers from the first run; until then it stays empty on purpose.

1

Contributors on GitHub, read from github.com at build time

0

GPUs in the network

Run 0: forming

Training runs

0

Open artifacts released

0

The network starts with you. Run 0 opens soon.

  1. ScaffoldedPhase 1: Run 0

    A dense model of about 1B parameters with the OLMo-core trainer on one GPU node, plus an MoE track. Launchers and configs exist; nothing has run on a GPU.

  2. PlannedPhase 2: Post-training

    SFT, DPO and RLVR with open-instruct, and asynchronous RL with prime-rl.

  3. PlannedPhase 3: DiLoCo islands

    DiLoCo outer loops across single-node islands: community nodes and donated clusters.

  4. LaterRun 1 and Run 2

    About 10B, then 30B to 70B as pooled compute allows, with distributed RL. Not scheduled.