Show HN：HART OS——一款旨在让前沿 AI 无需数据中心的开源 AI 操作系统

Hevolve Hive Agentic Runtime

零锁定、由 Agentic OS 提供前端的民主化前沿智能。

一款 AI-native 操作系统。模型运行在你自己的硬件上，节点彼此直接联邦，API 兼容 OpenAI。

---

一个运行在你自己机器上的助手：无需订阅，断开 Wi-Fi 也能工作。你输入的内容会留在设备上，因为它无处可去；你也可以监测网络进行验证。

8GB RAM 已经足够；在 8GB 配置上，它运行的是轻量版本。不同硬件规格具体能获得什么，请见“启动它”部分，因为那才是关键所在。

对于困难问题，前沿模型优于任何能够装进笔记本电脑的模型。但人们每天提出的大多数问题并非如此，而这正是它所服务的其余场景。

现已可用：Nunba 支持 Windows、Linux 和 Android。这个仓库是其底层运行时：它将本地推理作为系统服务提供、进行点对点联邦，并可通过 /v1/chat/completions 或 hart CLI 端到端驱动。下文的每一项声明都标明了实现它的文件。

只想直接使用？ 下载 Nunba：一个已签名的安装程序，无需 Python，并带有会根据你的硬件选择模型的安装向导。以下内容面向希望从源码运行该运行时的用户。

你的机器能带来什么。 两个组件决定这一点。core/gpu_tier.py 将硬件分类到不同层级，前端徽章直接引用其文字而不作改述。实际加载什么模型、加载到哪个设备，则由 VRAM 管理器决定：它为每个模型保留预算、在加载前检查是否适配，并将每个模型放置为 GPU、CPU 卸载或仅 CPU 模式（integrations/service_tools/vram_manager.py）。10GB 以上的 CUDA 显卡可解锁推测解码：由一个 0.8B 草稿模型先行回答，再由主模型验证；层级说明称这可让回复速度提升约 40%。显存介于 4GB 和 10GB 时，GPU 只运行主模型。完全没有 CUDA 时，聊天在 CPU 上运行，并以紧凑模型作为主模型，属于 0.8B 或 2B 级别；模型目录将 main 视为任何 GGUF 都可占用的槽位（integrations/service_tools/model_catalog.py），因此更换模型是配置操作，而非大规模改造。本地 7B 模型需要 16GB RAM 和一块 GPU（security/system_requirements.py，FULL 层级）。

这些条件并不限制节点能够回答什么；在根据硬件评判它之前，这是值得理解的部分。Agent 守护进程在任何层级上的运行方式相同，本地模型不应处理的一个轮次，可以完整交给模型更大的对等节点。该机制的两部分均已发布并在启动时挂接：hive_capability_advertiser 负责通告，hive_expert_discovery 负责注册其接收到的信息；由对等节点的模型直接完成该轮次，而不是审查一个草稿。通告由每个节点自行选择加入（HEVOLVE_HIVE_ADVERTISE=1 和一个公开端点），因此在没有任何节点选择加入的网络中，它会回退到本地。一台普通机器不是只有一个小模型，而是“小模型加上一条通往更大模型的路由”。

服务器可在数秒内启动，但安装过程并非如此。requirements.txt 锁定了 191 个包，并会拉取 torch、torchvision、transformers、onnxruntime 和 scipy，因此首次运行请预留数分钟时间和数 GB 空间。

请使用 Python 3.10 或 3.11，不要使用更新版本。 有 24 个锁定依赖没有 cp312 wheel，其中包括 pandas、scipy、PyYAML、onnxruntime、grpcio 和 tokenizers，因此在 3.12 上安装会以 “No matching distribution found” 停止。这看起来像仓库损坏，而不是版本不匹配。它们每一个都有可以正常工作的当前版本；issue #92 列出了每个依赖的最低兼容版本。

git clone https://github.com/hertz-ai/HARTOS.git && cd HARTOS
python3.10 -m venv venv && source venv/bin/activate   # Windows: venv\Scripts\activate.bat
pip install -r requirements.txt
echo "OPENAI_API_KEY=sk-..." > .env       # or GROQ_API_KEY, or none for local llama.cpp
python hart_intelligence_entry.py         # listens on :6777

