Your AI. Your hardware. Your values.
Upload your corpus, configure a transformer architecture, and pretrain a language model from random weights on your own hardware. Fine-tune with LoRA, then export to safetensors or GGUF — the weights are yours, with no upstream license to inherit.
Why off-the-shelf AI fails
The model behind your AI isn't actually yours. Until you pretrain one.
Every team building on AI eventually hits the same wall: the underlying model is rented, fine-tuning still inherits someone else's license, and pretraining is treated as out of reach. Atom flips it. Upload your corpus, configure a transformer, pretrain from random weights on your own hardware. The weights are yours — no API quotas, no per-token bills, no upstream license to inherit. Export to safetensors or GGUF and serve them anywhere.
What you do today
You rent your AI from someone else
Why it fails
Every prompt your team sends pays OpenAI or Anthropic a tax. Your data leaves your network on every call. Raise prices, change policy, deprecate a model — you have no leverage because the weights aren't yours.
What you do today
Fine-tuning a Llama is still Meta's model
Why it fails
LoRA adapters on someone else's base inherit that base's license, biases, and refusal patterns. A 'fine-tuned' model is still fundamentally theirs — not the clean-slate, your-corpus-only model you'd build for an internal system.
What you do today
Pretraining is 'too expensive' to consider
Why it fails
Everyone assumes pretraining means $1M+ on a multi-node H100 cluster. For a 25M–125M model on a focused corpus, it's a single GPU and a weekend. The infrastructure to do it has just never been packaged for one team to use.
How it works
Corpus → tokenizer → pretrained weights → fine-tuned, exported, yours.
01
Activate your license + install on your server
Pay once, get a license key, copy the one-line install command from your dashboard. Atom runs anywhere Docker runs — your workstation, a Hetzner box, an H100 rental, your team's GPU cluster.
02
Upload your corpus
Drag in a .txt, .jsonl, or .csv. Atom trains a fresh ByteLevel BPE tokenizer on your data and packs the tokens into a memory-mapped binary ready for training. Vocab size and token count surface instantly.
03
Configure your architecture, pretrain from random weights
Pick a preset (6M / 50M / 125M / 350M) or set layers, heads, d_model, context length yourself. Live parameter count as you tune. Click Start — Atom pretrains a Llama-style decoder (RoPE, RMSNorm, SwiGLU) on your tokens, with live loss streamed to the dashboard.
04
Fine-tune, export, serve
LoRA-tune your pretrained model on instruction pairs. Export any checkpoint to HuggingFace safetensors or convert to GGUF for llama.cpp. Serve via Atom's OpenAI-compatible /v1/chat/completions endpoint, or plug into your own stack.
Built for teams that ship, not labs
Dataset ingestion + transformer from scratch + live training
= everything you'd build if you had six months.
Self-hosted, fully
Every model runs on your hardware. Your corpus, your weights, your inference. No data leaves your network — compliance, IP protection, and zero per-token costs by design.
BPE tokenizer trained on your data
Atom trains a fresh ByteLevel BPE tokenizer on your uploaded corpus — no inherited vocabulary, no Llama tokenization assumptions. Configurable vocab size; surfaces token count and document stats the moment ingestion finishes.
Configurable transformer architecture
Spec layers, heads, d_model, context length, and embedding dim through the dashboard. Live parameter count + bf16 memory estimate as you tune. Presets for 6M, 50M, 125M, and 350M; custom configs supported.
Live training dashboard
Loss curve, tokens/sec, GPU utilization, ETA — all streamed over Server-Sent Events as training runs. Checkpoint browser shows every save with step number and loss; pause and resume any job.
Pretrain from random weights — or LoRA fine-tune
Train a Llama-style decoder (RoPE, RMSNorm, SwiGLU, grouped-query attention) from random init on your corpus — the weights are entirely yours. Or LoRA-fine-tune any pretrained checkpoint with your instruction data.
Export to safetensors + GGUF
Every checkpoint exports to HuggingFace safetensors in one click. Bundled script converts to GGUF for llama.cpp serving. OpenAI-compatible /v1/chat/completions endpoint lets you swap Atom into existing stacks without rewriting.
Pretrain from random weights — clean-slate weights, no upstream license
CoreA 25M–125M parameter Llama-style decoder, trained from random init on a focused corpus, runs on a single GPU over a weekend. The weights are wholly yours — no Meta, Mistral, or Qwen license to inherit, no API to phone home to, no vendor that can deprecate your model.
GPU-aware training orchestration — single-GPU, multi-GPU, or CPU fallback
CoreAuto-detects CUDA, Apple Silicon MPS, or CPU. Mixed precision (bf16 / fp16), gradient checkpointing, cosine LR with warmup, distributed data parallel for multi-GPU rigs — all configured automatically based on what your server actually has.
100%
Self-hosted — your hardware, your corpus, your weights
0
Per-token costs once it's running
25M+
Pretrain on a single GPU over a weekend
0
Upstream model licenses to inherit
What changes for your team
Train your own model. Not someone else's.
Pretrain a model that's actually yours
Atom trains a Llama-style decoder from random weights on your own corpus. No inherited Meta or Mistral license, no API quotas, no per-token tax. The resulting weights are clean-slate — you own them, you can fork them, you can ship them inside other products without an upstream lawyer to call.
Skip the cluster math you assumed you needed
Pretraining doesn't have to mean a $1M H100 rental. A 25M–125M parameter model on a focused corpus runs on a single consumer GPU. Atom packages the training loop, tokenizer, checkpointing, and export so you can actually do it in a weekend.
Fine-tune, export, ship — one workflow
After pretraining, LoRA-tune on your instruction data without leaving Atom. Export to safetensors with one click; convert to GGUF for llama.cpp. Or hit the OpenAI-compatible /v1/chat/completions endpoint Atom exposes — same shape your existing stack already speaks.
Pricing
One payment. Yours forever. Everything after is margin.
One license, paid once. Atom runs on your hardware. No per-seat, no per-token, no recurring — and no vendor between you and your AI.
Founding License
The perpetual platform license, plus white-glove implementation by a certified partner.
1 workspace, unlimited models
- Perpetual Atom platform license
- 1 workspace, unlimited team members
- Unlimited models — train and serve as many as your hardware supports
- White-glove deployment on your hardware
- Initial models trained against your values
- Harness / orchestrator integration
- All future platform updates, free for life
A workspace is one isolated environment with its own models, feedback data, and API keys. Run as many models as your hardware supports — Atom doesn't charge per inference, per token, or per seat.
No recurring. No per-token. No per-seat.
Ready to train your own model?
Stop renting your AI.
Start training your own model.
Bring a corpus, leave with a model. Atom pretrains a transformer from random weights on your hardware, fine-tunes it on your instructions, and exports clean-slate weights you can serve anywhere — no upstream license, no per-token bill, no vendor between you and your AI.
100%
Self-hosted, your hardware
∞
Models per workspace
0
Vendor between you and your AI
Self-hosted. Aligned to you. Yours.