one engine.
everywhere it needs to run.
octomind is an open-source agent runtime. one binary, any of 31 model providers, and the same agent in your terminal, your ci, your editor, behind your product and in the cloud.
curl -fsSL https://octomind.run/install.sh | bash
octomind run developer:general
- terminal
- ci
- editor
- server
- cloud
agents should keep working when you step away.
chat agents are built around a person at the keyboard, clicking approve. octomind is built for the run nobody watches: policy lives in a file, and a guard stops a tool call before it runs while a validator checks each turn as it ends.
an agent should be a file you own: portable across models, machines and surfaces, and able to finish the work without a human clicking approve.
.agents/guardrails.toml
[[guard]]
match = 'shell(command=git push.*(?:--force(?:\s|$)|-f(?:\s|$)))'
message = "Force push blocked. Use --force-with-lease and ask first."
[[validator]]
name = "test-after-edit"
when = ["+filesystem-write", "-shell(command=cargo test)"]
script = ".agents/validators/remind-tests.sh"
one agent file. five places it runs.
agents are TOML in a registry, not framework code. guards, hooks and validators check every tool call and every turn, so the same definition works with someone watching or with no one at all.
developer:general from muvon/tap
octomind run developer:general
a line prompt with markdown and no tui, so it works the same over ssh, in tmux and in a ci log.
more solved per dollar.
that is the number the engine is tuned for. four choices serve it, and every one is on in the config octomind ships with.
- finish the task
- before a "done" or a hand-back is accepted, an independent verification pass checks the result against what you asked for.
- how the verify gate works
- pay for the work, not the context
- main work, supervision and compression go to separate models. compression runs only when it saves money, and oversized tool output is condensed before the model reads it.
- how compression decides
- learn between sessions
- after /done or a compaction, your rules and the lessons of the session are extracted, kept as files you own, and packed into later turns where they apply.
- how learning works
- stay portable
- any of 31 providers, chosen per role and switched mid-session with /model. the same file runs in all five places.
- the providers
same model, same price: 24 solved to 19.
octobench, run on 2026-07-30: 25 tasks from pull requests merged in 2026, graded by each project's own held-out tests plus an llm judge. octomind and opencode ran the same open model through the same endpoint, so the harness was the only difference.
all four agents in the run, each on its own stock model.
| agent | model | solved | cost | wall time |
|---|---|---|---|---|
| octomind | glm-5.2 (open) | 24 / 25 | $63.43 | 3.6h |
| claude code | claude-opus-5 | 23 / 25 | $81.79 | 6.7h |
| codex | gpt-5.6-sol | 21 / 25 | $14.86 | 1.0h |
| opencode | glm-5.2 (open) | 19 / 25 | $129.54 | 3.3h |
the writeup and every case.
specialists far past the terminal.
the open registry ships 168 agents across 34 domains and 31 multi-step workflows. run any of them by its tag.
behind one login: 44 live models from 15 makers. or bring your own key for any of 31 providers, local models included. browse the models
in the cloud, the engine becomes octos.
octomind cloud runs the same binary on managed machines. an octo is one agent per thing you work on (the blog, the app, a client) with its own workspace, memory, schedule, logins and bill.
- the blog
- the app
- a client
- it sleeps when there is nothing to do and wakes on a message or a routine. asleep, it costs storage only.
- reach it from the panel, Telegram, Slack, WhatsApp or GitHub.
- routines fire it on a timer, a webhook or a click, and every run, skipped ones included, is recorded with its cost.
- each machine has Docker inside, a browser you sign in to, and public urls.
the runtime is free. convenience is what we sell.
three layers, each earning differently. none of them is the runtime itself.
the runtime: free, Apache 2.0
bring your own key to any of 31 providers. this is the top of the funnel, not a loss leader we plan to close off later.
octomind cloud: a subscription
each plan includes usage equal to its price, and the fleet grows as subscriptions fund the hardware under it.
next: the tap marketplace
domain experts publish verified specialists; teams install them. a transaction layer on a registry that already ships 168 free agents.
no venture funding to date — everything here was built bootstrapped. capital efficient by necessity, not by pitch deck.
- free $0 every hub model from your own tools, pay as you go.
- pro $50/mo $50 of usage a month
- max $200/mo $200 of usage a month
- team $500/mo $500 of usage a month, pooled
one of us isn't human.
small on purpose — the same specialist-agent leverage the product sells is how the company runs.
Don Karter
ceo & co-founder
started coding at 12, books before computers. 20+ years across high-load backends, distributed systems, and ai — including ai-assisted coding before the tools had names. builds octomind, sets the technical direction.
Vladimir Kosenko
software engineer & co-founder
fintech engineer at heart — payment systems and trading infrastructure before pivoting to products. technical enough to understand the stack, product-obsessed enough to shape where it goes.
Ava Nuts ai
ai person
her own GitHub, her own commits, her own opinions — persistent memory across every project, context that shapes how she thinks. not a tool anyone prompts. the clearest proof the product works: we run on what we sell.
where it's going.
shipped
the runtime
any of 31 providers, mcp tools, adaptive compression, five ways to run, guardrails as code, multi-step workflows, a write sandbox on Linux and macOS, and native Windows since 0.59.0.
the open registry
168 agents across 34 domains and 31 workflows: developers, security, lawyers in nine jurisdictions, doctors, finance, content and travel.
octomind cloud and hub
octos on managed machines with Docker inside, routines, Telegram, Slack, WhatsApp and GitHub, a browser you sign in to, public urls and a developer api. 44 live models from 15 makers behind one login, open to every account.
in progress
scaling the cloud
bootstrapped, no investors: the fleet grows as subscriptions fund hardware, and launch feedback ships every week.
ahead
next: a premium tap marketplace
verified specialist taps. domain experts (lawyers, doctors, engineers) publish; teams install.
then: vertical tap bundles
curated collections for regulated industries (legal, medical, finance) with signed manifests and provenance.
the vision: specialist agents as community infrastructure
every team runs on composable specialist ai: owned, portable, grounded in domain knowledge. built by experts, shared freely, run anywhere.
we believe ai agents should be a community resource, like packages, not products. built by experts, shared freely, composable by anyone.
run it where you are.
open source, any model, one binary. yours to fork, run and keep.
curl -fsSL https://octomind.run/install.sh | bash