2026-07-26 18:40 UTCIn-site rewrite5 min readUpdated: 2026-07-26 18:50 UTC

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

HART OS is an open-source AI-native operating system that runs locally on any device, from laptops to robots, providing AI inference as a system service. It features self-improvement, federation across peers, and an OpenAI-compatible API, eliminating the need for datacenters.

SourceHacker News AIAuthor: hevolveai

Uh oh!

There was an error while loading. Please reload this page.

Notifications You must be signed in to change notification settings

Fork 1

Star 7

BranchesTags

Open more actions menu

Folders and files

NameName

Last commit message

Last commit date

Latest commit

History

2,123 Commits

.cache/42

.github

agent-ledger-opensource

claw_native

compositor

core

demo

deploy

desktop

docs

examples

hart_sdk

hartos_speech_audio

hevolvearmor

integrations

memory

nixos

scripts

security

tests

tools

.coveragerc

.dockerignore

.env.example

.gitignore

.mcp.json

.pre-commit-config.yaml

.readthedocs.yml

CHANGELOG.md

CLAUDE.md

CODE_OF_CONDUCT.md

CONTRIBUTING.md

Dockerfile

FLYWHEEL_RECOVERY_BRIEF.md

HARTOS_SPEECH.md

HART_OS_FULL_DESKTOP_SPEC.md

HART_OS_MASTER_TRACKER.md

KNOWN_ISSUES.md

LICENSE

MANIFEST.in

NOTICE

OPEN_PROBLEMS.md

README.md

SECURITY.md

_revenue_assets.md

agent.pid

agent_identity.py

boot_vm.sh

claw_bridge.pyd

compact-wsl.ps1

create_recipe.py

crossbar_server.py

cultural_wisdom.py

embedded_main.py

enable_systemd.sh

exception_collector.py

gather_agentdetails.py

hart_cli.py

hart_intelligence.py

hart_intelligence_entry.py

hart_onboarding.py

hartos_bootstrap.py

hartos_speech.py

hartos_speech_stitch.py

helper.py

helper_ledger.py

lifecycle_hooks.py

mkdocs.yml

nix_build.sh

openapi.yaml

pyproject.toml

recipe_experience.py

requirements-voice.txt

requirements.txt

reuse_recipe.py

run_debug.py

setup.py

statix.toml

threadlocal.py

Repository files navigation

Hevolve Hive Agentic Runtime

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

HART = the bare engine (pip install hart-backend, listens on :6777). 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 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.

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.

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.

Table of Contents

Why HART OS?

Open problems — what we have not solved

60-second start

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

Why HART OS?

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.

60-second start

git clone https://github.com/hertz-ai/HARTOS.git && cd HARTOS python3.10 -m venv venv && source venv/Scripts/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 (drop-in for any 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"}]}'

Live demo · Full quickstart · Nunba desktop

How it compares

HART OS OpenAI Agents LangChain AutoGen

Self-improves at runtime (auto-evolve loop + RSI-2 gate) yes no no partial

Continuous baselining vs prior snapshots yes (agent_baseline_service.py) no no no

Built-in benchmark adapters 7 (registry-driven) n/a n/a n/a

Federates across peer nodes yes (PeerLink + hash-verified) no no no

Local-first multimodal yes (llama.cpp + Whisper + 6 TTS + VLM) no partial partial

Channel adapters out of the box 31 1 (webhook) custom custom

One codebase, multiple topologies flat / regional / central hosted only library library

OpenAI-compatible endpoint yes yes bring your own bring your own

Recipe replay (cached LLM steps) yes (90% faster) no no no

Native source protection (HevolveArmor) yes n/a n/a n/a

Capabilities

Agent runtime

What it does Where

CREATE / REUSE recipe pattern Run a task once via LLM, save the trace, replay 90% faster with no LLM calls on cached steps create_recipe.py, reuse_recipe.py

GoalManager Unified goal lifecycle, guardrail-gated state machine, escalation hooks integrations/agent_engine/goal_manager.py

AgentDaemon Autonomous tick loop, circuit breaker, frozen-thread detection integrations/agent_engine/agent_daemon.py

SpeculativeDispatcher Fast draft model answers first, expert agent takes over if confidence drops speculative_dispatcher.py

ParallelDispatch ThreadPoolExecutor fan-out across SmartLedger tasks parallel_dispatch.py

SelfHealingDispatcher Catches transient failures, retries with backoff + alternative providers self_healing_dispatcher.py

96 expert agents Coding, research, marketing, product, security, ethics, ops, ... auto-dispatched per goal integrations/expert_agents/

Recipe Pattern + Aider In-process Aider backend (no subprocess) for code edits integrations/coding_agent/aider_native_backend.py

Auto-evolve, baselining, benchmarking

What it does Where

AutoEvolve loop Realtime: hypothesis -> 33-rule filter -> hive vote -> parallel sandbox -> RSI-2 gate -> federated broadcast integrations/agent_engine/auto_evolve.py

RSI-2 monotonic gate New release must beat prior baseline on every benchmark by configurable margin or PR is rejected rsi_trigger.py, pr_review_service.py

Benchmark registry 7 built-in adapters (3 sourced from HevolveAI: QuantiPhy, Embodied, Qwen). Pluggable via register_adapter() benchmark_registry.py

Per-agent baselines Per-agent snapshots at agent_data/baselines/.json, used as the regression floor agent_baseline_service.py

Coding benchmark tracker SQLite-backed coding benchmarks (coding_benchmarks.db), HumanEval / MBPP / custom suites integrations/coding_agent/benchmark_tracker.py

Hive benchmark prover Cryptographic proof that a benchmark was run on the claimed model + dataset (resists fake-score federation) hive_benchmark_prover.py

Continual learner gate Gates access to hive learning by verified compute contribution (Compute Contribution Tokens): no contribution, no learning continual_learner_gate.py

PR review service Auto-rejects PRs on baseline regression or guardrail mismatch pr_review_service.py

Upgrade orchestrator 7-stage pipeline: BUILD -> TEST -> AUDIT -> BENCHMARK -> SIGN -> CANARY -> DEPLOY upgrade_orchestrator.py

OTA service systemd service does daily check + cryptographically-verified upgrade hart-update-service.py

Hive connectivity + federation

What it does Where

PeerLink Direct P2P WebSocket mesh, trust-aware encryption (same-user devices skip overhead, cross-user E2E), works offline on LAN, across the internet, multi-device core/peer_link/

NAT traversal UDP hole-punching, STUN-style fallbacks for residential NATs core/peer_link/nat.py

Hivemind handler Tier-aware routing (flat / regional / central), connection budget per tier (10 / 50 / 200) core/peer_link/hivemind_handler.py

FederatedAggregator Equal-weighted delta merging (log1p-floor, not hardware tier). Channels: model deltas, resonance, recip

[truncated for AI cost control]