Edge-Native Models
Models from 494M to 4.5B parameters, shipped as safetensors, GGUF and MLX builds and tuned to run fast on an 8 GB laptop, a single T4 or Apple Silicon.
Intelligence at the Edge
Precision over scale.
We build open-source language, code and vision models engineered to run on the hardware you already own.
scroll to discover our pipeline
01
Curate the signal
Every sample earns its place.
Training data is filtered and deduplicated before a single step: Athena-1.0-Brain is decontaminated against the benchmarks we report, and Atlas-Coder-2 learned only from execution-verified code.
02
Distill the intelligence
QLoRA fine-tuning and frontier-trace distillation compress strong reasoning into 0.5B–4.5B parameters, trained on single T4 GPUs and one H100 with cross-session checkpoint recovery, so interrupted runs resume where they stopped.
03
Verify the behavior
Benchmarks measure capability; behavior needs its own test. We score models with standard harnesses such as EvalPlus and lmms-eval, and built llm-diff to catch what scores miss: regressions in instruction fidelity, verbosity and reasoning consistency.
04
Ship to the edge
Open weights ship as GGUF and MLX builds for local runtimes like LM Studio and llama.cpp. Atlas-Coder-2 generates 75 tokens per second on an 8 GB MacBook Air — no cloud, and no data leaving the device.
Built for the edge,
engineered beyond scale-first AI.
Open by Default
Every model and dataset is published on Hugging Face under Apache-2.0, and llm-diff is MIT-licensed — with training data, settings and hardware documented in each model card.
Behavior, Verified
llm-diff is git diff for model behavior: it catches silent regressions in instruction fidelity, verbosity and reasoning consistency before a model ships.
Signal-Dense Data
Open training sets — from the 200K-sample Orbit corpus to the deduplicated, decontaminated Athena-1.0-Brain — so every result can be traced back to its data.
Research-grade standards across every release.
Every release ships with a model card documenting its base model, training data, hyperparameters and hardware, so results can be checked, reproduced and built on.
How we build, evaluate and ship efficient AI.
Models that run locally keep data private, cost nothing per token and keep working offline. Our research shows that with signal-dense data and careful adaptation, compact models can rival much larger ones on the tasks they are built for: Atlas-Coder-2, at 494M parameters, ranks in the global top five strictly sub-1B models on EvalPlus HumanEval+.
Consumer hardware. Atlas-Coder-2 runs at 75 tokens per second on an 8 GB M2 MacBook Air in LM Studio, and its GGUF build runs at 40+ tokens per second on a laptop CPU. Apollo-VL-Edge-3B runs in about 6 GB of memory in FP16, or 2.5 GB as a 1.9 GB Q4_K_M GGUF, and ships 4-, 6- and 8-bit MLX builds for Apple Silicon.
We measure capability and behavior separately. Capability is scored on standard benchmarks: EvalPlus HumanEval+ for code, and ChartQA, AI2D and OCRBench through lmms-eval for vision. Behavior is measured with llm-diff, our open-source regression tool, which compares instruction fidelity, verbosity, reasoning consistency and latency between two models. Model cards publish the evaluation setup alongside the scores.
Yes. Every model and dataset is on Hugging Face under Apache-2.0, and llm-diff is MIT-licensed on GitHub (pip install pluto-llm-diff). Model cards document training data, hyperparameters and hardware, and the Pluto-Genesis training pipeline is described in a research paper published on Zenodo.