# Octos

> Octos is an open-source, Rust-native agentic operating system that runs AI agents on your own hardware with multi-tenant isolation, 16 LLM providers, 14 messaging channels, and a 31MB zero-dependency binary.

Octos (Open Cognitive Tasks Orchestration System) is a Rust-native, API-first agentic OS that lets you run your own AI agent system on a single machine — from a Mac Mini to a Raspberry Pi — without Python, Docker, or external runtime dependencies. The project is fully open source under the Apache 2.0 license and available on GitHub at octos-org/octos, with v2.0.2 as the latest release.

## What It Is

Octos is the backend operating system for AI agents. Rather than a chatbot SDK or framework, it ships as a single 31MB static binary that exposes 80+ REST endpoints plus a UI Protocol v1 over WebSocket and stdio. You configure agent profiles with their own prompts, models, tools, and channels, then manage them from one control plane. The project describes itself as "infrastructure, not a library" — the contrast it draws is with LangChain (a framework) or OpenClaw (a chatbot app).

## Architecture and Deployment Model

The runtime is organized into 12 `octos-*` crates plus app-skill crates, all compiled into one binary:

- **octos-agent** — the agent loop, tool registry, MCP client/server, sandbox, hooks, and sub-agent routing
- **octos-bus** — 14 messaging channel adapters (Telegram, Discord, Slack, WhatsApp, WeChat, Matrix, DingTalk, LINE, Email, and more) with 5 queue modes per session
- **octos-llm** — 16 LLM provider adapters (Anthropic, OpenAI, Gemini, Vertex AI, DeepSeek, OpenRouter, Groq, Ollama, vLLM, and others) with a 3-layer failover stack: RetryProvider → ProviderChain → AdaptiveRouter
- **octos-memory** — 3-layer hybrid memory: long-term entity bank, episodic store (redb + BM25/HNSW vector search), and session JSONL with LRU compaction
- **octos-pipeline** — DOT-graph multi-step workflows with per-node model selection and bounded parallel fan-out
- **octos-swarm** — a PM/swarm dispatcher that fans contracts to N workers (native or external CLI/MCP agents), with validator gating and cost rollup

Deployment paths include a hosted cloud signup at octos.cloud, self-hosted local, and a self-hosted cloud + tenant pair for internet-accessible remote use.

## Performance and Resource Footprint

The project publishes the following self-reported performance figures: cold start under 100ms, 20MB resident memory per agent, a few KB per session (green threads), and the ability to run 200+ agents on a single 16GB machine. The binary is 31MB static with no garbage collection pauses, compared to the project's own benchmark table showing 500ms–2s startup and 200–300MB per agent for alternatives. True multi-core parallelism is used for deep research tasks, with 8 concurrent search workers across up to 5 providers (Tavily, DuckDuckGo, Brave, You.com, Perplexity).

## Agent Topologies and Autonomy

Octos supports three agent relationship models:
- **Sub-agents** — hierarchical children spawned mid-turn via `spawn_agent`, running in-process with isolated sandboxes; results return to the parent only
- **Peer agents** — sovereign sibling sessions staged via `peer_handoff` and gathered via `peer_gather` over a shared blackboard
- **Agent swarm** — a dispatcher at `POST /api/swarm/dispatch` that fans contracts across Parallel, Sequential, Pipeline, or Fanout topologies, with external CLI backends (`claude -p`, `codex exec`) supported

For autonomous operation, `/goal <objective>` gives the agent a standing objective with a token budget and checkpointed continuations across turns. `/loop` runs recurring tasks on a fixed interval or self-paced cadence, persisting across restarts.

## Security and Sandboxing

The entire codebase enforces `deny(unsafe_code)` workspace-wide. Sandbox isolation uses bwrap + Landlock/seccomp on Linux, sandbox-exec on macOS, and Windows AppContainer. The project lists 67 prompt injection tests covering input sanitization, output filtering, and constant-time comparison to prevent timing attacks. API keys are stored in macOS Keychain; each user profile runs as a separate OS process with scoped file access.

## Update: v2.0.2

The latest release is v2.0.2, published on 2026-07-23, with the repository last pushed on 2026-08-04. The project has 1,030 GitHub stars and 74 forks as of the data snapshot. Recent development direction includes UI Protocol v1 (JSON-RPC over WebSocket/stdio), ACP (Agent Client Protocol) integration for Zed editor, MCP server and client support, session time-travel via `session/rollback`, live reasoning streaming, and a native office suite (PPTX/DOCX/XLSX via pure Rust). The homepage notes the license as MIT, while the GitHub repository records Apache License 2.0 — the GitHub license file is the authoritative source.

## Features
- 31MB zero-dependency static binary
- 80+ REST endpoints + UI Protocol v1 over WebSocket/stdio
- 16 LLM provider adapters with 3-layer failover (RetryProvider → ProviderChain → AdaptiveRouter)
- 14 messaging channel adapters (Telegram, Discord, Slack, WhatsApp, WeChat, Matrix, DingTalk, LINE, Email, and more)
- Multi-tenant: 200+ isolated agent profiles on a single machine
- 3-layer hybrid memory: long-term entity bank, episodic store, session JSONL
- 40+ tools sent every turn (shell, files, search, web, browser, memory, and more)
- DOT-graph multi-step pipelines with per-node model selection and bounded parallel fan-out
- Agent swarm dispatcher with Parallel, Sequential, Pipeline, and Fanout topologies
- Sub-agent and peer-agent topologies
- /goal and /loop autonomy modes with checkpointed continuations
- Session time-travel via session/rollback
- Native PPTX/DOCX/XLSX generation via pure Rust
- Voice: cloud TTS and local ASR/TTS via OMiniX runtime
- Sandbox isolation: bwrap + Landlock/seccomp + sandbox-exec + Docker + Windows AppContainer
- deny(unsafe_code) workspace-wide; 67 prompt injection tests
- MCP server (octos mcp-serve) and MCP client support
- ACP (Agent Client Protocol) integration for Zed editor
- LRU tool deferral (~15 active, ~50 on demand)
- 5 queue modes per session: Followup, Collect, Steer, Interrupt, Speculative
- macOS Keychain integration for API key storage
- Deep research pipeline: 8 concurrent search workers across 5 providers
- Family Plan sub-accounts with per-user process isolation
- octos-web browser client, octos-tui terminal client
- Python, Swift, Kotlin, C, JS/WASM language bindings

## Integrations
Anthropic Claude, OpenAI, Google Gemini, Vertex AI, DeepSeek, OpenRouter, MiniMax, Zhipu AI, Qwen, Moonshot, Groq, Z.AI, NVIDIA, Ollama, vLLM, Telegram, Discord, Slack, WhatsApp, WeChat, WeCom, Feishu, Matrix, QQ, Twilio, DingTalk, LINE, Email, Tavily, DuckDuckGo, Brave Search, You.com, Perplexity, MCP (Model Context Protocol), ACP (Agent Client Protocol), Zed editor

## Platforms
WINDOWS, MACOS, LINUX, WEB, API, CLI, DEVELOPER_SDK

## Pricing
Open Source

## Version
v2.0.2

## Links
- Website: https://www.octosai.org
- Documentation: https://octos-org.github.io/octos/
- Repository: https://github.com/octos-org/octos
- EveryDev.ai: https://www.everydev.ai/tools/octos