HART OS
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.
What it is
An assistant that runs on your own machine, with no subscription, that works with the wifi off. 8GB of RAM is enough. What you type stays on the device because there is nowhere else for it to go, and you can watch the network to check.
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.
Why it exists
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.
Start it
The server starts in seconds. The install does not. 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.
Use Python 3.10 or 3.11, not a newer one. faiss-cpu==1.7.4 publishes
wheels for cp37 through cp311 only, so on 3.12 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.
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.
Full capability map → . Every subsystem with the file that implements it: agent runtime, auto-evolve, federation, 31 channel adapters, 15 providers, security, economics, the API surface, and how it compares to the alternatives.
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.
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.
Documentation
| 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 |