Octo-Small
UC Berkeley, USA · May 2024
Octo Model Team (UC Berkeley, Stanford University, Carnegie Mellon University, Google DeepMind)
- Parameters
- 27 M
- 27M parameters (paper Table V: 12 layers, hidden size 384, MLP 1536, 6 heads).
- GPU memory
- 0.1 GB
- weights at bf16, computed. Fits an 8 GB card
- Inference latency
- not published
- per action step
- Weights
- MIT
- downloadable checkpoint
What it is
Octo-Small is the 27M-parameter sibling of Octo-Base, identical in architecture apart from width (hidden size 384 instead of 768) and trained on the same 800k Open X-Embodiment trajectories. It runs at 17 iterations per second on a single RTX 4090 and its checkpoint is 0.55 GB, making it the cheapest generalist policy in this comparison to deploy. The published evidence for it is thin: the paper used Octo-Small for its ablations (83% aggregate on the WidowX ablation protocol) but ran the headline zero-shot and fine-tuning evaluations with Octo-Base, and it states that Base perceives scenes better and is more robust to initial configuration. Treat it as the low-compute option whose accuracy relative to Base is documented only qualitatively.
Architecture
- Backbone
- No VLM backbone. Transformer trained from scratch with 12 layers, hidden size 384, MLP size 1536 and 6 heads over shallow CNN patch encoders; language via a frozen pretrained t5-base (111M) encoder.
- Action head
- Conditional diffusion head, 3-layer MLP with hidden dimension 256, DDPM objective, cosine noise schedule, 20 diffusion steps
- Action chunk
- 4 steps per forward pass
- Control rate
- 17 Hz
- Parameters
- 27M parameters (paper Table V: 12 layers, hidden size 384, MLP 1536, 6 heads). The Hugging Face repo rail-berkeley/octo-small-1.5 holds a single 0.55 GB JAX checkpoint file. Architecturally identical to Octo-Base apart from width. The paper's scaling study also mentions a 10M Octo-Tiny, which was not released.
- Pretraining data
- Same mixture as Octo-Base: 800k robot trajectories from 25 curated Open X-Embodiment datasets. Pretraining took 8 hours on a TPUv4-128 pod, at batch size 2048 for 300K steps.
- Embodiments
- WidowX (BridgeData V2), UR5, Google robot (RT-1 setup)
What hardware it needs
This is the section most people came for, so it is worth being precise about which numbers are measured and which are arithmetic.
| Precision | Weights | Note |
|---|---|---|
| fp32 | 0.1 GB | Training master weights, rarely used for inference |
| bf16 or fp16 | 0.1 GB | The usual way these checkpoints are served |
| int8 | 0.0 GB | Quantised, expect some loss of precision on fine motions |
| int4 | 0.0 GB | Aggressive quantisation, verify success rate before trusting it |
Smallest real card that fits the bf16 weights plus a 40 percent runtime allowance: 8 GB. That is an estimate for inference, not for fine tuning. Full fine tuning also holds optimiser state and gradients, which typically costs several times the weights unless you use LoRA or a comparable adapter.
| Control rate | 17 Hz |
| Checkpoint download | 0.55 GB |
No GPU memory requirement is published for Octo-Small in the paper, the README or the model card. No number is given here rather than an estimate.
Reported results
Grouped by what the evaluation actually asked. Values from different suites are not comparable with each other, so each one keeps its suite and split.
Simulation
No results in this category are published for this model.
Real world
No results in this category are published for this model.
Fine tuned tasks
What the model reaches after being adapted to a new task or a new robot, usually from a small number of demonstrations. This is the number that matters if you bring your own data.
- Octo ablation suite (real WidowX) 40 trials across two language-conditioned and two goal-conditioned tasks83%aggregate success rateReported by the Octo authors, Table II. The paper states all ablations were run on Octo-Small because of the compute budget. Ablated variants on the same protocol: RT-X dataset mix 60%, single-robot Bridge data only 43%, discretized action head 18%, continuous MSE head 35%, ResNet-50 plus Transformer architecture 70%. This protocol differs from the zero-shot evaluation in Figure 5, so the number is not comparable to Octo-Base's zero-shot results.source
On real hardware
The only real-robot number published specifically for Octo-Small is the 83% aggregate on the WidowX ablation protocol (40 trials, two language-conditioned and two goal-conditioned tasks). The zero-shot and finetuning evaluations across the 9 real setups in the paper were run with Octo-Base. The scaling study (Figure 6) states that zero-shot performance rises with model size from Octo-Tiny through Small to Base.
Fine tuning it yourself
Identical recipe to Octo-Base: JAX and Flax, full-model updates with the diffusion objective, about 100 target demonstrations, 50k steps, cosine decay with linear warmup, RLDS data format. New observation encoders and action heads can be attached without modifying pretrained weights.
Where it helps, where it does not
Strengths
- Smallest released generalist policy in this comparison at 27M parameters and a 0.55 GB checkpoint
- Fastest measured inference of the models here at 17 iterations per second on a single RTX 4090
- Same flexible input and output interface as Octo-Base, so new cameras, proprioception and action spaces can be attached at fine-tuning time
- Same diffusion action head and the same 800k-trajectory pretraining mixture as the base model
Limits
- The paper explicitly reports that Octo-Base is more robust to initial scene configuration and less prone to early grasp attempts, indicating better visual scene perception in the larger model, so Small trades accuracy for speed
- Almost no published head-to-head numbers: the only Octo-Small result in the paper is the 83% ablation aggregate on WidowX, and its protocol differs from the zero-shot and finetuning evaluations used for Octo-Base
- Inherits every Octo-Base weakness: weak wrist-camera use (27% of pretraining data), weak language conditioning (56% annotated), heavy degradation on novel behaviors such as flipping and precise insertion
- No VRAM or millisecond latency figures are published
- The repository has not been pushed since July 2024
Sources
Everything on this page was taken from these documents. Where they disagree with what you read here, they win.
- https://arxiv.org/abs/2405.12213
- https://arxiv.org/pdf/2405.12213
- https://github.com/octo-models/octo
- https://huggingface.co/rail-berkeley/octo-small-1.5
- https://huggingface.co/rail-berkeley/octo-small-1.5/raw/main/config.json
- https://octo-models.github.io/
Entry last checked 2026-08-11.
Try a policy on a real arm
A physical SO-100 is online and free to drive in the browser, and five of the models in this arena can be fine tuned on a dataset you record with your own.