Octomind

A multi-model, MCP-native coding-agent runtime for terminals and unattended automation.

Source repo
Muvon/octomind
Stars
★ 643
Last updated
5d ago
License
Apache-2.0
Primary language
Rust

At a glance

How it runs
CLISelf-hosted service
Works with
Universal · cross-platformOpenAI API · Claude API
Cost
Free tier plus a paid hosted plan
Setup effort
Low · running in minutes
You'll need
macOS, Linux, or WindowsOctomind Cloud login or a supported provider API keyRust 1.95+ for Cargo installation or source buildsShell / CLINetwork accessLocal filesystemMCP Server
Typical use
A developer runs developer:general in a local repository to inspect code, execute tests, and make edits.
Not a fit if
  • Users who require a graphical desktop interface
  • Teams unwilling to let an agent run commands or access project files
  • Environments requiring every tool dependency inside one binary
Website
octomind.run ↗ set on GitHub
Maintenance
Commits in the last 30 dayslast commit 2026-11-16latest release 0.72.0 (2026-11-15)
Source review
63/100 · Some gaps

What does this agent do, and when should you use it?

Octomind is an open-source, CLI-first AI agent client and runtime distributed as a single Rust binary. Its session engine is exposed through an interactive terminal, stdin pipelines, a long-running daemon, a WebSocket server, and an ACP sub-agent interface. Models use MCP tools to inspect and edit files, execute shell commands, search code, and delegate work to other agents. Roles, model choices, tool permissions, workflows, budgets, and guardrails are configured in TOML rather than framework code. Users can obtain model access through Octomind Cloud or bring credentials for providers such as OpenRouter, OpenAI, Anthropic, DeepSeek, and Ollama. The principal deployment boundary is a locally or self-hosted process, although external models and MCP tools may introduce network, credential, and dependency requirements.

A user starts a role or tap specialist with octomind run; the runtime resolves its model settings, system prompt, MCP servers, and allowed tools. With the octofs integration, an agent can call view, text_editor, batch_edit, extract_lines, shell, and workdir to inspect a repository, run commands, and change files. It can also enable servers with mcp, delegate to specialists with tap, register dynamic workers through agent, and handle delayed or event-driven work through schedule and monitor. Requests can arrive interactively or over stdin, while responses can be plain text or JSONL; supported models can additionally follow a supplied JSON Schema. Repository-level guards can deny matching calls before execution, hooks can turn failed checks into corrective feedback, and validators can report post-turn failures back to the agent. Named sessions persist across runs, and adaptive compaction reduces accumulated context while retaining critical task knowledge.

  1. A developer runs developer:general in a local repository to inspect code, execute tests, and make edits.
  2. A CI maintainer pipes a review or analysis task into Octomind and captures plain-text or JSONL output.
  3. A platform team runs a named daemon or WebSocket server for monitoring jobs, internal dashboards, or editor integrations.
  4. A multi-agent system invokes octomind acp to use a configured specialist as an ACP sub-agent.
  5. A team governing unattended automation uses guards, hooks, and validators to block risky calls and feed test failures back automatically.
  6. A cost-conscious engineering group assigns different providers to research and review stages while tracking request and session spending.

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Install / run
  • curl -fsSL https://raw.githubusercontent.com/muvon/octomind/master/install.sh | bash
  • cargo install octomind
Environment variables
OPENROUTER_API_KEY
Runtime
Rust 1.95
Install notes cover
Windows · macOS · Linux

How do you install or deploy this agent?

The installation script supports macOS, Linux, and Windows; Windows users run it under Git Bash or MSYS2. The default destination is ~/.local/bin/.

curl -fsSL https://raw.githubusercontent.com/muvon/octomind/master/install.sh | bash

Sign in for model access through the default octohub:auto configuration:

octomind login

Alternatively, skip Cloud login, supply a supported provider key, and replace the model in [model], [supervisor.model], and [compression.model]. For example:

