Yesterday we launched Octomind Cloud. That post was the map — the hub, the machines, the economics. Today I want to do the opposite of a map: one narrow path, walked end to end, with nothing skipped.

Here's the thing most people miss in the launch noise: the part you can use right now needs no invite. Machines (our hosted dev boxes) are invite-gated while the fleet scales. The hub — one login, a curated roster of models, no provider accounts — is open to everyone, today, on your own laptop. The whole onboarding is one install command and one browser click.

To keep myself honest, every transcript in this post comes from a clean ubuntu:24.04 container I ran this morning — no dotfiles, no cached credentials, no Node, no Python. (The one screenshot of the interactive shell is from my own machine — same build, same flow.) If it works in that container, it works on your machine. Total spend for everything below: under two cents.

What the hub actually is

Before the walkthrough, thirty seconds of theory, because the hub is the reason the walkthrough is short.

The hub is an OpenAI-compatible gateway in front of a curated model roster — twenty-one models that earn their place, not a 400-model dropdown. Open-weights models (DeepSeek, Qwen, Kimi, GLM, MiniMax, Gemma) are included in every paid plan and draw from your plan caps. Premium models (Claude, GPT, Gemini) bill per token from prepaid credits at published prices. There's a free model with a daily allowance, so a brand-new free account can try everything below without paying anything.

How it works is the interesting part:

  • You never handle a key. octomind login runs a device flow — the same one gh auth login uses. The CLI shows a short code, you confirm it in the browser where you're already signed in, and the hub mints a key scoped to that machine and writes it to disk itself. No password ever touches the terminal.
  • Every machine gets its own revocable key. Log in from a laptop and a server, and you'll see two keys in the panel, named after their devices. Revoke one; the other keeps working.
  • Fair use is per account, not per key, so the budget is a property of you, not of how many terminals you have open. Past your parallelism limit, requests queue briefly instead of failing.
  • The meter is visible while you work. Every response prints what it cost. No end-of-month archaeology.

Under the hood this is octohub — open source, Rust, one static binary. The hosted hub is the same code with the keys problem solved for you.

Step 1 — install (one command)

bash 
curl -fsSL https://octomind.run/install.sh | bash

On macOS you can use Homebrew instead: brew install muvon/tap/octomind. Here's the real output from the container:

text 
[INFO] Installing octomind...
[INFO] Detected platform: x86_64-unknown-linux-musl
[INFO] Latest version: 0.38.2
[INFO] Downloading octomind 0.38.2 for x86_64-unknown-linux-musl...
[INFO] Extracting binary...
[INFO] Installing to /root/.local/bin...
[SUCCESS] octomind installed successfully!
[SUCCESS] Installation verified!

A static binary lands in ~/.local/bin (add it to your PATH if the installer tells you to). No runtime, no package manager churn, works the same on macOS and Linux.

Step 2 — log in (one click)

bash 
octomind login
text 
╭ login · octomind account
│   code  6PVJ-NHW9
│   url   https://octomind.run/app/login/cli
│
│ Confirm the code in your browser to finish signing in.
│ waiting…
│   account  don@muvon.io
│   key      octomind-cli-35f0c0f849cd
│   stored   /root/.local/share/octomind/config/.env
╰ ✓ login · signed in

That's the entire authentication story. The CLI opened (or printed) the panel URL, I confirmed the code matched, and by the time I switched back to the terminal it had claimed a per-device hub key — you can see it named after the machine — and stored it. If you don't have an account yet, the same page signs you up first; the free plan needs no card.

If that key ever worries you, it's listed in the panel under Keys, and revoking it takes one click. This shipped in 0.38.0 precisely because the alternative — pasting long-lived secrets into terminals — is how keys end up in shell history and screen recordings.

Step 3 — ask your first question

Give the agent something real to look at. I dropped a small file with a deliberate bug into an empty repo:

python 
# stats.py
def median(values):
    ordered = sorted(values)
    mid = len(ordered) // 2
    if len(ordered) % 2 == 0:
        return ordered[mid]
    return ordered[mid]


if __name__ == "__main__":
    print(median([3, 1, 4, 1, 5]))
    print(median([3, 1, 4, 1, 5, 9]))

Two practical notes before the first run. Run git init first if the directory isn't a repo yet — the code-search index works repo-per-repo. And the first run bootstraps its own tooling (it installed Node for its MCP servers in my container, unprompted), so give it a minute.

bash 
octomind run

The interactive shell — the concierge header: agent, model routing, working directory, and session id

This is the recommended baseline: bare octomind run starts the concierge orchestrator — it works out what you need, routes it to the right specialist, and remembers you across sessions. The header is your session at a glance: the agent, the model setting — octohub:auto, meaning the hub routes each request to a suitable model so you don't have to pick one before you've even started — the working directory, and a session id you can come back to later.

