DEV Community: Don Karter

Your First Five Minutes with Octomind: One Install, One Login, Zero API Keys

Don Karter — Fri, 24 Jul 2026 04:43:08 +0000

This post originally appeared on octomind.run/blog/octomind-hub-quickstart. Cross-posted to dev.to.

Every AI coding tool starts the same way: sign up, grab an API key, paste it into a config file, forget it's there until it leaks. Octomind doesn't do that. One curl command, one browser click, and you're talking to an agent that reads your code, finds bugs, and fixes them — then proves the fix works.

Total cost for the whole thing: under two cents.

Here's the walkthrough. Everything below ran in a clean Ubuntu 24.04 container. No dotfiles, no cached credentials, no Node, no Python pre-installed. Just the agent and a real codebase.

What you're actually getting

Octomind's Hub is an OpenAI-compatible gateway sitting in front of a curated model roster. Not a 400-model dropdown where half the entries are deprecated — 21 models that earn their place.

Open-weights models (DeepSeek, Qwen, Kimi, GLM, MiniMax, Gemma) ship with every paid plan. 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 account can try everything without entering a card.

The key part: you never handle an API key. Not once.

octomind login runs a device flow — same pattern as gh auth login. The CLI shows a short code, you confirm in your browser, and the Hub mints a key scoped to that specific machine. No password in your terminal. No secret in your shell history.

Every machine gets its own revocable key. Log in from your laptop and your server, and you'll see two keys in the panel named after each device. Revoke one, the other keeps working. Fair use is per account, not per key — past the parallelism limit, requests queue briefly instead of failing.

And the meter is visible while you work. Every response prints what it cost. No end-of-month archaeology.

Under the hood, it's all octohub — open source, Rust, one static binary.

Step 1: Install (one command)

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

Or on macOS: brew install muvon/tap/octomind

Here's what actually happened in the container:

[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!

Static binary drops into ~/.local/bin. No runtime dependencies, no package manager churn, works identically on macOS and Linux.

Step 2: Log in (one click)

octomind login

Output:

╭ 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

The CLI opened the panel URL, I confirmed the code, and it claimed a per-device Hub key. If you don't have an account yet, the same page signs you up first — free plan needs no card.

The key shows up in the panel under Keys. Revoking it takes one click. This shipped in 0.38.0 because pasting long-lived secrets into terminals is exactly how keys end up in shell history and screen recordings.

Step 3: Ask your first question

I dropped a Python file with a deliberate bug:

# 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]))

The bug: both branches return ordered[mid]. The even-length case should average the two middle values.

If your directory isn't a git repo, run git init first — the code-search index works repo-per-repo. First run bootstraps its own tooling (it installed Node for MCP servers unprompted), so give it a minute.

Then:

octomind run

This starts the concierge orchestrator — it works out what you need, routes to the right specialist, and remembers across sessions. The header shows the agent, model setting (octohub:auto — the Hub routes each request to a suitable model), working directory, and session ID.

Or skip routing entirely: octomind run developer:general for direct specialist access.

I asked: "Read stats.py and explain in a few sentences what it does. Is the median calculation correct?"

The agent:

Read the file with a tool call (not hallucinating from context)
Found the bug: duplicated branch, even-length case wrong
Demonstrated on concrete input: 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
Suggested the fix: return (ordered[mid-1] + ordered[mid]) / 2

Cost: $0.00403 · 27K in · 518 out

Step 4: Make it prove the fix

Here's where it gets interesting. I asked: "Fix the median bug, then run python3 stats.py to prove the fix works."

The agent:

Edited exactly the broken line with str_replace
Ran python3 stats.py
Output: 3 and 3.5 — fix verified. Even-length now yields 3.5 instead of 4.

Cost: $0.00960 · 67K in · 525 out

Total for review plus verified fix: under a cent and a half.

Every run is a persistent session. octomind run --resume-recent picks up where you left off. -n mywork gives the session a name. You can pipe it for CI and scripting:

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

How to ask questions that actually work

A few things I learned from the transcripts:

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." Specificity is free speed.

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 tokens on every single transcript in the walkthrough.

Escalate when the task outgrows the shelf. -m on the command line or /model mid-session switches to any model. Premium ones bill per token from credits. Escalation is a flag, not a migration.

Does it hold up?

The SWE-bench-Live numbers: 70% solved on the open-shelf model (GLM) at roughly $3.30 per solved task. The harness and baseline live in the repo under bench/ with committed history.

Honest framing: it's their own harness, a pilot-sized suite (15 instances, two runs each), efficiency-first metric. Not a leaderboard submission. The claim is straightforward — an agent on open-weights pricing, resolving real issues, with a cost-per-solved you can actually reason about.

What's next

Everything above ran on a local machine. That's the point — start where you are.

Machines (persistent Linux boxes with the full toolchain, real Docker inside, sessions that survive closing your laptop) are invite-gated while the fleet scales. Subscribing unlocks access instantly. Free accounts earn invites through weekly usage. Every subscriber gets invites to hand out.

It's bootstrapped — hardware bought with revenue, the gate widening at the pace they can genuinely serve.

Get started

Free tier, no card required:

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

Five minutes, two cents, no API keys. Ask it something concrete, make it prove its answer, then see how it goes.

Octomind Cloud Is Live: Real Machines for Your Agent, Every Model Through One Key

Don Karter — Wed, 22 Jul 2026 16:42:12 +0000

This post originally appeared on octomind.run/blog/octomind-cloud-launch. Cross-posted to dev.to.

You've built an agent. It's running a 40-minute refactor. You close your laptop.

Gone. Session dead. Tokens burned. Context lost.

Agents are long-running processes. Laptops aren't long-running machines. The math doesn't work.

That's the first problem we solved with Octomind Cloud. There are two more — and they're equally annoying if you've ever tried to run AI workflows in production.

The Three Problems

Problem 1: Your agent dies with your laptop lid.

You start a long task. Close the laptop. Come back. Everything's gone. You're starting over.

Problem 2: API keys in five dashboards.

OpenRouter. Anthropic. OpenAI. Voyage. That .env file you're scared to look at. Every provider has its own billing, its own rate limits, its own way of telling you you're out of credits.

Problem 3: Your AI bill is a surprise.

Opaque seat pricing. Or worse — usage-based, but you can't see the meter until the invoice hits. Runaway agents burning money overnight while you sleep.

Octomind Cloud is the answer to all three. It's cloud compute for AI agents — one subscription, one wallet, one key.

What You Actually Get

Two things sharing one account:

The Hub — an OpenAI-compatible gateway with 21 curated models behind a single API key
Machines — persistent Linux containers with the full agent toolchain, ready in under a minute

The whole stack is open source (Apache 2.0): octomind, octocode, octobrain, octohub. Self-host if you want. All doors open, docs assume you might.

The Hub: One Key, 21 Models

The Hub is an OpenAI-compatible gateway. You get one API key, and it works across every model on the shelf.

Open shelf (included in every paid plan):

DeepSeek V4 Flash, DeepSeek V4 Pro
Qwen3.7 Plus, Qwen3.7 Max
Kimi 2.6, Kimi 2.7 Code
MiniMax M3
GLM-5.2
Gemma 4

Premium shelf (bills per token from credits):

Claude Fable 5, Opus 4.8, Sonnet 5
GPT-5.6 family: Sol, Terra, Luna
GPT-5.5, GPT-5.5 Pro, GPT-5.4 mini, GPT-5.4 nano
Gemini 3.5 Flash, Gemini 3.1 Pro

There's also a free model with a daily allowance. When everything else is exhausted, this one keeps working.

Prices are published. Metering matches the table exactly. No surprises.

Fair use per account:

Free: 1 parallel call
Pro: 5 parallel calls
Max: 10 parallel calls
Team: 20 pooled parallel calls

Under the hood, the Hub runs on octohub — open source, written in Rust, ships as one static binary.

Here's what a call looks like:

curl https://hub.octomind.run/v1/chat/completions \
  -H "Authorization: Bearer $OCTOMIND_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-luna",
    "messages": [{"role": "user", "content": "Explain Rust ownership in one paragraph"}]
  }'