export OPENROUTER_API_KEY="your_key"
[model]
name = "openrouter:google/gemini-2.5-flash"

[supervisor.model]
name = "openrouter:google/gemini-2.5-flash"

[compression.model]
name = "openrouter:google/gemini-2.5-flash"

Cargo installation is also documented and requires Rust 1.95 or newer:

cargo install octomind

Verify the binary, generate the default configuration, and start a session:

octomind --version
octomind config
octomind run

How do you use this agent?

Start the general development specialist supplied by the default tap. Its first use may install tools and request credentials:

octomind run developer:general

For scripts or CI, provide the request through stdin. The positional argument to octomind run is a role or tap tag, not a message:

echo "Explain the auth module" | octomind run developer:general --format plain

Select JSONL for machine-readable output:

echo "List TODO items" | octomind run developer:general --format jsonl

For a long-running session, start a named daemon and send subsequent requests from another terminal. The daemon stays attached to its original terminal:

echo "watch the build" | octomind run --name watcher --daemon --format jsonl
octomind send --name watcher "run the test suite"

Expose a specialist as an ACP sub-agent:

octomind acp developer:general

Named sessions can be resumed later:

octomind run --name my-feature
octomind run --resume my-feature

What are this agent's strengths and limitations?

Pros
  • One session engine supports interactive CLI use, stdin automation, daemon operation, WebSocket integrations, and ACP orchestration.
  • It supports stdio and Streamable HTTP MCP servers and can activate capabilities or delegate to tap specialists during a session.
  • Deterministic pre-call guards, post-result hooks, and post-turn validators provide concrete controls for unattended execution.
  • Model selection is configurable per role and workflow step across multiple providers, with mid-session switching and cache-aware cost accounting.
  • Adaptive compaction, persistent named sessions, and an out-of-band supervisor are designed for multi-hour or multi-day work.
Limitations
  • Although the core is one binary, octofs, octobrain, and tap-provided MCP tools can bring separate dependencies and credentials.
  • The generated configuration defaults to octohub:auto; BYOK users must update the main, supervisor, and compression model tables and inspect role overrides.
  • Spending thresholds inspect already-recorded costs, so an individual provider call can exceed the configured amount; they are not hard prepaid caps.
  • Schema-constrained output depends on model support, and --format at an interactive terminal errors unless stdin is piped or daemon mode is enabled.
  • Anonymous telemetry is enabled by default. It can be disabled, and the documented payload excludes code, prompts, paths, tool arguments, and environment values.

How does this agent compare with similar options?

The repository reports July 30, 2026 octobench results on 25 tasks taken from merged pull requests and scored by held-out tests. Octomind with glm-5.2 solved 24 tasks, Claude Code with claude-opus-5 solved 23, Codex with gpt-5.6-sol solved 21, and OpenCode with glm-5.2 solved 19. These figures evaluate complete setups: the Octomind run used a staged tap and a binary override with an unfinished-handback pre-gate, so the difference cannot be attributed to a single runtime feature or model. The README also identifies them as published historical results rather than measurements of the current checkout.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Octomind This agent 63 · Some gaps CLIFreemium ★ 643 5d ago Rust OpenAI API · Claude API
Selectools 62 · Some gaps Library / SDKFree + model costs ★ 11 18d ago Python OpenAI API · Claude API
Neuron AI — Agentic Framework for PHP 69 · Some gaps Library / SDKFree + model costs ★ 2.2k 1d ago PHP OpenAI API · Claude API
Hazzel 63 · Some gaps CLIFree + model costs ★ 30 23d ago Python OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
63/ 100 5-point scale 3.2 / 5
This review covers the source as of Nov 08, 2026. The project has shipped 2 stable release(s) since, which have not been re-reviewed. The score and verdict describe the reviewed version only. Recent releases ↓
Trust 14/29
Reliability 8/14
Adaptability 15/18
Convention 14/18
Effectiveness 7/13
Verifiability 5/8
Why each dimension lost points
Trust14 / 29 · 2.4/5