它支持 OpenAI 协议，因此任何 OpenAI SDK、LangChain、LiteLLM、Aider 或 Continue 配置都可以不经改动地指向它：

curl -X POST http://localhost:6777/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "hevolve", "messages": [{"role": "user", "content": "Hello"}]}'

在线演示 · 快速开始 · Nunba 桌面端

---

“AI-native”在这里实际意味着什么

大多数被描述为 AI 驱动的软件，都附带一个助手：一个独立应用，通常与他人的服务器通信，能够驱动少数功能。移除这个助手后，底层的一切依然照常工作。

在这里，推理是系统提供的一项服务，就像系统提供文件系统一样。应用不会捆绑模型，也不会持有 API 密钥；它通过 Model Bus 向 OS 请求，OS 决定哪个模型回答，并在可行时于本地运行。单台机器上的十个应用，不会各自加载一份模型副本。

有一个后果值得明确说明：每台设备都成为相同的目标。驱动笔记本电脑的运行时，也驱动机器人，因此机器人的 AI 访问只是另一次 Model Bus 调用；针对 :6777/v1/chat/completions 编写的代码，在两者上无需修改即可运行。

这是一个通过 PeerLink 联邦的 Python 代码库；PeerLink 是一个没有中间 broker 的直接点对点 WebSocket。每个节点上有两项变化，且它们彼此独立。节点能做什么，是从其硬件读取的能力层级。节点在网络中的位置，则是通过 HEVOLVE_NODE_TIER 设置的拓扑模式；只有 flat 可以自行声明。regional 需要由 central 签发的证书，central 需要 Ed25519 主私钥；节点若在没有证明的情况下声称属于任一层级，就会回退为 flat，并记录原因（security/key_delegation.py:103）。

启动时的护栏哈希会每 300 秒重新检查一次，再加上 Ed25519 发布签名，使人类保持控制权。节点从自身使用过程中在本地自我改进；这也是一个可关闭的开关，因为一个自称“活着”的操作系统，应当带有关闭开关。

那么为什么它还提供 Dockerfile

因为这是以三种方式打包的同一套源码树，具体采用哪种方式由拓扑模式决定。在 flat 模式下，它运行在 Nunba 捆绑包中，作为 Windows、macOS 或 Linux 上的普通应用运行。作为 regional 或 central 时，它在 Docker 中独立运行，这也是会与其他节点联邦的节点所采用的部署方式。作为 HART OS，它使用 Nix 构建并直接在裸机上启动，托管与另外两种形态相同的运行时。没有针对不同形态重新实现任何功能，只有最后一种形态构成“操作系统”的主张。

Nix 值得特别指出，因为大多数人所说的“不可变 OS”，更多源自 Nix 而不是本项目。代际版本、单命令回滚、只读存储：这些都属于 NixOS；如果你只需要这些，原生 NixOS 今天就能提供全部能力。这里叠加的是更新流水线：BUILD、TEST、AUDIT、BENCHMARK、SIGN、CANARY 和 DEPLOY。其中，当健康状况恶化时，canary 会自行回退代际版本；签名步骤则需要一把由人类持有、AI 无法接触的主密钥（nixos/modules/hart-ota.nix）。这种继承关系也解释了为何下文 Copilot 的边界是结构性的，而不是一句承诺。存储区只读，因此无论编码 Agent 多么想这么做，它都无法原地重写正在运行的系统。

如果你认为“OS”这个名称做的工作超过了代码实际配得上的程度，这是合理的怀疑；它是操作系统吗？ 严肃对待这一问题。合成器确实使用链接的 Smithay 进行构建，并在 2026-07-26 的 CI 中显示为绿色。有 19 项 nixosTest VM 检查，涵盖 initrd、绘制 watchdog、层级降级和恢复 TTY；该页面直言不讳地指出，它们已定义但尚未通过：该测试套件只能手动触发，没有一次绿色运行。编写一个 initrd 测试仍然能够说明这是怎样的项目，但不能说明启动已经正常工作；该页面明确说明了这一点，而不是让你自行假定。