When you already know the domain, skip the routing and talk to the exact specialist — models do noticeably better when the role matches the task. For our coding session that's the developer:

bash 
octomind run developer:general

Type at the prompt:

text 
〉 Read stats.py and explain in a few sentences what it does.
  Is the median calculation correct?
text 
╭ view · octofs
│ path "stats.py"
│ 1:def median(values):
│ 2:    ordered = sorted(values)
│ ...
╰ ✓ view 50ms · 114 tokens
─────
What it does: Sorts a list of numbers and returns the middle element —
a broken attempt at median.

Is the median correct? No. The even-length case is wrong. Both branches
return ordered[mid] — they're identical code. For an even-length list,
the median should be the average of the two middle values, not just the
upper one.

Example: median([3, 1, 4, 1, 5, 9]) → sorted [1, 1, 3, 4, 5, 9], mid=3,
returns 4. Correct answer is (3+4)/2 = 3.5.

The fix: change the even branch to
return (ordered[mid-1] + ordered[mid]) / 2.
─────
· $0.00403 · 27K in · 518 out

Notice three things. It read the file with a tool instead of hallucinating its contents. It found the actual bug — the duplicated branch — and demonstrated it on a concrete input. And the last line told me what it cost: four tenths of a cent.

Step 4 — let it change code, and make it prove it

Reviewing is nice; the point of an agent is hands. Stay at the prompt and ask for the change and the proof in one message:

text 
〉 Fix the median bug, then run python3 stats.py to prove the fix works.
text 
╭ text_editor · octofs
│ command  "str_replace"
│ -5:         return ordered[mid]
│ +5:         return (ordered[mid - 1] + ordered[mid]) / 2
╰ ✓ text_editor 50ms · 139 tokens
╭ shell · octofs
│ command "cd /root/demo && python3 stats.py"
│ 3
│ 3.5
╰ ✓ shell 50ms · 6 tokens
─────
Done. Even-length median now averages the two middle values instead of
returning the upper one.
─────
· $0.00960 · 67K in · 525 out

It edited exactly the broken line, ran the file, and the output shows the fix: the even-length list now yields 3.5 instead of 4. Total for the review and the verified fix: under a cent and a half. That's the complete loop — read, reason, change, verify — on an open-weights model, five minutes after curl.

Every run is also a persistent session (that's the name in the header). octomind run --resume-recent picks up where you left off; -n mywork gives a session a name you can come back to. And when you want the same agent in a script or CI job, the interactive part is optional — pipe the request in and get plain output back:

bash 
echo "Fix the median bug, then run python3 stats.py to prove it." \
  | octomind run developer:general --format plain

Asking questions that get good answers

The open shelf is priced like open weights because that's what it is — and open models reward a particular style of asking. It's the same style that makes premium models cheaper, so it's just good hygiene:

  • One task per message, with the file named. "Read stats.py and check the median calculation" beats "look around and tell me what's wrong."
  • Ask for proof, not confidence. The agent has a shell — end your request with "run it and show the output." A claim that compiles is worth ten that don't.
  • Bound the answer. "In a few sentences" saved me tokens in every transcript above.

When a task outgrows the open shelf — a gnarly multi-file refactor, a subtle concurrency bug — escalate just that session: -m on the command line or /model mid-session switches to any model on the roster, premium ones billed per token from credits at the prices published on the hub page. Escalation is a flag, not a migration.

Does it actually hold up?

Fair question — "agent fixes toy bug" proves plumbing, not competence. We measure octomind on SWE-bench-Live tasks — real GitHub issues, fixed in clean containers, judged by the instance's own test suite, not by vibes. On our current committed baseline (a 15-instance pilot suite, two runs each), the build you just installed solves 70% of runs with an open-shelf model — GLM, the same shelf your plan caps cover — at about $3.30 per solved task. The harness and the baseline live in the repo under bench/, committed history and all, because a benchmark you can't re-run is marketing.

I'll be straight about what that number is: our own harness, a pilot-sized suite, an efficiency-first metric — not a leaderboard submission. The claim I actually care about is narrower and better: an agent on open-weights pricing, resolving real issues, with a cost-per-solved you can reason about.

What's next: the rest of the cloud

Everything above ran on my machine — that's the point of today's post. The other half of the launch, machines — persistent Linux boxes with the whole toolchain and real Docker inside, where sessions survive your laptop lid — is invite-gated while the fleet scales. Subscribing unlocks access instantly, free accounts earn invites through actual weekly usage, and every subscriber gets invites to hand out. We're bootstrapped: hardware is bought with revenue, and the gate widens at the pace we can genuinely serve. Cloud for everyone is where this goes.

But you don't need to wait for any of that:

bash 
curl -fsSL https://octomind.run/install.sh | bash
octomind login
octomind run

Five minutes, two cents, no API keys. Ask it something concrete and make it prove its answer — then tell us how it went.