Skip to content
Open Frontier Labs mark: a glowing green arc over a road that leads to a star

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.

  • 0Contributors on GitHub
  • 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

Contribute what you have, from a single consumer GPU to an 8-GPU node.

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.

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.

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
Planned

NVIDIA / CUDA / RTX

  • CUDA
  • RTX
  • GeForce

The first target: CUDA training from consumer RTX cards up to 8-GPU nodes.

Help us build 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

Planned: trainers, data pipelines and a node agent, all in public repositories.

Public Checkpoints

Planned: every checkpoint released as it is produced.

Community Governance

Decisions in public; 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

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

Join, leave or scale compute with minimal friction.

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.

0

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. PlannedRun 0

    About 1B parameters, DiLoCo across 4 to 8 nodes in two regions.

  2. PlannedRun 1

    About 10B parameters, our first community base model.

  3. PlannedDistributed RL

    Asynchronous RL with community-built environments.

  4. PlannedRun 2

    30B to 70B parameters, as large as pooled compute allows.

Join Open Frontier Labs.

Contribute compute, build with the protocol, and help advance open frontier intelligence with a global community.