Octopus-SI-OS README

项目的 README,来自 github.com/miuuyy/Octopus-SI-OS。合并为一个 markdown 文件:README.md。

Octopus

Octopus Superintelligence OS

A self-evolving agentic OS.
A new architecture for agent execution, built on operating-system principles, where agents can reshape their environment and the trajectory of their own work.

Research preview macOS 14+ Rust kernel MIT license

Octopus OS

Octopus runs agents the way the well-known ones run: they read and write your files, drive a browser, use your desktop, call your apps and accounts. You talk to it by text or by voice. The difference is what they run on. You should never have to wonder whether it can do something. If it is allowed to, it can, and when it cannot yet, it can build itself the missing piece.

Underneath, its architecture gives an agent a structure to execute in and a picture of itself and of the world. Capabilities are not add-ons bolted onto a loop. They are contracts in that architecture, so the system can grow in any direction - connect something new, give itself a new sense, rewrite itself. Neither the model nor the agent loop sits at the center. The kernel is about 45,000 lines of Rust; everything else is ported onto it, starting with Codex: sign in with ChatGPT and Codex CLI runs as one interface of the system.

Self-evolution means shaping the conditions of future work. Under policy, an agent can create and revise goals, change interfaces (triggers), add tools, organize workers, and arrange context and execution environments. These changes persist across tasks and runs: they affect what it notices, when it acts, what it works on, and which capabilities it can use next. The agent changes its environment, and that environment shapes its subsequent behavior. Self-improvement remains the research aim: whether this process actually makes the system better.

[!NOTE] This is a research preview. In our runs so far, today's models - GPT-6 included - do not take initiative on their own, and for an ordinary coding task Octopus gives you nothing that Codex CLI does not already give you. The research question is: how can an architecture that lets agents reshape their execution environment help them take initiative and steer their own long-term development? The project studies whether this process leads to useful autonomy and measurable self-improvement.

What you get

HomeOne continuous conversation with the system. Type or talk. It can put live widgets on the screen while it works.
ProjectsA goal with its own context and permissions. What an agent may do in one project says nothing about another.
AgentsSet one up once: a model, a role, and what it may touch. Underneath, an agent is not a program but two JSON files, so you can run as many as you want.
TasksA piece of work you hand to an agent. Leave it running, come back later, pick up where it stopped.
Terminal clientChat, tasks, tools, files, and results in your terminal. Shares the same Home, Projects, and Agents with the desktop client.
ApplicationsThe outside world, plugged in: chat channels, MCP servers, other model providers.
DriversWhere the work physically happens: a folder, a git worktree, a browser, your desktop, a container, a remote machine.

Get started

You need macOS 14+, Swift 6.2+ (Xcode 26 or its Command Line Tools), Node 24, stable Rust, and a ChatGPT account. Without one, you can explore the client in its read-only Test profile (client guide) or configure an API-key, OpenAI-compatible, Claude CLI, Gemini or Vertex provider in Applications.

git clone https://github.com/miuuyy/Octopus-SI-OS.git
cd Octopus-SI-OS
npm ci --prefix app

Then package the app, open it, and sign in with ChatGPT. Press Enter in the embedded terminal to start the system, pick what you want it to have, and say something.

Package the app, step by step

The native build needs the headers of the Node version inside the pinned Electron, independently of the Node version running npm. The runtime helper downloads and verifies the headers pinned in app/native/runtime.json, then prints their path. Package and open the app:

headers="$(node app/native/runtime.cjs headers)" &&
OCTOPUS_NATIVE_NODE_HEADERS="$headers" npm --prefix app run package:mac &&
open -n ./app/build/Octopus.app

Packaging builds the client, the release runtime, the capability executables, and the provider bridge, and bundles the managed Codex distribution. The result is app/build/Octopus.app, ad-hoc signed for this machine. It is not notarized, so Gatekeeper may warn.

First run
  1. Sign in with ChatGPT. It opens the browser. There is no terminal login.
  2. Set a local password. It guards the client on this machine.
  3. Start the system. The embedded terminal prepares a command ending in octopus up. Press Enter and wait for the ready state.
  4. Pick a starting structure. Projects, names, capabilities. Select Set up Octopus.
  5. Say something in Home. A reply proves the connection. A task that uses its tools proves that task's setup.

For a new task, create an Agent first: choose a Project and a model, review its capabilities, then select it in the task composer.

Model availability and usage limits belong to your provider account. Voice and some applications ask for their own credentials and macOS permissions.

Start from a setup file

A setup file (*.octopus-setup.json) carries an Octopus's space, projects, capabilities and model, never its keys, accounts or history. On the first setup step, Import setup… fills the wizard from one; Export setup… on the review step, or Settings → General → Setup file, saves yours. Try it with the Legacy watch setup file. More in Setup files.

To use the terminal client, build it from the checkout and open Octopus:

npm --prefix app run build:cli
./octopus

See Terminal client for setup, keyboard controls, existing Home selection, and commands for scripts or other agents.

How it works

Two words carry the picture. System is everything Octopus can act on. World is everything else. They meet only at declared interfaces; there is no other route.

Underneath, there are a few primitives and no orchestrator:

One turn, end to end

You type a message in Home and Octopus reads a file to answer it.