它能够看到并操作自己的桌面。 视觉模型接收屏幕截图，并通过常规动作词汇经由 pyautogui 驱动真实机器，因此可以操作浏览器或任何其他 GUI。视觉识别在设备端完成（integrations/vlm/local_computer_tool.py）。

Claude Code 作为节点自身的 Copilot 运行。 hart-copilot 会让你进入 Claude Code，在一个新分支上的可写 checkout 中工作；边界由文件系统而非提示词强制执行：nix store 为只读，因此它在结构上无法原地修改正在运行的系统，并且这一路径中的任何内容都不会触及 main。合并、OTA 发布和版本签名仍由人类负责。细节及当前限制请见设计说明。该模块已经构建完成，flake-eval 为绿色，且 hart hive connect 现已存在，因此会话可以向 hive dispatcher 注册并接收工作。仍未实现的部分包括：尚无实时 dispatcher 向它分配任务；live ISO 上的登录状态在重启后也无法保留。

它与当前所用操作系统有何不同

Windows 和 macOS 现在都可以在设备端运行模型，因此这不是过去那种“本地对云端”的老故事。Copilot+ 使用 NPU，Apple Intelligence 使用 Neural Engine。不同之处在于模型属于谁，以及应用被允许请求什么。

| HART OS | Windows | macOS | Linux
---|---|---|---|---
任何应用都可以向 OS 请求推理 | 是，:6777 上的 Model Bus | 仅限厂商助手 | Apple Intelligence 属于 Apple | 否，每个应用自带模型
根据硬件选择模型 | core/gpu_tier.py、vram_manager.py | 固定 | 固定 | 手动
运行 Windows、macOS、Linux 和 Android 应用 | Wine、Darling、Flatpak/Snap/AppImage/Nix、Waydroid（app_installer.py） | Windows、Linux 可通过 WSL | macOS，其他系统需要 VM | Linux，Windows 可通过 Wine
发现你的其他设备并交接一个轮次 | compute_mesh_service.py、LAN beacon :6780 | 否 | Continuity 移动任务，而非推理 | 否
与其他人的节点联邦 | PeerLink，无 broker | 否 | 否 | 否
同意机制是系统原语 | 追加式记录、JWT 认证、分发到你的设备（consent_api.py） | 按应用提示 | 按应用提示 | 按应用
一次学习任务并重复执行 | create_recipe.py / reuse_recipe.py | 否 | 否 | 否
更新是可回滚的代际版本 | 底层为 NixOS | 原地更新，System Restore 仅部分覆盖 | 密封卷，无代际回滚 | NixOS 和 Silverblue 支持，大多数发行版不支持

其中有三行比实际情况更值得称赞。Mesh 会将完整轮次交给一个对等节点，而不是将一个模型拆分到多台机器上，因此，如果你来此寻找的是类似 parallax 的分层切分，它并不是。一个围绕目标协调的节点 hive，不等同于一个更大的模型；而需要前沿能力的问题，依然需要前沿模型。并且，recipe 是从一次真实运行中学习得到的，这意味着错误的 recipe 会持续错误地重放，直到有人纠正它，循环中的其他部分都不会捕捉到这一问题。

完整能力地图 → 覆盖所有子系统及其实现文件：Agent runtime、auto-evolve、联邦、31 个渠道适配器、16 个提供商、安全、经济机制、API 表面，以及它与 Agent 框架而非操作系统的比较。

HART 是本仓库中的裸引擎，监听 :6777。目前尚无 PyPI 包，因此请按上文从源码安装。HART OS 是可在笔记本电脑、服务器、手机或边缘节点上启动的完整 AI-native OS。Nunba 是面向消费者的应用，在 Windows、macOS 和 Linux 上提供同一个已签名客户端。

---

少数机构拥有能力最强的 AI，也随之拥有拒绝策略、定价权，以及你输入一切内容的日志。这些都不是任何自然规律的必然结果，而是由谁为集群付费决定的。

这里的学习是增量式并通过 gossip 传播的；随着节点被使用，能力会在消费级硬件上累积，并由 federated_aggregator.py 执行周期性 aggre

Hevolve Hive Agentic Runtime