The evidence shows configurable tool permissions, a directory sandbox, deterministic guardrails, spending limits, and telemetry opt-outs; it says telemetry excludes code, prompts, paths, and environment values. Credentials are stored in the user config area and a private vulnerability channel is documented, supporting moderate scores. Deductions: the sandbox is off by default, has path exceptions, and leaves network access available; the guardrails example says its regexes are not a shell security policy. Risky actions generally lack per-action confirmation, and rollback is not automatic. Cargo dependencies and a reporting process are shown, but no dependency audit or vulnerability mitigation status is included. Attribution is visible in commit settings and copyright headers, while publisher identity remains unknown under the prompt.

Reliability8 / 14 · 2.9/5

The README, CLI source, docs, and Cargo manifest consistently describe a Rust binary with several operating surfaces and configuration options. However, config version examples differ (22, 25, and 26), reducing self-consistency. Rust MSRV, install targets, and external model/MCP requirements are documented, but tap, model, and third-party MCP availability depends on network services. Some errors are surfaced to users, and the safety guide states that config validation does not validate project guardrails; the packet does not establish clear messaging for every failure path.

Adaptability15 / 18 · 4.2/5

The materials cover interactive terminal use, stdin/CI, daemons, WebSocket, ACP, multiple model providers, and specialist taps, with configuration for roles, capabilities, sandboxing, and limits. Role permissions, guardrails, sandboxing, and non-interactive budget stops establish some boundaries, but automatic capability activation is on and sandboxing is off by default; the sandbox also leaves networking available. The skill describes when to delegate to Octomind, and the README distinguishes local roles from tap tags, though the overall trigger scope remains broad. Installation and architecture requirements cover Linux, macOS, and Windows in useful detail.

Convention14 / 18 · 3.9/5

Documentation is organized into usage, integration, reference, use-case, and development entry points, with installation, configuration, role, MCP, troubleshooting, example, and FAQ material. Apache-2.0 metadata matches the supplied license. The security policy identifies the latest supported release and a private reporting path; a Cargo version and Conventional Commit convention are visible. Deductions: no full changelog is included, config-version examples conflict, and the default remote installer executes downloaded content, although pinning a version is documented. Maintainer contact and disclosure responsibilities are stated, but response timing depends on maintainer availability.

Effectiveness7 / 13 · 2.7/5

The product combines file and shell tools, MCP, sub-agents, supervision, and structured output across CLI, CI, and daemon surfaces, giving it a clear use in coding automation. Deductions: while permissions and supervision may reduce operating effort, the packet does not quantify deployment costs or benefits for different teams. The benchmark is summarized in the README with an external reproduction guide; this packet alone cannot confirm the comparative results for this revision or justify a strong cost-benefit score.

Verifiability5 / 8 · 3.1/5

Many behaviors are tied to configuration fields, commands, source entry points, and the safety tutorial, including telemetry opt-outs, sandbox limits, guardrails, and error hooks. README claims receive partial corroboration from usage docs and source, and installation and security procedures are concrete. Deductions: several performance, security, and benchmark claims remain primarily README assertions, and the packet is only a sample, so implementation cannot be fully cross-checked. The docs distinguish benchmark date and limitations, but conflicting config-version examples make fact checking less complete.

Risks and how to mitigate them
  • Octomind supports unattended runs; sandboxing is off by default and does not restrict network access. Enable sandboxing and project guardrails, and inspect actual tool capabilities and external MCP services before granting access.
  • Guardrail regexes are not a complete shell security policy; hooks and validators provide feedback but do not undo writes. Keep an independent acceptance check and a recoverable version-controlled workspace.
  • First use of a tap may download an agent manifest and install dependencies; the remote installer examples execute downloaded scripts. Pin versions and review sources for supply-chain-sensitive deployments.
  • The README benchmark summary cannot be independently checked from this packet, and config-version examples conflict.
