The Offline Oracle™ — a 20B brain that runs free on your Mac.
DeepGrove just released a 20-billion-parameter reasoning model that runs entirely on your own Mac — no API bill, no subscription, no internet required.
On my machine it answers at 228 tokens a second — faster than most paid cloud models stream their replies.
It solved competition-level maths on my desk with the wifi off, and DeepGrove showed it running on an iPhone.
The whole brain is a 5 GB file you download once and own forever, under an MIT licence.
I installed it, wired it into my Agent OS, and stress-tested it for a full morning — including the parts DeepGrove doesn't advertise.
Below: the exact setup commands, the real numbers from my tests, and the one weakness you need to know before you trust it.
"We introduce Maple-Preview, an open-source 20B-A1B ternary-weight reasoning LLM, SOTA in its weight class. It solves IMO-level problems and runs at 200+ tokens/s on a Mac Mini M4, 5–16× faster than efficient models like Gemma 4, Qwen3.5, and gpt-oss."
— DeepGrove, launch announcement, August 4, 2026
What DeepGrove actually shipped.
A 20B reasoning model, open-sourced, built for laptops
This is the tweet that started it. Three claims stand out: it's open source under MIT, it solves IMO-level maths problems, and it runs at 200+ tokens a second on a Mac Mini — which DeepGrove says is 5–16× faster than models like Gemma 4 and Qwen3.5 in its class. Further down the thread they show it running on an iPhone at 120+ tokens a second, and demo it "dreaming" a user's dietary preference into its own weights overnight. I tested the Mac claims myself below — the speed one holds up on my machine.
A brain written with three symbols.
Normal AI models store every connection as a precise number with many decimal places. Maple stores each one as just minus, zero, or plus — three symbols. That's what "ternary weights" means.
Writing the brain with three symbols makes the file tiny and the maths fast. A model that would normally need around 38 GB fits in 5 GB, and your Mac's chip chews through it at silly speeds.
The second trick is the expert system. Maple holds 256 small specialist networks inside it, and for each word it generates, a router wakes up only the 8 most useful ones. You get the knowledge of a 20-billion-parameter model with the running cost of a 1-billion one.
Add a 128,000-token context window and an MIT licence — which means free, including for commercial use — and you get something new: a genuine reasoning model, the kind that thinks in long chains before answering, that lives on your laptop instead of in a data centre.
"If you squash the numbers that hard, doesn't it get dumb?"
That was true for years — squashed models lost too much. DeepGrove trained Maple to be ternary from the start instead of squashing it afterwards, which is why it can still solve competition maths. My own tests below show exactly where that holds and where it cracks.
The Rented Brain Problem — every serious AI you use lives in someone else's building.
Think about how you use AI today. Every hard question travels to a data centre you'll never see, gets answered on someone else's machine, and comes back with a bill attached.
You pay per thought. The subscription renews whether you had a big month or not.
Your prompts — client work, contracts, financials, ideas — commute through someone else's servers to get answered.
And when the wifi drops, on a flight, in a dead spot, during an outage, your "intelligence" is gone entirely.
Local models were supposed to be the answer, but the ones that fit on a laptop were either too dumb to trust or too slow to bear.
Maple-Preview is the first local model I've tested that genuinely reasons at cloud speeds. That's why I call this setup the Offline Oracle™.
What changes when the brain moves in with you.
Ask, pay, hope the wifi holds.
- Every hard question is a metered API call.
- Reasoning models are the priciest tier of all.
- Your private data travels to answer your questions.
- No connection, no intelligence.
- Rate limits decide when you're allowed to think big.
- The provider can change prices or models any day.
Download once, own it forever.
- One 5 GB download, then every question is free.
- Real chain-of-thought reasoning, running locally.
- Nothing you ask ever leaves your machine.
- Works on a plane, in a dead spot, in an outage.
- No rate limits — it's your hardware.
- MIT licence: use it commercially, modify it, keep it.
The Offline Oracle™ — three layers.
Here's the mental model I use for what you're actually getting.
The Rock
A 5 GB file sitting on your disk that contains the entire brain. Not a login, not a token, not a subscription — a file. Copy it, back it up, keep it forever. If DeepGrove disappeared tomorrow, your oracle keeps answering.
The Race
Ternary weights plus the 8-of-256 expert trick make it absurdly fast for its brain size. DeepGrove's benchmark says 218 tokens a second on a base M4 — my M4 Max measured 228. Answers stream faster than you can read them.
The Deep End
This is a reasoning model — it thinks in long private chains before answering, like a maths-olympiad kid scribbling working. That's where it shines, and (honestly) where it can also drown. My tests below show both.
What I measured on my own Mac.
I don't publish vendor numbers without checking them. Same morning it dropped, I installed the runtime, downloaded the weights, and ran my own test ladder — maths problems where I brute-forced the true answer in Python first, plus code tasks graded by hidden test cases.
| Hard problem | Maple-Preview | LFM2.5 (baseline) |
|---|---|---|
| Permutation counting (divisible by 22) | PASS — 5,257 tokens, 46s | FAIL — wrong answer |
| Number theory (n divides 2ⁿ+1) | FAIL — never stopped thinking | PASS — 54,241 tokens |
| Modular triples count | FAIL — never stopped thinking | FAIL — wrong answer |
| Subset-sum counting | FAIL — never stopped thinking | FAIL — wrong answer |
| Spiral-matrix code, 8 hidden edge cases | PASS — 659 tokens, 6s | FAIL |
Every maths answer was checked against ground truth I brute-forced in Python first — no trusting the model, and no trusting my own memory either.
The honest part — where it broke.
Those three hard-tier fails weren't wrong answers. They were no answer at all. Maple thought for ten straight minutes on each, burned the entire 64,000-token budget, and never landed. When a reasoning chain doesn't converge, it just… keeps swimming.
And the second weakness matters if you build things: it's not a code-shipping model. DeepGrove says this themselves — the preview had minimal training for agentic work. I tested it anyway. Asked for an animated solar system page, it spiralled to the token cap and delivered a fragment. Asked for a todo app, it produced a beautiful-looking file in 22 seconds — and the page was dead on arrival. Two JavaScript syntax errors meant the whole script never parsed. It looked finished. Clicking a button did nothing.
"Two out of five on the hard tier doesn't sound like a genius."
Context: those problems are brutal — the comparison model scored one out of five with more training data behind it. Maple beat it while running fully offline, and crushed the code-reasoning task the other model failed. It's a reasoning engine, not a code shipper — DeepGrove says agentic training comes next. Use it for what it's good at today, and it's genuinely the best free thing on your Mac.
Three things you might be thinking.
Members inside the Boardroom run systems like this every day — local models, agents, full pipelines. Their wins are documented, in their own words, in a 158-page doc.
Read the 158-page testimonials doc →If you want this already wired in.
Everything in this guide runs inside my Agent OS — local models like Maple wired in beside Claude, Hermes and the whole agent fleet, switchable from one dashboard. Inside the AI Profit Boardroom you get the system pre-built, plus live help when something doesn't work first try.
- The Offline Oracle™ setup — Maple + the Agent OS local engine, pre-wired
- The complete Agent OS — every agent, studio and dashboard in one place
- 5 live coaching calls a week — real people on your exact setup
- 1,000+ prebuilt agents and the automation playbooks
- 4,000+ members in 38 countries — someone's online whenever you're stuck
From zero to your own oracle in about ten minutes.
These are the exact commands I ran on my Mac this morning — nothing theoretical. You need an Apple Silicon Mac (M1 or newer). No account, no API key, no card.
Step 1: Install uv (if you don't have it)
It's the fast Python tool DeepGrove's setup script uses:
curl -LsSf https://astral.sh/uv/install.sh | shStep 2: Clone the Mac runtime
DeepGrove ships a fork of mlx-lm that understands Maple's ternary format:
git clone https://github.com/deepgrove-ai/mlx-lm-deepgrove.git ~/maple-mlx
cd ~/maple-mlxStep 3: Run setup and activate
One script builds the environment:
./setup.sh
source .venv/bin/activateStep 4: Download the brain
The 2-bit Mac checkpoint is 5 GB — this is the coffee-break step:
hf download deepgrove/maple-2bit-mlx --local-dir maple-2bit-mlxStep 5: First answer
Ask it something and watch the speed readout at the end:
python -m mlx_lm generate --model ./maple-2bit-mlx --trust-remote-code \
--flash-head --prompt "Write a haiku about a grove." \
--temp 1.0 --top-p 0.95 --top-k 20Mine printed 228.5 tokens-per-sec on the first try. The --flash-head flag is the free speed boost — keep it on.
Step 6: Chat with it properly
python -m mlx_lm chat --model ./maple-2bit-mlx --trust-remote-code \
--max-tokens -1 --temp 1.0 --top-p 0.95 --flash-headStep 7: Serve it like an API
This gives you a local OpenAI-compatible endpoint any tool can talk to:
python -m mlx_lm server --model ./maple-2bit-mlx --trust-remote-code \
--flash-head --port 8124 --host 127.0.0.1Now anything that speaks the OpenAI API — scripts, apps, your own agents — can point at http://127.0.0.1:8124/v1 and get free local reasoning.
Step 8: No Mac? Try it in the browser first
DeepGrove hosts a free demo at chat.deepgrove.ai — same model, zero install. Good for a taste before you commit the 5 GB.
Three lines and it becomes an engine.
My Agent OS has a "Local" engine — the slot where a model running on this Mac answers instead of a cloud one. Because Maple serves a standard OpenAI-style endpoint (Step 7), wiring it in took three lines of config and zero new code:
LOCAL_OPENAI_BASE=http://127.0.0.1:8124/v1
LOCAL_OPENAI_MODEL=/Users/you/maple-mlx/maple-2bit-mlx
LOCAL_MODEL_LABEL=Maple-Preview 20B-A1B · MLX ternaryI verified it end to end — the Local chat answered as "Maple-Preview 20B-A1B · MLX ternary", streaming its thinking live.
And then I made an honest call: I parked it. My Local engine's day job is building things — pages, games, dashboards — and that's exactly the skill Maple doesn't have yet. So the build engine stays on a builder model, and Maple sits one comment away for reasoning sessions. The right tool in the right slot is the whole point of an OS.
"Why bother wiring in a model you then parked?"
Because now it's a switch, not a project. Reasoning-heavy day — flip to Maple, think for free, flip back. The ten minutes of wiring buys permanent optionality, and when DeepGrove ships the agentic training they've promised, my OS is already ready for it.
Live builds — made by Maple, running on this page.
Don't take my word for any of this. I ran a build gauntlet on Maple: short creative briefs, and a rule that only builds that pass a live playtest ship — real browser, console must be clean, pixels must actually move. No human touched a line of the code below.
The full gauntlet scoreboard: 35 attempts across 9 briefs, 2 clean ships. Simple canvas art it can land; anything with UI logic it ships broken or thinks itself past the deadline. That's the honest state of a preview model with minimal agentic training — and exactly why my Local build engine stays on a builder model while Maple handles the reasoning work.
"Two clean ships out of 35 tries — why show that at all?"
Because the ones that shipped are genuinely lovely, the one that failed teaches you more than a highlight reel would, and you should demand this level of proof from every model page you read. Reasoning is Maple's game today; building is what DeepGrove says comes next.
Six jobs the Offline Oracle™ does well.
Plane-mode deep work
Full reasoning power on flights, trains and dead zones. The oracle doesn't know the wifi is off.
Private-data thinking
Contracts, financials, client strategy — reason over them with nothing ever leaving your machine.
Maths & algorithm checking
Its strongest suit. Competition-level problem solving and tight, edge-case-aware algorithm code.
Free idea triage
Batch the rough thinking — outlines, angles, first passes — locally at $0, and spend cloud credits only on finals.
Pocket oracle
DeepGrove runs it on iPhones at 120+ tok/s. On-device AI that actually reasons is now a real category.
Self-updating memory
Their wildest demo: Maple notices a fact worth keeping, then "dreams" it into its own weights overnight.
A month with the oracle.
Week 1 — Move it in
Days 1–7Run the eight steps. Ask it real questions from your actual work. Watch the tok/s readout once — then stop being impressed and start being demanding.
Week 2 — Give it a job
Days 8–14Pick one recurring reasoning task — analysis, planning, checking work — and route it to Maple by default. Keep the server running; it's 7.6 GB of RAM you'll forget about.
Week 3 — Wire it into your stack
Days 15–21Point your tools at the local endpoint. Anything that accepts an OpenAI base URL — scripts, agents, editors — can now think for free.
Week 4 — Check the bill
Days 22–30Compare your cloud spend to a month ago. Every question the oracle answered was one you didn't pay for. Decide what else deserves the free tier.
Everything on one card.
Two ways to do this.
The free path is above — every command, nothing held back. Follow section X tonight and you'll have your own oracle before bed.
The shortcut is the Boardroom: the whole Agent OS pre-wired — local engines, cloud agents, studios, dashboards — plus people on live calls who run this exact stack.
Real people are running this stack right now — agency owners, ecom founders, creators.
- The Offline Oracle™ pre-wired into the full Agent OS
- 5 live coaching calls a week with people on your setup
- 1,000+ prebuilt agents + every playbook I use
- 158 pages of member wins — documented, in their own words