Same endpoint, same format. Switch models by changing the model field. That's it.

Machines: Persistent Linux Containers

Machines are persistent Linux containers with the full agent toolchain pre-installed:

octomind, octocode, octobrain
Web terminal
Git, Docker, Node, Bun
Headless browser, ffmpeg

Three sizes:

Size	vCPU	RAM	Active	Idle-Warm	Suspended
Small	1	2 GB	$0.05/hr	$0.01/hr	~$0
Medium	2	4 GB	$0.10/hr	$0.02/hr	~$0
Large	4	8 GB	$0.20/hr	$0.04/hr	~$0

Per-second metering. Automatic transitions between active, idle-warm, and suspended states.

10 GB working disk free with every machine.

Security details that matter:

Docker runs inside (real Docker Engine, sysbox runtime, no --privileged)
System filesystem is read-only
Agent runs as non-root user
Environment variables are encrypted and write-only — the panel never shows the value back
Shared directories between machines on the same host

Your machine is ready in about a minute. You get a web terminal, an API endpoint, and it's reachable from the panel, the developer API (api.octomind.run), or Telegram.

Sessions Survive You

Start a turn. Close the tab. The turn keeps running.

Open it from your phone 20 minutes later. Everything's there — full transcript recorded.

Sessions are reachable from:

The panel
Web terminal
Developer API (api.octomind.run)
Telegram

Telegram integration: One tap connects your bot. The machine answers in chat with real formatting — code blocks, lists, everything renders properly.

Switch models per session: /model gpt-5.6-luna works from the panel, Telegram, or the API. Same command, same result.

This is the same octomind you run locally. Same config, same sub-agent delegation, same tools. The only difference is it doesn't die when you close your laptop.

Embeddings: Index Once, Search Everywhere

Two lanes for embeddings:

Local (default, free):

Fastembed running on machine CPU
You pay compute, not tokens

Hub (paid):

Voyage 4, Jina v5, OpenAI text-embedding-3
Starts at $0.02 per million tokens

Index once. The index lands in shared storage. Every machine reuses it. No re-indexing, no duplication.

Pricing

Plan	Price	Usage Caps	Machines	Shared Storage
Free	$0	$0.15/day	1 Small	2 GB
Pro	$20/mo ($10 first month)	$20/4h · $60/week · $120/month	5	10 GB
Max	$100/mo	5x Pro caps	20	30 GB
Team	$500/mo	Pooled caps	Unlimited members	Shared machines

Credits are overflow. Hit your cap mid-task? Credits keep the session flowing. It doesn't die.

Every price is on the pricing page and in the panel. The meter bills from the same numbers. No reconciliation surprises.

What's Next

Octomind Cloud is in beta. It's live now.

The whole stack is open source, Apache 2.0. Self-host if you want, or use the cloud and move on with your day.

Try it: octomind.run/app — free tier, no card, start building.