Underneath every Octos product is one governed loop: compose a task, make the decision, grade it against the outcome, render it to any surface — and keep the memory true. Built like infrastructure, on models you own.
Every Octos product runs the same five-verb cycle. The surface and the vertical change; the loop doesn't.
The heart of it is decide → grade: every decision is made under your concerns, carries its evidence, and comes back to be scored against what actually happened — the loop nothing else closes. See the concept →
A company brain, a personal OS, a game world. Each is a vertical — a configuration of programs and concerns, not a separate codebase. Same engine underneath.
Modular programs expose typed operations through an API, coordinate over one shared model of the world they all maintain, and render that composition as an app. The architecture, the governed memory, and the surface in one place.
Octos is model-agnostic — reach any model through your existing agent, or run the standalone runtime that drives the whole loop on open models and hardware you choose: ours, yours, or fully offline. It answers to you, not a vendor's roadmap.
A surface is declared once — a Decision Card, a Concern Panel, a Program Hub. Octos renders it wherever the work is: a rich card in an MCP client, a table in the CLI, a JSON feed over HTTP, a full dashboard on a second screen. The composition is the source; the surface adapts to the host.
Rich, interactive surfaces inline in Claude Code or any MCP client — the open, cross-vendor standard for in-chat UI.
The same decision as a clean CLI card — the daily, primary surface for people who live in a shell.
Any app reads the same governed record over a local HTTP door — the changes feed, the trace, point-in-time state. One spec, the surfaces that exist today.
A standalone control plane — the session map, the concern queue, the decision history — composed as one app.
Your agents don't call Octos like a library — they run on it. It sits above orchestration and beside identity: the layer that decides what deserves attention, governs what gets done, and turns the result into an app. Bring your own models, your own tools, your own host — Octos is the runtime they answer to.
The knowledge graph remembers; the governance layer keeps it true — and the whole thing runs on models you own.
Every choice the system makes is a real object — not a log line, not an API call that vanishes. It carries the evidence behind it, the alternatives it weighed, and a prediction of the outcome. Months later, when the outcome is known, the decision comes back to be scored against it.
This is what distinguishes Octos from observability tools. Observability watches what happened. Octos creates an accountability record the system is responsible to. You can audit any decision, trace why it was made, reopen it when the ground shifts, and see, over time, whether the system's judgment is improving.
Retrieval-augmented generation finds text. It doesn't keep it correct. As an agent accumulates context, language models degrade — on the NoLiMa benchmark, Claude 3.5 Sonnet drops from 87.6% to 29.8% accuracy by 32K tokens, even when the relevant information is present in the window. NoLiMa, 2025. The widely-cited Liu et al. "Lost in the Middle" (2023) showed retrieval from a long context follows a U-shaped curve — highest at the edges, worst in the middle.
Octos holds your domain as living structure: a world-model the system maintains as the work moves, flagging staleness as grounding goes stale. Memory is governed, not just searched. The longer it runs, the more reliable it gets — the opposite of a vector store decaying into noise.
Octos drives the governance loop — gate, record, grade, react — and the engine is yours to run on your own infrastructure. Point its LLM organs at any model you choose; self-host that model and no vendor can revoke, reprice, or silently change what it's allowed to do.
Most AI products are one vendor decision away from dead. API pricing changes, terms-of-service updates, and capability regressions are all risks when your system is a thin wrapper on someone else's model. Octos is the runtime — you own the engine.
A new vertical is a new configuration of programs, concerns, and a world-model — not a new codebase. The runtime stays the same underneath, and it's built to grow new verticals into itself.
Plans, standups, roadmaps, and decisions from across an org — all governed by the same runtime. When intent and reality diverge, the system flags it. Decisions are tracked, scored, and auditable.
Habits, goals, health, projects — services that compose over one model of your life. Cross-domain reasoning no single app can do. Runs on your own device — open-source Personal Core.
Game worlds where every player sees only what their character knows, decisions persist into a traceable history, and an AI director manages the canonical record. A single-player narrative prototype is running today.
Watch Octos make a real decision, attach its evidence, and grade it against the outcome — in about a minute.