Octopus OS
Octopus OS is an operating system for long-running agent work. Agents can develop software, update servers, create files, research, plan, and handle recurring business tasks in the same place.
The idea came from how I use Codex. It gradually became the place where I did much more than coding, but the work was still split across chats. I wanted one environment that remembered the goal, the current state, and what was still unfinished.
Octopus stores work as goals and tasks. A large goal can branch, independent tasks can run in parallel, and the system can stop and later continue from the same state.
The 40.6k-line Rust kernel is deliberately not where the agent loop or product behavior lives. It provides the native foundations those layers run on, while roughly 740k lines of lifecycle and product code remain outside it. I designed and implemented the system across the kernel, desktop application, agent lifecycle, model adapters, MCP, tools, and external integrations. The project-owned codebase currently contains approximately 780k lines. I use Octopus OS to manage work across my other projects.
2026 · 7 months · research project · Rust · TypeScript · React · Electron
What exists today.
40.6k
lines in the Rust kernel — just 5.2% of the ~780k-line codebase — providing native foundations for the full agent lifecycle
~740k
lines of lifecycle and product code kept outside the kernel
50+
plugins available in Octopus
Goals instead of chats
A chat works for a request that starts and ends today. Longer work has dependencies, unfinished branches, recurring responsibilities, and goals that remain important after the conversation ends.
Octopus turns a request into a goal, places related tasks under it, and shows what is active or waiting. That structure remains available to future work, so the system does not depend on one conversation staying open.
Goal topology
Every task belongs to a goal. Larger outcomes can branch into related goals, so long-running work stays organized as one visible structure instead of disappearing into separate chats.
Long-running by default
Goals, progress, results, and pending work are stored as data. The process can stop and restart without losing what the system is doing or why it is doing it.
Different kinds of work
Deployments, code changes, research, generated files, recurring business tasks, and personal planning can all live in the same environment.
Parallel work
One goal can hold several active tasks at once. Independent work continues in parallel while dependent tasks wait visibly for the result they need.
Changeable components
The OS can inspect and change the components that define its abilities. New tools and integrations can become part of the environment without rebuilding the kernel around every use case.
Traceable execution
The system keeps a durable record of what moved, what completed, what is still waiting, and what result supports each completed step.
The desktop app
The desktop app is where the system is used day to day. It brings together text and voice input, goals, active tasks, projects, tools, files, and execution history.
What I built
I designed and implemented Octopus across the Rust kernel, desktop application, agent lifecycle, model adapters, MCP, tools, and external integrations.
Small native kernel, large replaceable capability layer
I designed the boundary between the Rust kernel and the lifecycle above it. The kernel provides native foundations; agent loops and product behavior stay outside it.
Fullstack
I designed and implemented the system across the Rust kernel, desktop application, agent lifecycle, model adapters, MCP, tools, and external integrations. The project-owned codebase currently contains approximately 780k lines, including the 40.6k-line Rust kernel.
Founder
I lead and build Octopus independently. I also use the OS to manage work across my other projects, so daily use drives what I build next.
The source is private today. I plan to publish an open-source Research Preview by the end of September 2026 on
my GitHub.
