octos-org/octos

Octos - Agentic Operating Systems

What it solves

Octos is an embeddable AI agent harness kernel written in Rust. It provides the core execution loop, context management, memory, and coordination logic needed to build AI agent applications without requiring developers to rebuild these foundational runtime components from scratch.

How it works

Octos operates as a reusable kernel with a programmable protocol boundary. It can be compiled directly into an application or hosted behind the Octos UI Protocol (OUP), a JSON-RPC 2.0 interface. This allows the kernel to handle agent execution and runtime state while the application owns the user interface and product workflow. The system is composed of several Rust crates, including octos-agent for execution and sandboxing, octos-memory for persistent retrieval, and octos-pipeline for managing workflow graphs.

Who it’s for

It is designed for developers building coding applications, agent-powered desktop apps, research services, workflow engines, or fleets of cooperating agents who want a robust, native execution layer.

Highlights

  • Programmable Protocol (OUP): A JSON-RPC interface that allows human-facing clients or other agents to control the runtime via WebSockets or stdio.
  • Context & Memory Management: Built-in support for context budget management, compaction (summarization), and a hybrid index for long-term memory.
  • Durable Sessions: Supports session identity, conversation branching, and rollback, allowing clients to reconstruct state after a reload.
  • Crate-based Architecture: Modular Rust libraries for LLM routing, plugin integration, and task supervision.
  • Multi-Agent Coordination: Capabilities for managing child agents, independent peers with separate worktrees, and supervised background tasks.
  • Extensible Tooling: Support for filesystem, shell, and MCP tools with configurable permission profiles and human-in-the-loop approval flows.

Related

  • Project
    qntx/ovo

    ovo is a Rust library that lets you embed a multi‑agent runtime into your program. Agents can be spawned dynamically and controlled with Rhai scripts, while all actions are journaled for replay or debugging. It’s useful for building AI agents, automation pipelines, or any system that needs lightweight, scriptable concurrency. The crate is dual‑licensed (Apache‑2.0 or MIT) and maintained by the QuantX community.

  • Project
    tinyhumansai/openhuman

    OpenHuman is an open‑source Rust‑based AI‑agent harness offering a desktop app and a library. It runs hundreds of agents on a cheap VPS by compressing prompts, using a tiny tool‑search model, and keeping the core in a single compiled process. Benchmarks show it’s the fastest, cheapest, and most memory‑efficient among seven comparable harnesses. Features include built‑in memory, voice agents, real‑browser/desktop control, 119 OAuth integrations, 14 messaging channels, and support for local or BYOK models. Install via pre‑built binaries or a simple script; developers embed it with a few lines of Rust code.

  • Project
    ag2ai/ag2

    An open-source AgentOS framework for building AI agents and orchestrating their cooperation through a hub-and-channel network system.

  • Project
    lahfir/agent-desktop

    A Rust-based tool that enables AI agents to reliably control a desktop by interacting with OS accessibility trees rather than pixels, featuring token-efficient UI snapshots.

  • Project
    ZJU-REAL/HugAgentOS

    HugAgentOS is an open‑source, self‑hosted “AgentOS” that lets AI agents retrieve knowledge, run code, and complete real‑world tasks. It uses a domain ontology as a control plane for rule‑based, traceable execution, and offers chat, private RAG, sub‑agents, skill extensions, sandboxed code, multi‑layer memory, automation, and a web UI. Install via a one‑command script (SQLite) or Docker‑Compose (PostgreSQL/Redis, optional Milvus/Neo4j). Community Edition is Apache‑2.0; Enterprise adds multi‑tenant governance.