Democratic frontier intelligence with zero lock-in, fronted by an agentic OS.

An AI-native operating system. Models run on your own hardware, nodes federate directly with each other, and the API is OpenAI-compatible.

---

An assistant that runs on your own machine, with no subscription, that works with the wifi off. What you type stays on the device because there is nowhere else for it to go, and you can watch the network to check.

8GB of RAM is enough, and on 8GB it is the modest version. Exactly what you get at which spec is in Start it, because that is where it matters.

On a hard question a frontier model beats anything that fits on a laptop. Most of what people ask in a day is not that, and this is for the rest.

Ready today: Nunba for Windows, Linux and Android. This repo is the runtime underneath it: it serves local inference as a system service, federates peer to peer, and is drivable end to end from /v1/chat/completions or the hart CLI. Every claim below names the file that implements it.

Just want to use it? Download Nunba: one signed installer, no Python, and a setup wizard that picks a model for your hardware. Everything below this line is for running the runtime itself from source.

What your machine gets you. Two components decide. core/gpu_tier.py classifies the hardware into a tier, and the frontend badge quotes its words rather than paraphrasing. What actually loads, and onto which device, is the VRAM manager's call: it keeps a budget per model, checks fit before anything loads, and places each one gpu, cpu-offload or cpu-only (integrations/service_tools/vram_manager.py). A 10GB+ CUDA card unlocks speculative decoding, a 0.8B draft answering while the main model verifies, which the tier text puts at roughly 40% faster replies. Between 4 and 10GB the GPU runs the main model alone. With no CUDA at all, chat runs on CPU with a compact model as the main, 0.8B or 2B class, and the model catalog treats main as a slot any GGUF can take (integrations/service_tools/model_catalog.py), so swapping the model is configuration rather than surgery. A local 7B wants 16GB of RAM and a GPU (security/system_requirements.py, FULL tier).

None of that caps what a node can answer, which is the part worth understanding before judging it by its hardware. The agent daemon runs the same on any tier, and a turn the local model should not take can be handed whole to a peer whose model is bigger. Both halves of that are shipped and attached at boot, hive_capability_advertiser announcing and hive_expert_discovery registering what it hears, with the peer's model taking the turn directly rather than reviewing a draft. Advertising is opt-in per node (HEVOLVE_HIVE_ADVERTISE=1 and a public endpoint), so on a network where nobody has opted in it falls through to local. A modest machine is a small model plus a route to a larger one, not a small model on its own.

The server starts in seconds. The install does not. requirements.txt pins 191 packages and pulls torch, torchvision, transformers, onnxruntime and scipy, so budget a few minutes and a few GB on a first run.

Use Python 3.10 or 3.11, not a newer one. Twenty-four pins have no cp312 wheel, among them pandas, scipy, PyYAML, onnxruntime, grpcio and tokenizers, so on 3.12 the install stops with "No matching distribution found", which reads like a broken repository rather than a version mismatch. Every one of them has a current release that would work; issue #92 carries the lowest compatible version for each.

git clone https://github.com/hertz-ai/HARTOS.git && cd HARTOS
python3.10 -m venv venv && source venv/bin/activate   # Windows: venv\Scripts\activate.bat
pip install -r requirements.txt
echo "OPENAI_API_KEY=sk-..." > .env       # or GROQ_API_KEY, or none for local llama.cpp
python hart_intelligence_entry.py         # listens on :6777

It speaks the OpenAI protocol, so any OpenAI SDK, LangChain, LiteLLM, Aider or Continue setup points at it unchanged:

curl -X POST http://localhost:6777/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "hevolve", "messages": [{"role": "user", "content": "Hello"}]}'

Live demo · Quickstart · Nunba desktop

---

What "AI-native" actually means here

Most software described as AI-powered ships an assistant: a separate app, usually talking to somebody else's server, that can drive a few functions. Remove the assistant and everything underneath works as before.

Here inference is a service the system provides, the way it provides a filesystem. An application does not bundle a model or hold an API key, it asks the OS over the Model Bus, and the OS decides which model answers and runs it locally where it can. Ten apps on one machine do not each load their own copy.

One consequence is worth stating plainly: every device becomes the same target. The runtime driving a laptop is the runtime driving a robot, so a robot's AI access is just another Model Bus call, and code written against :6777/v1/chat/completions runs unchanged on both.

It is one Python codebase that federates over PeerLink, a direct peer-to-peer WebSocket with no broker in the middle. Two things vary per node and they are independent of each other. What a node can do is a capability tier read off its hardware. Where a node sits in the network is a topology mode set by HEVOLVE_NODE_TIER, and only flat is self-declared. regional needs a certificate issued by central, central needs the Ed25519 master private key, and a node claiming either without the proof falls back to flat and logs why (security/key_delegation.py:103).

A boot-time guardrail hash re-checked every 300 seconds, plus Ed25519 release signing, keep humans in control. Nodes improve themselves from their own use, locally, and that is a toggle you can switch off, because an operating system that describes itself as alive should come with an off switch.

Then why does it ship a Dockerfile

Because it is one source tree packaged three ways, and the topology mode picks which. In flat it rides inside the Nunba bundle and runs as an ordinary app on Windows, macOS or Linux. As regional or central it runs standalone in Docker, which is how the nodes that other nodes federate with get deployed. As HART OS it is built with Nix and boots on the metal, hosting the same runtime the other two forms run. Nothing is reimplemented per form, and only the last one is the OS claim.

Nix is worth naming because most of what people mean by "immutable OS" comes from there rather than from us. Generations, one-command rollback, a read-only store: all NixOS, and plain NixOS gives you all three today if that is the only thing you want. What sits on top here is the update pipeline, BUILD through TEST, AUDIT, BENCHMARK, SIGN, CANARY and DEPLOY, where the canary reverts the generation by itself when health regresses and the signing step needs a master key that a human holds and the AI cannot reach (nixos/modules/hart-ota.nix). The inheritance is also why the copilot boundary below is structural instead of a promise. The store is read only, so a coding agent cannot rewrite the running system in place however much it would like to.

If you think "OS" is doing more work in that name than the code earns, that is a reasonable suspicion and Is it an OS? takes it seriously. The compositor does build with Smithay linked, green in CI on 2026-07-26. There are nineteen nixosTest VM checks covering initrd, paint watchdogs, tier drops and the recovery TTY, and that page is blunt that they are defined but not passing : the suite is manual-dispatch only and has no green run. Writing an initrd test still tells you what kind of project this is. It does not tell you the boot works, and the page says so rather than letting you assume it.

It can see and drive its own desktop. A vision model takes a screenshot and the usual action vocabulary drives the real machine through pyautogui, so it can operate a browser or any other GUI. The seeing happens on the device (integrations/vlm/local_computer_tool.py).

Claude Code runs as the node's own copilot. hart-copilot drops you into Claude Code inside a writable checkout on a fresh branch, with the boundary enforced by the filesystem rather than by a prompt: the nix store is read only, so it structurally cannot modify the running system in place, and nothing in that path touches main. Merging, OTA publishing and release signing stay human. Details and the current limits are in the design note. The module is built and flake-eval green, and hart hive connect now exists, so the session can register with the hive dispatcher and take work. What is still missing: no live dispatcher has handed it a task yet, and the login does not survive a reboot on the live ISO.

Where it differs from the OS you are running now

Windows and macOS both run models on-device now, so this is not the old story about local versus cloud. Copilot+ uses the NPU and Apple Intelligence uses the Neural Engine. What differs is who the model belongs to and what an application is allowed to ask for.

| HART OS | Windows | macOS | Linux
---|---|---|---|---
Any app can ask the OS for inference | yes, Model Bus on :6777 | vendor assistant only | Apple Intelligence is Apple's | no, each app brings its own
Model chosen from the hardware | core/gpu_tier.py, vram_manager.py | fixed | fixed | manual
Runs Windows, macOS, Linux and Android apps | Wine, Darling, Flatpak/Snap/AppImage/Nix, Waydroid (app_installer.py) | Windows, Linux via WSL | macOS, others need a VM | Linux, Windows via Wine
Finds your other devices and hands over a turn | compute_mesh_service.py, LAN beacon :6780 | no | Continuity moves tasks, not inference | no
Federates with other people's nodes | PeerLink, no broker | no | no | no
Consent is a system primitive | append-only, JWT-authed, fanned out to your devices (consent_api.py) | per-app prompts | per-app prompts | per-app
Learns a task once and replays it | create_recipe.py / reuse_recipe.py | no | no | no
Updates are generations you can roll back | NixOS underneath | in-place, System Restore is partial | sealed volume, no generation rollback | NixOS and Silverblue yes, most distros no

Three of those rows are more flattering than they should be. The mesh hands a peer a whole turn, it does not split one model across machines, so if you came here looking for parallax-style layer sharding it is not that. A hive of nodes coordinating on a goal is not the same thing as one larger model, and a question that needs frontier capability still wants a frontier model. And a recipe is learned from a real run, which means a wrong recipe replays wrongly until a person corrects it, and nothing else in the loop will catch it.

Full capability map → covers every subsystem with the file that implements it: agent runtime, auto-evolve, federation, 31 channel adapters, 16 providers, security, economics, the API surface, and how it compares to the agent frameworks rather than to operating systems.

HART is the bare engine in this repo, listening on :6777. There is no PyPI package yet, so install from source as above. HART OS is the full AI-native OS that boots on a laptop, server, phone or edge node. Nunba is the consumer app, one signed client across Windows, macOS and Linux.

---

A handful of organisations own the most capable AI, and with it the refusal policy, the price, and the logs of everything you type. None of that follows from any law of nature. It follows from who paid for the cluster.

Learning here is incremental and gossiped, accumulated on consumer hardware as nodes get used, with federated_aggregator.py doing periodic aggregation rather than a tight all-reduce. Nobody blocks on anybody else's gradient, so the machines do not need to sit in one building. Inference runs on llama.cpp with GGUF weights, so CUDA, ROCm, Metal, Vulkan and plain CPU are all real paths and nothing in the delivery path needs one vendor's silicon.

The aim, which is a bet and not a shipped feature: an internet of intelligence that nobody owns.

The part we are not comfortable with

The learning is not open. Hebbian, Bayesian and gradient code lives in a private repo called HevolveAI, and this runtime loads it as a signed binary and falls back to a stub when it is missing. You can see the seam in security/native_hive_loader.py.

The reason is the boring one. It is the piece a funded competitor would copy first, and it is how the rest of this gets paid for. That is a normal way to run a company and an awkward thing to put next to an argument about nobody owning the intelligence. Both are true and we would rather say so up here than have you work it out from a table row halfway down.

The narrower claims hold and you can test them yourself. llama.cpp and GGUF run on CUDA, ROCm, Metal, Vulkan and bare CPU, so no vendor owns the silicon you need. Apache 2.0 means a fork costs you an afternoon. What we cannot say without a caveat is that nobody owns the intelligence, because today somebody owns a piece of it, and it is us. Open problem 9 is that argument, including the case that we are wrong to ship it this way at all.

---

Where to start if you want to help

Status: public alpha. The runtime, the Model Bus and the channel adapters are in daily use. APIs still move.

If you want something concrete, the good first issue and help wanted labels are real gaps rather than manufactured onboarding tasks. Each says what is wrong, why it matters, and what would count as done. A couple carry the measurement that found the bug, and one names a hypothesis we already ruled out so nobody spends a Saturday re-testing it. Setup is in CONTRIBUTING.md.

If you would rather argue than patch, start at Open problems. Ten things we have not solved, each with the code implementing today's inadequate answer: what convergence can mean when no node can see the population, whether a system that rewrites itself can still be verified, and why a turn escalates itself to a better model automatically but can never decide on its own that a problem deserves an hour and three machines. Telling us a framing there is wrong is worth more to us than a patch.

---

Section	What's in it
Capabilities	Every subsystem, with the file that implements it
Open problems	Ten things we have not solved
Contributing	Setup, where help is wanted, what we will not merge
Quickstart	Install to first agent
Architecture	Topology, PeerLink, draft-first dispatch, federation
API	/chat, OpenAI-compatible, 195+ endpoints
Provider join	Lend compute, host a region

---

Apache License 2.0.