sequenceDiagram
  participant Op as You
  participant Chat as Chat interface
  participant K as Kernel
  participant Prov as Provider interface
  participant Door as Workspace room
  Op->>Chat: types a message
  Chat->>K: hands in an artifact
  Note over K: form the grant, admit, record
  K-->>Prov: movement recorded
  Prov->>K: hands in a tool call
  K-->>Door: movement recorded
  Door->>Door: check the grant, run the tool
  Door->>K: hands in the result
  K-->>Prov: movement recorded
  Prov->>K: hands in the reply
  K-->>Chat: movement recorded
  Chat->>Op: renders the reply

The kernel never pushes anything and never decodes a payload. Each interface is a live process reading its own movements. The provider interface builds what the model sees; the room's door checks the tool against the grant and runs it. The turn continues while the model keeps asking for tools and ends when it replies.

Every "movement recorded" is one row in the ledger. A refusal is a row too - typed, never a silent drop.

Extend it

Everything attaches the same way: a folder of JSON, plus a script or binary when it needs to run. None of it touches the kernel.

You want You add
A provider over an existing wire One interface folder
A channel or a sensor One interface folder, with a process if it must listen - any language
A worker (an agent) A system_worker_<name>/ folder: two JSON files
A tool A tool.json over a room's executable
A check A verifier folder: a descriptor and a script
The system can do this to itself

A run asked for something it has no sense for - say, to look at you - cannot. So it authors a run for a coder, with the artifacts that run must prove. The coder writes a small camera driver and registers it by creating a new interface folder. A verifier passes it. The descriptor is picked up live.

The first time, that takes as long as a coder needs. The second time there is nothing to build. The system has a new input, and it got it by writing JSON and one script.

More in Scenarios.

The cookbook is Extending Octopus.

Desktop client — voice, tasks, and a view into the system

The optional macOS 14+ client is inspired by the ChatGPT desktop app. It brings together Home and voice calls, Projects and Tasks, split panes, Applications, Drivers, client Extensions, and experimental gesture controls. Topology and Movements expose the architecture behind the conversation.

The runtime works without this client; you can build your own. See the client guide for the screens, their roles, and setup.

Home during a voice call, with transcript and microphone, call, and audio controls

Documentation


Everything stays on your machine in ~/.octopus. Tools run in a deny-by-default sandbox, and every action is checked against permissions and recorded - see the security model. A model with tools on your machine is still a model with tools on your machine: grant what you are comfortable granting.

Independent software, not affiliated with or endorsed by OpenAI. Stored formats may change between preview builds.

MIT license · Security · Contributing

Octopus-SI-OS (miuuyy/Octopus-SI-OS)

正在搜索数据库…

这是什么?Octopus 是一个自我演化的智能体操作系统,是一种基于操作系统原理构建的、用于运行 AI 智能体的新架构。智能体可以自行重塑其运行环境,并自主构建缺失的能力。
这是一个操作系统,还是运行在 Codex 等智能体之上的一层?它是一个约 45,000 行的 Rust 内核,其他智能体工具被移植到其上,首先是 Codex CLI。使用 ChatGPT 登录后,Codex CLI 会作为 Octopus 内的一个界面运行。
我该如何让它运行起来?从源码打包 macOS 应用,打开它,使用 ChatGPT 登录,设置本地密码,然后在内嵌终端中按回车,运行 'octopus up',选择由项目和智能体组成的初始结构。
我需要 ChatGPT 账号以及 Node 和 Rust 工具链吗?需要。在打包和登录之前,你需要 macOS 14+、Node 24、稳定版 Rust 工具链以及 ChatGPT 账号。模型可用性和使用额度取决于你的 ChatGPT 服务账户。
目前它真的能让智能体自主主动行动吗?还不能,作者自己也承认:在他们迄今的运行中,即使是 GPT-6 也不会自行主动行动。对于一般的编码任务,Octopus 提供的功能,Codex CLI 也都已经具备。自我改进仍是一个待解决的研究问题。
这个东西除了 Mac 还能在其他系统上运行吗?不能。客户端和当前版本只支持 macOS 14 及以上。打包出的应用采用临时签名而非公证,因此首次启动时 Gatekeeper 可能会发出警告。
我的数据和智能体的操作会去哪里?所有内容都保存在本地的 ~/.octopus 中。工具在默认拒绝的沙箱中运行,每个操作在生效前都会经过权限检查,并记录在账本中。
Octopus 真的能自行为自己添加新能力吗?可以。如果某次运行需要它缺少的一种感知能力,比如查看摄像头,它就可以编写一个任务,交给编码工作者去编写一个小型驱动程序,并将其注册为新的接口文件夹。一旦验证器通过,系统便拥有了一种由 JSON 和一个脚本构成的新输入方式。
这套架构的核心组成部分有哪些?接口(类型化端口)、产物(跨越边界的消息、差异和工具调用)、运行记录(可持久化的执行记录)、工作者(智能体描述而非程序),以及在每次到达时重新计算的策略。没有中央调度器。
不使用桌面图形界面,有办法用它吗?有。终端客户端与桌面应用共享同一个主页、项目和智能体,可从代码检出处构建,涵盖聊天、任务、工具和文件操作。
为什么要构建类操作系统的架构,而不是直接使用 Codex CLI?这被定位为一个研究预览,旨在检验让智能体重塑自身执行环境(包括目标、工具和接口)能否带来真正的自主性以及可衡量的自我改进。它并不是一次立即见效的 Codex 效率提升。
作者
miuuyy
大小
47.2 MB
星标
773
更新
提交Nov 17
时长
1个月
提交 · 90 天