Evidence confidence: Low Reviewed Nov 08, 2026 Reviewed revision 78d0261d4a38 New commits since this review; the score may not cover them
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/octomind.svg)](https://followagents.com/en/agents/octomind)
<a href="https://followagents.com/en/agents/octomind"><img src="https://followagents.com/badge/octomind.svg" alt="FARS review"></a>

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. 0.72.0 Release 0.72.0
    Release notes excerpt
    📋 Release Summary Tool calls now include their kind, file locations, and diffs, and TAP runs can be routed to a named specialist. Agent loading validates uses entries; TAP routing honors selected and confidence-gated choices, renamed-agent aliases, and the raised specialist threshold. Other fixes enforce pinned embedding revisions, correct log-level reselection, recognize schema-declared command arguments, render inbox markdown, and sync TAP clones with the upstream default branch. 🚨 Breaking Changes - resolver: validate uses entries when loading agents 33ed199a …
    View on GitHub ↗
  2. 0.71.0 Release 0.71.0
    Release notes excerpt
    📋 Release Summary Agent and tap references now resolve across domains, including renamed tap agent tags; prompts expand declared dependencies, and successful turns print summaries. Global layer configuration and the unsupported ACP hook option have been removed; fixes address schedule and configuration validation, nested supervisor paths and evidence, tap refresh and role handling, gate evaluation, token formatting, and session resume. 🚨 Breaking Changes - agent: resolve cross-domain chief references 1489e930 - tap: resolve tap domains to chief agents 597e465d …
    View on GitHub ↗
  3. 0.70.1 Release 0.70.1
    Release notes excerpt
    🔧 Improvements & Optimizations - configure-tests: derive skip index from provider count 4421fab8 🔄 Other Changes 1 maintenance, dependency, and tooling update not listed individually.
    View on GitHub ↗

FAQ

Is an Octomind Cloud subscription required?
No. Cloud login supplies model access for the default octohub:auto setup, but users can instead configure supported providers such as OpenRouter, OpenAI, Anthropic, DeepSeek, or Ollama.
What local resources can the agent access?
Access depends on the active role and configuration. With octofs, it can view, search, and edit files, execute shell commands, and manage the working directory; executable scripts in .agents/tools/ can also become project-local MCP tools.
How can a team restrict dangerous operations?
A .agents/guardrails.toml file can define pre-call guards, post-result hooks, and post-turn validators. Rules may match capability names, argument patterns, call history, roles, and result text.
Are the spending thresholds guaranteed hard limits?
No. Both thresholds are disabled by default and operate on recorded costs, so one provider request can take spending beyond the configured amount.
Does it support fully unattended workflows?
Yes. It accepts stdin with plain or JSONL output and also offers daemon, WebSocket, and ACP modes. A session spending threshold stops piped, ACP, or WebSocket work, while an interactive terminal can ask whether to continue.
Is Octomind free?
Octomind has a free version; the project also offers a paid hosted plan.
Is Octomind open source?
Yes. The source code is on GitHub (Muvon/octomind) under the Apache-2.0 licence.
Is Octomind safe to use?
FollowAgents' FARS review (Nov 08, 2026) scored Octomind 14/29 on trust and safety. None of the eight safety controls the review checks for was missing outright. The repository has changed since that review.
Is Octomind still maintained?
Yes. The latest commit on GitHub is from 2026-11-16, within the last 30 days. The latest release is 0.72.0 (2026-11-15).
Who makes Octomind?
Octomind is published on GitHub by the account Muvon. FollowAgents has not verified which person or company is behind that account.
What is Octomind's official website?
The project's GitHub repository lists https://octomind.run as its website. That link is set by the repository owner; the source code itself is on GitHub (Muvon/octomind).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts