Show HN: HART OS - an open-source AI OS built so frontier AI needs no datacenter

Comments

Hevolve Hive Agentic Runtime - The AI-native operating system for every device, from your computer to embodied AI. Local-first, federated, OpenAI-compatible.

The most capable AI now lives inside a handful of organisations that can put enough compute in one building. That concentration is an architectural choice rather than a law of physics, and it decides what the models will refuse, what they cost, and who gets to read what you type.

The Architectural Choice

To be precise, because this is the obvious thing to attack: you cannot train a frontier model without a datacenter, and we are not claiming you can. What we are claiming is that the intelligence people actually use does not have to be delivered from one.

HART OS runs models on the device, and when a node cannot handle something it recruits a peer directly, with no broker and no company in the middle. We do not shard a model across the network either. Layer-level parallelism over consumer links is a bad idea and we do not attempt it. A peer serves a whole request instead, so a machine with a bigger model answers what a smaller one could not, which tolerates latency in a way tensor parallelism does not.

The things we have not solved are written down in OPEN_PROBLEMS.md, each naming the file that implements today's inadequate answer.

Components

• HART = the bare engine (run from this repo, listens on :6777). There is no published PyPI package yet, so install it from source as shown below.
• HART OS = the full AI-native OS. It boots on a laptop, server, or edge node, runs on phones, and reaches into embodied AI, and it ships the agentic Liquid Shell, Model Bus, model catalog, channel pairing, agent dashboard, and hive view.
• Nunba = the consumer companion app, one signed client across Windows / macOS / Linux.

AI-Native Design

AI-native means the OS adapts to the machine, not the other way around. On each device it probes what the hardware can actually do, serves LLM, vision, and speech to every app over the Model Bus (socket, D-Bus, or HTTP), and lets the on-device model compose the interface and learn each task once so it can replay it later.

The runtime that drives a desktop is the same one that drives a robot, so a robot's AI access is just another Model Bus call. It is one Python codebase that runs in three shapes (flat laptop, regional LAN, or central cloud mesh), speaks the OpenAI protocol on :6777/v1/chat/completions, and federates with peers over PeerLink (direct peer-to-peer WebSocket, no broker).

A boot-time guardrail hash, re-checked every 300 seconds, plus Ed25519 release signing, keep humans in control.

Self-Improvement

You would notice it last, the way you notice anything alive: it improves on its own. Each node learns from what it does and gets quietly better, locally, on your own hardware, with nothing leaving the device.

Calling an operating system alive should make you reach for the off switch, so that came first: the self-improvement is a toggle, every node is killable on its own, and it runs only as long as you let it.

README Structure

This README is written to be read by people and by agents alike. Every capability below names the file it lives in, so whether you are a developer or an AI agent exploring the repo, you can go from a feature straight to its source.

Status: public alpha. The runtime, the Model Bus and the channel adapters are in daily use; APIs still move. Issues and PRs are genuinely wanted - see Contributing. If you would rather argue than patch, start at Open problems.

Nine things we have not solved, each with the code that implements today's inadequate answer and what would count as progress: what convergence can mean with no global view, 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. Disagreeing with a framing there is worth more to us than a patch.

• Why HART OS?
• Open problems - what we have not solved
• Start it
• How it compares
• Capabilities
• Hello, agent
• Architecture map
• API surface
• How auto-evolve works
• How hive connectivity works
• Topology
• Build / extend
• Economics (for node operators)
• Documentation index
• License

How It Compares to Other Software

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 exactly as before. HART OS inverts that. Inference becomes a service the system provides, the way it provides a filesystem or a network stack. An application does not bundle a model or hold an API key - it asks the OS, and the OS decides which model answers, running locally where it can. Ten apps on one machine do not each load their own copy or each pay their own bill.

That has a practical consequence 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.

If you are here to contribute, the parts that most need outside eyes are the auto-evolve loop (autoresearch_loop.py), the guardrails that gate every self-improvement (hive_guardrails.py), and the 31 channel adapters - the most self-contained place to start. See CONTRIBUTING.md.

Installation

Honest about the clock: the server is up seconds after the install finishes, but the install itself is not quick. requirements.txt pins 235 packages and pulls torch, torchvision, transformers, onnxruntime and scipy, so budget a few minutes and a few GB on a first run. This section used to be headed "60-second start", which was not true of anything except the last line.

Use Python 3.10 or 3.11, and not a newer one. The python3.10 in the first command is load-bearing rather than decorative. faiss-cpu==1.7.4 publishes wheels for cp37 through cp311 only, so on 3.12 or later the install stops with "No matching distribution found for faiss-cpu==1.7.4", which reads like a broken repository rather than a version mismatch. If your system python is newer, install 3.10 alongside it and point the venv at that.

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-Compatible Endpoint

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

Live demo · Full quickstart · Nunba desktop

Capabilities Tables

Agent System

Auto-Evolve & Benchmarking

Peer Networking & Hive

Community & Experimentation

AI Providers & Hardware