HOW I WENT FROM $600/MONTH TO $14. ELON'S GROK + KIMI'S BRAIN
I paid Sam Altman, Dario Amodei and Elon Musk at the same time for five months. Don't make the same mistake.
> Follow & Bookmark this - I'm @starmexxx, I track how AI tools are creating new income streams most people haven't heard of yet. This one is the entire build.
Four people decide what you pay for AI, and two of them just defected.
Sam Altman charges $200 a month for ChatGPT Pro to get you Codex. Dario Amodei charges $200 for Claude Max to get you Claude Code. Both sell a terminal agent bolted to a model you can't inspect, on a subscription they reprice whenever the board asks for margin.
Then on July 15, Elon Musk put xAI's coding agent on GitHub under Apache 2.0 - Rust, full TUI, MCP, headless CI, 19.6k stars, irrevocable. Twelve days later Yang Zhilin - 34, Carnegie Mellon PhD, ex-Google Brain, now running Moonshot out of Beijing - published his weights on Hugging Face, one of them under a plain MIT license. And in the same window Lisa Su put 256 GB/s of unified memory in a $2,349 box the size of a hardcover.
Nobody put those three together out loud. Here's what happens when you do: Musk gave away the body, Yang gave away the brain, Lisa Su sells the desk it sits on - and Altman and Amodei are still charging $400 a month for the pair.
I paid $600 a month for five months. $3,000 gone renting compute that now runs on my desk at 140 watts. This is the complete build - agent, model, box, config file, electricity math, and an honest list of what it can't do. Every command is copy-paste. Every number is checkable.
1/
The bill this replaces. $600 in one table.
This is what a serious AI user pays in 2026 if they want an always-on agent plus two frontier models.
WHAT WHY YOU BOUGHT IT PER MONTH PER YEAR
SuperGrok Heavy the only tier with Grok Bot $300 $3,600
ChatGPT Pro frontier reasoning + codex $200 $2,400
Claude Max 5x claude code seat $100 $1,200
-------- --------
$600 $7,200
Seven thousand two hundred dollars a year. For software that runs on someone else's computer, sends your codebase to their servers, and rate-limits you on the day you actually need it.
The replacement, in the same shape:
WHAT WHERE IT COMES FROM ONE-TIME PER MONTH
grok-build github, apache-2.0 $0 $0
Kimi-Linear-48B-A3B hugging face, MIT $0 $0
Ollama runtime ollama.com, open source $0 $0
the box one mini PC, yours forever $609-3,299 $0
electricity 20 hours a day, every day -- $14
-------- --------
$14
Everything above the electricity line is a one-time purchase or free. That's the whole article in one table - the rest is how to actually wire it.
2/
What Elon actually gave away. And why it matters more than the model.
xai-org/grok-build is xAI's real coding agent - not a demo, not a wrapper. It's the same harness behind their paid CLI, published in full.
Language Rust (99.6%)
License Apache 2.0
Stars 19.6k
What it is full-screen TUI coding agent
Reads your entire codebase
Writes files, patches, whole features
Runs shell commands, tests, builds
Also web search, MCP servers, long-running tasks
Modes interactive TUI · headless for CI · embedded via ACP
Install is one line:
# macOS / Linux
curl -fsSL https://x.ai/cli/install.sh | bash
# Windows PowerShell
irm https://x.ai/cli/install.ps1 | iex
grok --version
Here's the part that makes this article possible, and it's buried in the docs rather than the announcement: grok-build talks to any OpenAI-compatible endpoint. It was built to call xAI's API, but the transport is generic. Point it at localhost and it never phones home.
That single design decision turns a free agent into a free stack. You are not getting a crippled open-source clone of the paid tool. You are getting the paid tool, with the billing endpoint swapped out.
Worth knowing before you fall in love with it: xAI ships the code but does not take patches back - the repo is Apache 2.0 and read-only in practice. You can fork it, ship it inside your own product, and nobody can revoke that. You just can't contribute upstream. Full docs live at docs.x.ai/build/overview.
3/
The three Kimi brains. Only one fits your desk.
This is where every article about "running Kimi locally" gets it wrong, and where you'll save yourself a wasted weekend and possibly a wasted $4,000.
Moonshot publishes weights for models at wildly different scales. They are not interchangeable, and the flagship does not run on your hardware. Not "runs slowly" - does not run.
MODEL TOTAL / ACTIVE WEIGHTS ON DISK LICENSE RUNS AT HOME?
Kimi-Linear-48B-A3B 48B / 3B ~28GB (Q4) MIT YES - one card
Kimi K2.7 Code ~1T / 32B 325GB (2-bit) modified ONLY on a big box
Kimi K3 2.8T ~1.4TB (MXFP4) modified NO
Kimi K3 is not a home model. 2.8 trillion parameters. Native MXFP4 weights land around 1.4TB. Squeeze it to 2-bit and you're still near 1TB; push to aggressive sub-2-bit and you get 650–700GB of heavily degraded model. There is no consumer GPU in this conversation - not a 5090, not a 3090, not even a 96GB RTX PRO 6000. The realistic private deployments are four 512GB Mac Studio nodes over Thunderbolt 5 at roughly $40,000, or a dual-socket EPYC box with 1–1.5TB of DDR5 that will hand you single-digit tokens per second. Renting eight H100s is cheaper than both.
Kimi K2.7 Code is the ceiling for a serious home box. Around 1T parameters with 32B active, 325GB at 2-bit. That needs a machine with real memory - 512GB Mac Studio territory, or a big-RAM server with CPU offload. Possible. Not cheap, not fast.
Kimi-Linear-48B-A3B is the one you actually run. 48B total, only 3B active per token, and it's the interesting piece of engineering in Moonshot's lineup rather than just a shrunk-down flagship:
Architecture hybrid linear attention - Kimi Delta Attention (KDA)
3:1 KDA-to-global-MLA ratio
Context 1M tokens
KV cache up to 75% smaller than full attention
Decoding up to 6x faster at long context
License MIT - no revenue clause, no attribution rule
Quantized builds llama.cpp, Ollama, LM Studio, Jan
That KV cache number is the reason this works on a desk. Long context normally eats memory faster than the weights do - a 1M-token conversation in a conventional model blows past your VRAM long before the weights become the problem. KDA cuts the cache by three quarters, which is what lets a home box hold a real working context instead of a toy one.
And the license genuinely is MIT. No monthly-active-user threshold, no revenue clause, no attribution banner. Ship it in a product, sell the product, owe nobody anything.
4/
Pick the box. Every machine, every watt.
You need one machine that stays on. Here's the real field in 2026, with the two numbers that matter - memory bandwidth (how fast it thinks) and watts (what it costs you monthly).
MACHINE MEMORY PRICE BANDWIDTH LOAD RUNS
origimagic A3 32GB $609 ~90 GB/s 45W 7B-13B Q4
Beelink SER9 32GB $859 ~120 GB/s 50W 7B-13B Q4
MINISFORUM AI X1 Pro-470 32GB $1,359 ~130 GB/s 60W 27B Q4
Beelink SER10 MAX 32GB $1,799 ~150 GB/s 65W 27B Q4
GMKtec EVO-X2 96GB $2,349 256 GB/s 140W 70B Q4
GMKtec EVO-X2 128GB $3,299 256 GB/s 140W 70B Q4 + headroom
Mac Studio M4 Max 128GB $3,699 546 GB/s ~180W 70B Q4, fastest
NVIDIA DGX Spark 128GB $4,699 273 GB/s ~170W 70B Q4
For Kimi-Linear-48B at Q4 you need roughly 28GB for weights plus room for context. A 32GB machine runs it but leaves you nothing for a long session. 96GB is the honest floor if you want the 1M context to mean anything, and that's why the EVO-X2 is the pick for most people.
Two notes the spec sheets won't tell you:
Bandwidth beats capacity for speed. The Mac Studio's 546 GB/s is more than double the EVO-X2's 256 GB/s, and you feel it on every token. If your budget stretches and you want the machine to feel fast rather than merely capable, that's where the money goes.
And if you already own a gaming PC with a 3090 or 4090, skip this section entirely. 24GB of VRAM runs Kimi-Linear at Q4 today. Your marginal cost for this whole build is zero dollars of hardware and a slightly higher power bill.
5/
The build. Four commands and one config file.
This is the entire setup. It takes about fifteen minutes, most of which is the model downloading.
# 1 - the runtime
curl -fsSL https://ollama.com/install.sh | sh
# 2 - the brain (Q4 build, ~28GB)
ollama pull kimi-linear:48b-a3b-q4_K_M
# 3 - the body
curl -fsSL https://x.ai/cli/install.sh | bash
# 4 - confirm the runtime is serving on the OpenAI-compatible port
curl http://localhost:11434/v1/models
Now wire them together. grok-build reads ~/.grok/config.toml:
# ~/.grok/config.toml
[model.kimi-local]
model = "kimi-linear:48b-a3b-q4_K_M"
base_url = "http://localhost:11434/v1"
name = "Kimi Linear 48B (local)"
api_backend = "chat_completions"
context_window = 262144
# keep a frontier fallback on the same install
[model.kimi-k3]
model = "kimi-k3"
base_url = "https://api.moonshot.ai/v1"
name = "Kimi K3 (api)"
api_backend = "chat_completions"
context_window = 1048576
The /v1 on the end of base_url is not optional - grok-build speaks the OpenAI chat-completions shape, and Ollama only exposes that under /v1. Leave it off and you'll get a connection that opens and then does nothing, which is a genuinely annoying twenty minutes to debug.
Set context_window to what the model actually does at your quantization, not the headline number. Claiming 1M on a 32GB box means the agent will happily build a request your machine can't hold.
Then run it:
grok models # list what's wired up
grok -p "explain this repo" -m kimi-local
grok # full TUI
Inside the TUI, /model kimi-local switches brains mid-session, or Ctrl+M opens the picker. Same terminal, same workflow, same agent - the only thing that changed is which machine does the thinking.
Verify it's actually local. Watch the runtime log while you send a prompt:
journalctl -u ollama -f # linux
tail -f ~/.ollama/logs/server.log # macOS
If requests show up there, nothing left your machine. If they don't, you're still on the API and still paying.
6/
What this actually handles. And what it doesn't.
The part every article skips. A 3B-active model is not Grok 4.6 and it is not Claude Opus, and pretending otherwise is how people get burned and go back to paying $600.
WORKS WELL LOCALLY STILL NEEDS THE FRONTIER
refactoring within a file novel architecture from scratch
writing tests for existing code debugging a subtle concurrency bug
explaining an unfamiliar codebase one-shot 500-line feature, no iteration
boilerplate, scaffolding, glue deep multi-step math proofs
commit messages, changelogs, docs "why is prod slow" with no lead
routine bug fixes with a stack trace anything where being wrong is expensive
searching and summarizing your repo hard research across many sources
running the same task 200 times production code you won't review
The honest split from a month of daily use: roughly 80% of the work never leaves the box. The remaining 20% is where frontier models earn their price - and 20% of your usage on metered API costs a few dollars, not $600.
This is also the difference between "local AI is a toy" and "local AI is a tool." The toy framing comes from people who tried to do the hard 20% locally, hit a wall, and wrote it off. The tool framing comes from routing correctly.
7/
The electricity math. Where $14 comes from.
No hand-waving. Here's the formula and the arithmetic.
monthly kWh = (load_watts x load_hours + idle_watts x idle_hours) x 30 / 1000
monthly cost = monthly kWh x $/kWh
assumptions: EVO-X2 at 140W load, 25W idle, $0.16/kWh (US average)
USAGE PATTERN LOAD IDLE kWh/MO COST/MO
casual - 4h a day 4h 20h 20.4 $3.26
working - 8h a day 8h 16h 45.6 $7.30
heavy - 12h a day 12h 12h 59.4 $9.50
ALWAYS-ON - 20h a day 20h 4h 87.0 $13.92
pinned - 24h a day 24h 0h 100.8 $16.13
$14 is the always-on number - the box running 20 hours a day, every day, doing real work. That's not a favorable-assumption figure; it's the aggressive one. Most people land at $7.
For comparison, other hardware at the same 8h/16h pattern:
RTX 5090 desktop 650W load 195 kWh $31.20
RTX 4090 desktop 550W load 166 kWh $26.56
Mac Studio M4 Ultra 250W load 66 kWh $10.56
MacBook Pro M4 Max 100W load 28 kWh $4.50
Yes - a 5090 gaming rig running local AI costs more in electricity than a Claude Pro subscription. Mini PCs win this not on speed but on watts. That's the whole reason the Strix Halo class of machine exists.
And the payback, which is the number that actually decides it:
you save $600 - $14 = $586 every month
BOX PRICE PAYS FOR ITSELF IN
origimagic A3 $609 1.0 month
Beelink SER10 MAX $1,799 3.1 months
GMKtec EVO-X2 96GB $2,349 4.0 months
GMKtec EVO-X2 128GB $3,299 5.6 months
Mac Studio M4 Max $3,699 6.3 months
Every one of these is profitable inside a year. Most inside a quarter.
8/
The hybrid. Keep one metered key, not three subscriptions.
Nobody should run 100% local, and anyone telling you otherwise hasn't shipped anything hard. The move is to make the frontier metered instead of subscribed - you pay for the 20% you actually use rather than renting unlimited access you touch twice a week.
Wire both into the same agent and switch with one keystroke. From section 5 you already have kimi-k3 configured. Here's what that 20% actually costs:
MODEL INPUT $/1M OUTPUT $/1M WHEN YOU REACH FOR IT
local Kimi-Linear $0 $0 everything, by default
Grok Build 0.1 $1.00 $2.00 agentic tool loops, cheap
Grok 4.3 $1.25 $2.50 1M context, long documents
Grok 4.6 $2.00 $6.00 hard reasoning, 500K context
Kimi K3 $3.00 $15.00 frontier, 1M context
Run the numbers on a realistic month. Say 40 hard sessions that need frontier help, each burning 50K input and 8K output:
40 sessions x 50K input = 2.0M input tokens
40 sessions x 8K output = 0.32M output tokens
on Grok 4.6 2.0 x $2 + 0.32 x $6 = $5.92
on Grok 4.3 2.0 x $1.25 + 0.32 x $2.50 = $3.30
on Kimi K3 2.0 x $3 + 0.32 x $15 = $10.80
Under $11 a month for the hardest 20% of your work, on the most expensive model in the list. The full stack lands at $14 electricity plus $6–11 of metered API - call it $25 a month, all in, replacing $600.
A router keeps you honest about which is which:
# route.py - send it local unless it's genuinely hard
import os, requests
LOCAL = "http://localhost:11434/v1/chat/completions"
FRONTIER = "https://api.x.ai/v1/chat/completions"
HARD = ("architecture", "race condition", "why is prod",
"design from scratch", "security review")
def ask(prompt: str, force_frontier: bool = False):
hard = force_frontier or any(k in prompt.lower() for k in HARD)
url, model, key = (
(FRONTIER, "grok-4.6", os.environ["XAI_API_KEY"]) if hard
else (LOCAL, "kimi-linear:48b-a3b-q4_K_M", "not-needed")
)
r = requests.post(
url,
headers={"Authorization": f"Bearer {key}"},
json={"model": model, "messages": [{"role": "user", "content": prompt}]},
timeout=600,
)
r.raise_for_status()
return r.json()["choices"][0]["message"]["content"], ("frontier" if hard else "local")
if __name__ == "__main__":
text, where = ask("write a pytest for utils.parse_date")
print(f"[{where}] {text}")
Crude on purpose. Keyword routing catches most of it, and the force_frontier flag handles the rest. Log which branch fires for two weeks and you'll know your real split - mine settled at 83/17.
9/
Grok Bot vs your always-on box. Same idea, different landlord.
xAI launched Grok Bot on August 11, 2026, and it's a genuinely good product. Each bot gets its own cloud computer, signs into your apps without APIs, keeps persistent context, and works while you're offline - asking for approval only when it needs it.
It's also only sold inside the expensive tiers:
HOW TO GET GROK BOT PRICE WHAT ELSE IS BUNDLED
SuperGrok Heavy $300/mo xAI's top consumer tier
Cursor Ultra $200/mo bot's own computer, routines
Cursor Teams Premium $120/seat/mo central billing, analytics
The honest comparison, because these are not the same product:
GROK BOT YOUR BOX
always on yes, in their cloud yes, on your desk
runs while you sleep yes yes
signs into your apps yes, built in you wire it yourself
frontier model yes, included metered, or local + cheaper
your code leaves yes never
monthly cost $300 minimum $14
rate limits weekly allowance your hardware
survives a price change no yes
Grok Bot wins on convenience and on the app-integration layer — that's real engineering you'd otherwise build yourself. Your box wins on cost, privacy, and the fact that nobody can reprice it, deprecate it, or throttle it on the Tuesday you're shipping.
If the app integrations are the thing you need, pay the $300 and stop reading. If what you actually wanted was an agent that works on your repo without a meter running, the box is strictly better.
10/
What neither of them actually gave away.
Both companies made a real gift and both kept the piece that matters to them. Worth naming, because it explains why this combination works at all.
xAI gave the harness, kept the model. grok-build is genuinely complete and genuinely Apache 2.0. But Grok 4.6's weights are not public and never have been - you get the body, you rent the brain. The license is also read-only in practice: you can fork, ship, and sell, but upstream doesn't take your patches. Fine for a user. Frustrating if you wanted a community around it.
Moonshot gave the model, kept the tooling. The weights are on Hugging Face and Kimi-Linear is real MIT. But K2.7 and K3 carry a modified license with a commercial threshold - cross roughly $20M in annual revenue running a model-as-a-service business on them and you need a separate agreement. And Moonshot ships no agent of their own that competes with what you're getting free from xAI.
Which is exactly why the combination works: each one open-sourced the half the other one was protecting. That is not coordination - it's two companies with opposite moats, and you get to stand in the gap.
Don't mistake either for charity. xAI wants the harness to be the default so their API is the default backend. Moonshot wants the weights everywhere so the paid tiers get considered. Both bets are rational. Both leave a working free stack on the table.
11/
Which tier are you. The decision tree.
+--------------------------------+
| What are you paying now? |
+---------------+----------------+
|
v
Do you already own a 3090/4090
or a Mac with 32GB+?
| |
yes no
| |
v v
START HERE. $0 down. What's your monthly AI bill?
Sections 5 and 8 | |
this afternoon. under $50 over $200
| |
v v
origimagic A3 EVO-X2 96GB
$609 $2,349
pays back in pays back in
~1 month 4 months
| |
+-----+------+
|
v
Do you need app integrations
(signs into your tools, routines)?
| |
yes no
| |
v v
Keep Grok Bot THE $14 STACK.
at $300. The box Local by default,
still kills your metered frontier
other two subs. for the hard 20%.
12/
The full stack in one block.
Save this one.
THE BODY
grok-build github.com/xai-org/grok-build
install curl -fsSL https://x.ai/cli/install.sh | bash
license Apache 2.0, fork and ship freely
config ~/.grok/config.toml
modes TUI · headless (CI) · ACP embedded
THE BRAIN
local Kimi-Linear-48B-A3B · MIT · ~28GB Q4 · 1M ctx
big box Kimi K2.7 Code · 325GB 2-bit
don't try at home Kimi K3 · ~1.4TB
runtime Ollama · LM Studio · llama.cpp · Jan
THE BOX
budget origimagic A3 $609 45W 13B
sweet spot GMKtec EVO-X2 96GB $2,349 140W 70B Q4
fastest Mac Studio M4 Max $3,699 180W 546 GB/s
free the GPU you own $0
THE BILL
electricity $3-14/mo depending on hours
metered frontier $6-11/mo for the hard 20%
total ~$25/mo replacing $600/mo
payback 1 to 6 months on the hardware
THE WIRING
base_url must end in /v1
context_window set to real, not headline
verify local watch the runtime log, not the agent
route local by default, frontier on keywords
The window.
Six months ago this article couldn't have been written. xAI's agent wasn't public. Kimi-Linear didn't exist. Mini PCs with 256 GB/s of unified memory weren't $2,349. All three landed inside one summer.
The subscriptions made sense when local hardware couldn't keep up. It kept up. A $609 box runs a capable coding model. A $2,349 box runs a 70B one with a million tokens of context. The agent driving them is the same one xAI ships to paying customers, published under a license that can't be revoked.
You don't need the most expensive option. You don't need to be an ML engineer. The setup is four commands and a config file, and the hardest part is waiting for a 28GB download.
$600/month subscriptions $7,200 a year
$14/month electricity $168 a year
--------------
$7,032 saved
One box kills that bill permanently. Pick your level, wire it this weekend, and stop renting compute you can own.
// The window is open. Follow @starmexxx - I'll keep finding them before they close //
Related articles
how to run an ai native agency with jev (FULL GUIDE)
jev is open to everyone now. it's a super fast decision model, so one person can now do work that businesses usually pay an agency a big cut for. here's how you can set up a whole ai native agency wi…
Grok Bot Agents: How to Build a 5-Person Sales Team That Never Sleeps (Full Guide)
I'm going to show you the exact 5-agent setup that's been running our lead gen, and the descriptions that go inside each one.
Grok Bot Is Turning One Person Into an Entire AI Team
You are no longer asking, "Can you help me do this?"