{"slug": "show-hn-hart-os-an-open-source-ai-os-built-so-frontier-ai-needs-no-datacenter", "title": "Show HN: HART OS – an open-source AI OS built so frontier AI needs no datacenter", "summary": "HART OS, an open-source AI-native operating system from Hevolve, runs locally on any device without requiring a datacenter, providing an OpenAI-compatible API via a Model Bus that serves LLM, vision, and speech to all apps. The system, currently in public alpha, uses a single Python codebase that operates on laptops, servers, edge nodes, phones, and embodied AI, with peer-to-peer federation over WebSocket and boot-time security hashes.", "body_md": "**Hevolve Hive Agentic Runtime**\n\nThe AI-native operating system for every device, from your computer to embodied AI. Local-first, federated, OpenAI-compatible.\n\nHART= the bare engine (`pip install hart-backend`\n\n, listens on`:6777`\n\n).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.= the consumer companion app, one signed client across Windows / macOS / Linux.[Nunba]\n\n**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`\n\n, 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.\n\nYou 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.\n\nThis 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.\n\nStatus: 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].\n\nIf you would rather argue than patch, start atNine 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.[Open problems].\n\n[Why HART OS?](#why-hart-os)[Open problems](/hertz-ai/HARTOS/blob/main/OPEN_PROBLEMS.md)— what we have not solved[60-second start](#60-second-start)[How it compares](#how-it-compares)[Capabilities](#capabilities)[Hello, agent](#hello-agent)[Architecture map](#architecture-map)[API surface](#api-surface)[How auto-evolve works](#how-auto-evolve-works)[How hive connectivity works](#how-hive-connectivity-works)[Topology](#topology)[Build / extend](#build--extend)[Economics (for node operators)](#economics-for-node-operators)[Documentation index](#documentation-index)[License](#license)\n\nMost 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.\n\nHART 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.\n\nThat has a practical consequence worth stating plainly: **every device\nbecomes the same target.** The runtime driving a laptop is the runtime\ndriving a robot, so a robot's AI access is just another Model Bus call, and\ncode written against `:6777/v1/chat/completions`\n\nruns unchanged on both.\n\n**If you are here to contribute**, the parts that most need outside eyes are\nthe auto-evolve loop (`autoresearch_loop.py`\n\n), the guardrails that gate every\nself-improvement (`hive_guardrails.py`\n\n), and the 31 channel adapters — the\nmost self-contained place to start. See [CONTRIBUTING.md](/hertz-ai/HARTOS/blob/main/CONTRIBUTING.md).\n\n```\ngit clone https://github.com/hertz-ai/HARTOS.git && cd HARTOS\npython3.10 -m venv venv && source venv/Scripts/activate   # Windows: venv\\Scripts\\activate.bat\npip install -r requirements.txt\necho \"OPENAI_API_KEY=sk-...\" > .env       # or GROQ_API_KEY, or none for local llama.cpp\npython hart_intelligence_entry.py         # listens on :6777\n# OpenAI-compatible (drop-in for any OpenAI SDK / LangChain / LiteLLM / Aider / Continue)\ncurl -X POST http://localhost:6777/v1/chat/completions \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\"model\": \"hevolve\", \"messages\": [{\"role\": \"user\", \"content\": \"Hello\"}]}'\n```\n\n[Live demo](https://hevolve.ai) · [Full quickstart](https://docs.hevolve.ai/getting-started/quickstart/) · [Nunba desktop](https://github.com/hertz-ai/Nunba)\n\n| HART OS | OpenAI Agents | LangChain | AutoGen | |\n|---|---|---|---|---|\n| Self-improves at runtime (auto-evolve loop + RSI-2 gate) | yes | no | no | partial |\n| Continuous baselining vs prior snapshots | yes (`agent_baseline_service.py` ) |\nno | no | no |\n| Built-in benchmark adapters | 7 (registry-driven) | n/a | n/a | n/a |\n| Federates across peer nodes | yes (PeerLink + hash-verified) | no | no | no |\n| Local-first multimodal | yes (llama.cpp + Whisper + 6 TTS + VLM) | no | partial | partial |\n| Channel adapters out of the box | 31 | 1 (webhook) | custom | custom |\n| One codebase, multiple topologies | flat / regional / central | hosted only | library | library |\n| OpenAI-compatible endpoint | yes | yes | bring your own | bring your own |\n| Recipe replay (cached LLM steps) | yes (90% faster) | no | no | no |\n| Native source protection (HevolveArmor) | yes | n/a | n/a | n/a |\n\n| What it does | Where | |\n|---|---|---|\nCREATE / REUSE recipe pattern |\nRun a task once via LLM, save the trace, replay 90% faster with no LLM calls on cached steps | `create_recipe.py` , `reuse_recipe.py` |\nGoalManager |\nUnified goal lifecycle, guardrail-gated state machine, escalation hooks | `integrations/agent_engine/goal_manager.py` |\nAgentDaemon |\nAutonomous tick loop, circuit breaker, frozen-thread detection | `integrations/agent_engine/agent_daemon.py` |\nSpeculativeDispatcher |\nFast draft model answers first, expert agent takes over if confidence drops | `speculative_dispatcher.py` |\nParallelDispatch |\nThreadPoolExecutor fan-out across SmartLedger tasks | `parallel_dispatch.py` |\nSelfHealingDispatcher |\nCatches transient failures, retries with backoff + alternative providers | `self_healing_dispatcher.py` |\n96 expert agents |\nCoding, research, marketing, product, security, ethics, ops, ... auto-dispatched per goal | `integrations/expert_agents/` |\nRecipe Pattern + Aider |\nIn-process Aider backend (no subprocess) for code edits | `integrations/coding_agent/aider_native_backend.py` |\n\n| What it does | Where | |\n|---|---|---|\nAutoEvolve loop |\nRealtime: hypothesis -> 33-rule filter -> hive vote -> parallel sandbox -> RSI-2 gate -> federated broadcast | `integrations/agent_engine/auto_evolve.py` |\nRSI-2 monotonic gate |\nNew release must beat prior baseline on every benchmark by configurable margin or PR is rejected | `rsi_trigger.py` , `pr_review_service.py` |\nBenchmark registry |\n7 built-in adapters (3 sourced from HevolveAI: QuantiPhy, Embodied, Qwen). Pluggable via `register_adapter()` |\n`benchmark_registry.py` |\nPer-agent baselines |\nPer-agent snapshots at `agent_data/baselines/<agent_id>.json` , used as the regression floor |\n`agent_baseline_service.py` |\nCoding benchmark tracker |\nSQLite-backed coding benchmarks (`coding_benchmarks.db` ), HumanEval / MBPP / custom suites |\n`integrations/coding_agent/benchmark_tracker.py` |\nHive benchmark prover |\nCryptographic proof that a benchmark was run on the claimed model + dataset (resists fake-score federation) | `hive_benchmark_prover.py` |\nContinual learner gate |\nGates access to hive learning by verified compute contribution (Compute Contribution Tokens): no contribution, no learning | `continual_learner_gate.py` |\nPR review service |\nAuto-rejects PRs on baseline regression or guardrail mismatch | `pr_review_service.py` |\nUpgrade orchestrator |\n7-stage pipeline: BUILD -> TEST -> AUDIT -> BENCHMARK -> SIGN -> CANARY -> DEPLOY | `upgrade_orchestrator.py` |\nOTA service |\nsystemd service does daily check + cryptographically-verified upgrade | `hart-update-service.py` |\n\n| What it does | Where | |\n|---|---|---|\nPeerLink |\nDirect 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/` |\nNAT traversal |\nUDP hole-punching, STUN-style fallbacks for residential NATs | `core/peer_link/nat.py` |\nHivemind handler |\nTier-aware routing (flat / regional / central), connection budget per tier (10 / 50 / 200) | `core/peer_link/hivemind_handler.py` |\nFederatedAggregator |\nEqual-weighted delta merging (log1p-floor, not hardware tier). Channels: model deltas, resonance, recipes, event counters | `federated_aggregator.py` |\nFederated gradient protocol |\nOptional weight-level sync interface (Phase 2, not active); the hive shares derived, signed, privacy-scoped learning, never raw data or model weights | `federated_gradient_protocol.py` |\nFederation handshake |\nPeer presents guardrail hash; mismatch = connection refused; re-verified every 300 s | `integrations/social/federation.py` |\nGossip + verification |\nTier-aware gossip with cert verification, peer-verified task results | `integrity_service.py` , gossip layer |\nEventBus + WAMP bridge |\nIn-process EventBus auto-publishes to Crossbar WAMP when `CBURL` env set; remote nodes subscribe to `com.hartos.event.*` topics |\n`core/platform/events.py` |\nFederated equality |\nTier multipliers replaced with `log1p(interactions)` floor=1.0. A Pi node has the same vote weight as a GPU rack at equal participation |\n(federation rule) |\nHive contests |\nOpen contests on the network; agents propose, hive votes, winners federate | `hive_contest.py` |\nNative hive loader |\nLoads closed-source HevolveAI binary at runtime with master-key signature verification, falls back to stub | `security/native_hive_loader.py` |\n\n| What it does | Where | |\n|---|---|---|\nThought experiment |\nPropose an idea, community votes (humans + agents, confidence-weighted), believers pledge compute | `api_thought_experiments.py` , `experiment_discovery_service.py` |\nComputePledge |\nSpark-budget pledge to a specific experiment, redeemable on idle GPUs across the network | `compute_borrowing.py` , `compute_mesh_service.py` |\nType-aware agents |\n`software` / `traditional` / `physical_ai` / `code_evolution` agent types per experiment |\n`dispatch.py` |\nAgent Hive View |\nReal-time swarm visualization, encounter lines (collaboration), inject mid-experiment variables | `api_hive_contest.py` + Nunba UI |\nReasoning trace |\nPer-agent reasoning capture, queryable post-completion (\"interview the agent\") | `reasoning_trace.py` |\n\n| What it does | Where | |\n|---|---|---|\n15 LLM providers |\nLocal llama.cpp, OpenAI, Anthropic, Google Gemini, Groq, Mistral, DeepSeek, OpenRouter, Together, Fireworks, Cohere, Perplexity, Hugging Face, Ollama, custom OpenAI-compatible | `integrations/providers/` |\nUniversal gateway |\nOne router, cost / latency / capability scoring, AES-256 keys at rest (PBKDF2 KDF) | `model_registry.py` , `model_bus_service.py` |\nSpeculative decoding |\nQwen3-0.8B draft + Qwen3-4B main, ~300 ms TTFT on consumer hardware | `speculative_dispatcher.py` |\nFaster-Whisper STT |\nLocal STT, multi-lang, GPU-accelerated when available | `integrations/service_tools/whisper_tool.py` |\nMiniCPM VLM |\nVision-language model for camera + screenshot reasoning | `integrations/vision/minicpm_server.py` |\n6 TTS engines |\nIndic Parler (22 Indic + EU), Chatterbox Turbo (English expressive), Kokoro (English neural), CosyVoice3 (en/zh), F5 (zero-shot voice clone), Piper (CPU fallback) | `integrations/channels/media/` , `tts.py` |\nAuto-VRAM tiering |\nDetects GPU + free VRAM, picks largest model that fits with headroom; degrades gracefully on 6 GB cards | `core/gpu_tier.py` , `vram_manager.py` |\n\n| Surface | Adapters |\n|---|---|\nCore chat |\nTelegram, Discord, Slack, WhatsApp, Signal, iMessage (BlueBubbles), Teams, Web SPA |\nEnterprise |\nMattermost, Matrix, Nextcloud, Rocket.Chat |\nSocial |\nMessenger, Instagram, Twitter / X, LINE, Viber, WeChat, Twitch |\nDecentralized |\nNostr, Tlon (Urbit), OpenProse |\nBridge variants |\nTelegramUser, DiscordUser, BlueBubbles, ZaloUser |\nOther |\nEmail (IMAP/SMTP), SMS (Twilio), Google Chat |\n\n`ResponseRouter`\n\nfan-out + WAMP desktop mirror; per-channel agent + prompt assignment; AutoGen-side tools so agents can register/send via channels themselves. [Catalog endpoint](#api-surface): `GET /api/social/channels/catalog`\n\n.\n\n| What it does | Where | |\n|---|---|---|\nAgentPersonality |\n8-dim personality dataclass (warmth, formality, verbosity, ...), generates per-agent system prompt | `core/agent_personality.py` |\nUserResonanceProfile |\n8-dim continuous floats (0-1), stored at `agent_data/resonance/<user_id>.json` |\n`core/resonance_profile.py` |\nResonanceTuner |\nEMA tuning (alpha 0.15) from dialogue signals, federated-delta export, oscillation detector | `core/resonance_tuner.py` |\nResonanceIdentifier |\nThin proxy that dispatches biometric ops (face, voice) to HevolveAI sibling. No ML in HART OS. | `core/resonance_identifier.py` |\n\n| What it does | Where | |\n|---|---|---|\nMemoryGraph |\nSQLite FTS5 + `memory_links` table, provenance-aware |\n`core/memory/` |\nSimpleMem |\nSemantic vector search for long-term recall | (vector store) |\nPersistentChatHistory |\nSingle shared buffer for LangChain + AutoGen (zero parallel paths) | (conversation buffer) |\nConversationEntry |\nCross-channel unified conversation log | `chat_messages.py` |\nEmbedding delta |\nPer-node embedding deltas federated back to the hive | `embedding_delta.py` |\n\n| What it does | Where | |\n|---|---|---|\n3-tier topology |\nflat (single device, SQLite WAL) -> regional (LAN/VPN, MySQL QueuePool) -> central (cloud, Docker mesh) | env-detected, single code path |\nSmartLedger |\n15-state task lifecycle, parallel + sequential dispatch, ledger persistence per user | `helper_ledger.py` , `lifecycle_hooks.py` |\nComputeMesh |\nMatch compute supply (idle GPUs, Nunba desktops) to demand (inference, training, experiments) | `compute_mesh_service.py` |\nComputeEscrow |\nPersistent escrow for pledged compute, replaces in-memory `_compute_debts` |\n(DB table in `models.py` ) |\nBudgetGate |\nLocal models (llama / mistral / phi / qwen / groq) cost 0 Spark; cloud models per-1k-token cost | `budget_gate.py` |\nMeteredAPIUsage |\nPer-call metering for cost recovery on metered providers | `models.py: MeteredAPIUsage` |\nNodeComputeConfig |\nPer-node policy: GPU hours served, total inferences, energy contributed, electricity rate, cause alignment | `models.py: NodeComputeConfig` |\nAdService |\nPeer-witnessed impressions (70% witnessed payout, 50% unwitnessed) | `ad_service.py` |\nHostingRewardService |\nReward score weighted by gpu_hours / inferences / energy / api_costs | `hosting_reward_service.py` |\nRevenueAggregator |\n90 / 9 / 1 split (users / infra / central). Single source of truth for all revenue queries | `revenue_aggregator.py` |\nCompute democracy |\nLogarithmic reward scaling, max 5% influence per entity, +20% diversity bonus | (constitutional rule, enforced) |\nAudit invariant |\nCombined compute of nodes auditing any single node must exceed that node's compute | (network self-enforces) |\n\n| What it does | Where | |\n|---|---|---|\nHiveGuardrails |\n10-class guardrail network. Frozen Python (`__slots__=()` , blocked `__setattr__` ), SHA-256 hash verified at boot + every 300 s. Gossip peers reject mismatched hashes. |\n`security/hive_guardrails.py` |\nMasterKey |\nEd25519. Signs releases, triggers `HiveCircuitBreaker` (network-wide kill switch). `MASTER_PUBLIC_KEY_HEX` is the immutable trust anchor. |\n`security/master_key.py` |\n3-tier cert chain |\ncentral -> regional -> local, short-TTL local certs | `security/key_delegation.py` |\nRuntimeMonitor |\nBackground tamper-detection daemon, frozen-thread detection, auto-restart | `security/runtime_monitor.py` , `security/node_watchdog.py` |\nImmutableAuditLog |\nSHA-256 hash chain, `AuditLogEntry` table, tamper detection on read |\n`security/immutable_audit_log.py` |\nTool allowlist |\nFAST = read-only, BALANCED = read-write, EXPERT = unrestricted | `tool_allowlist.py` |\nActionClassifier |\nDestructive pattern detection, `PREVIEW_PENDING` / `APPROVED` states for risky actions |\n`security/action_classifier.py` |\nDLP engine |\nPII scan + redact (email, phone, SSN, credit card), outbound gating | `security/dlp_engine.py` |\nRate limiter |\nRedis-backed; goal_create limited to 10/hour, /chat at 30/min on central instance | `security/rate_limiter_redis.py` |\nBoot hardening |\nTier authorization at boot, dev mode forced off on central (3 layers), TLS check, secret validation, DB encryption check | `__init__.py` , `start_cloud.sh` |\nOrigin attestation |\nCryptographic origin proof. Federation handshake requires signed attestation. Anti-rebranding. | `security/origin_attestation.py` |\nHSM trust |\nHSM provider abstraction for key custody | `security/hsm_trust.py` , `security/hsm_provider.py` |\n\n| What it does | Where | |\n|---|---|---|\nAES-256-GCM at rest |\nPython modules encrypted at rest with derived key | `core/security/` (Rust-native) |\nEd25519 key derivation |\nnode_identity -> HKDF -> AES key | (key derivation) |\nBCC mode |\nCython compile-to-C, irreversible | (build flag) |\nRFT mode |\nAST symbol renaming | (build flag) |\nAnti-debug, anti-tamper |\nProcess introspection guards, license management | (Rust binary) |\nTest coverage |\n54 tests (unit + integration + stress + e2e + pen) | `tests/` |\n\n| What it does | Where | |\n|---|---|---|\nServiceRegistry |\nDynamic service discovery + lifecycle | `core/platform/registry.py` |\nAppRegistry |\n9 manifest types (chat, panel, channel, agent, plugin, ...) | `core/platform/app_registry.py` |\nAppManifest + validator |\nSchema-validated app manifests | `core/platform/manifest_validator.py` |\nEventBus |\nIn-process pub/sub + WAMP bridge for cross-node events | `core/platform/events.py` |\nBootstrap |\nMigrates 55 shell_manifest panels, registers services, detects native apps, loads extensions, starts PeerLink | `core/platform/bootstrap.py` |\nCapabilityRouter |\nRoutes capability requests to the right service | `core/platform/registry.py` |\nEnvironmentManager |\nOS detection (NixOS / generic Linux / macOS / Windows), env-specific routing | `core/platform/agent_environment.py` |\nExtensions |\nSandboxed extension loader with manifest gating | `core/platform/extensions.py` , `extension_sandbox.py` |\nPrGuardian |\nAuto-reject PR on guardrail / baseline regression | `core/platform/pr_guardian.py` |\n\n| What it does | Where | |\n|---|---|---|\nShell APIs |\n40+ OS routes (`shell_os_apis.py` ), 9 desktop features (`shell_desktop_apis.py` ), 6 system features (`shell_system_apis.py` ) |\n`integrations/agent_engine/shell_*.py` |\nApp installer |\nCross-platform: Nix, Flatpak, AppImage, Wine, Android, Darling. Magic-bytes detection | `integrations/social/app_installer.py` |\nNixOS modules |\nOTA, NVIDIA, LUKS, firewall, power, accessibility, CUPS, nightlight, IME | (nix flakes) |\nLiquid UI service |\nMD3 design tokens, JS component lib (dsBtn, dsCard, dsModal) | `liquid_ui_service.py` |\nTheme service |\nEventBus-driven theme distribution | `theme_service.py` |\nNative remote desktop |\nRustDesk + Sunshine wrappers, 3-tier transport (DirectWS / WAMP / WireGuard), OTP session auth, DLP scan, peripheral bridge, DLNA casting | `integrations/remote_desktop/` |\nSystem panels |\n36 panels (model catalog, channel pairing, agent dashboard, hive view, ...) | `shell_manifest.py` |\nUnified hart CLI |\n21 subcommands: chat, code, social, agent, expert, pay, mcp, compute, channel, a2a, skill, voice, vision, desktop, remote, screenshot, tools, recipe, status, repomap, schedule, zeroshot | `hart_cli.py` |\n\n| What it does | Where | |\n|---|---|---|\nVision sidecar |\nMiniCPM VLM server, screenshot + camera frame reasoning | `integrations/vision/` |\nEmbodied AI bridge |\nFrame store + VLM grounding + actuator dispatch (universal robot API) | `integrations/vision/` , `integrations/robotics/` |\nOpenClaw |\nComputer-use action library | `integrations/openclaw/` |\n\n**Agent Protocol 2**(e-commerce, payments) -`integrations/ap2/`\n\n**Google A2A**(dynamic agent registry) -`integrations/google_a2a/`\n\n**MCP (Model Context Protocol)** servers -`integrations/mcp/`\n\n**Internal A2A**(task delegation between agents) -`integrations/internal_comm/`\n\n**Skills**(reusable capability bundles) -`integrations/skills/`\n\n**Marketing tools**(campaigns, content gen, video orchestrator) -`integrations/marketing/`\n\n,`marketing_tools.py`\n\n,`video_orchestrator.py`\n\n**Trading agents**(SmartLedger-tracked, budget-gated) -`trading_tools.py`\n\n**Coding agent**(idle compute -> distributed code tasks via Aider in-process) -`integrations/coding_agent/`\n\n**Web crawler**-`integrations/web_crawler.py`\n\n**Kids learning**(25+ educational game templates) -`api_games.py`\n\n``` python\nimport requests\n\n# 1. CREATE: teach a task once, save the trace as a recipe\nrequests.post(\"http://localhost:6777/chat\", json={\n    \"user_id\": \"alice\",\n    \"prompt_id\": \"research_assistant\",\n    \"prompt\": \"Find arXiv papers from the last week on speculative decoding\",\n    \"create_agent\": True,\n})\n\n# 2. REUSE: replay the recipe, no LLM calls on cached steps\nfor query in [\"mixture of experts\", \"constitutional AI\"]:\n    res = requests.post(\"http://localhost:6777/chat\", json={\n        \"user_id\": \"alice\",\n        \"prompt_id\": \"research_assistant\",\n        \"prompt\": query,\n    })\n    print(res.json()[\"output\"])\n```\n\nCustom tools, channel bindings, agent plugins: [docs.hevolve.ai/agent-plugin](https://docs.hevolve.ai/agent-plugin/).\n\n``` php\nHART OS  (port 6777)\n|-- Engine            CREATE -> save Recipe -> REUSE (90% faster replay)\n|-- Agent runtime     GoalManager . AgentDaemon . SpeculativeDispatch . ParallelDispatch . AutoEvolve\n|-- Auto-evolve       Hypothesis -> 33-rule filter -> hive vote -> sandbox -> RSI-2 gate -> federate\n|-- Baselining        agent_baseline_service . benchmark_registry . benchmark_tracker . hive_benchmark_prover\n|-- Memory            Shared LangChain + AutoGen buffer (zero parallel paths) . MemoryGraph . SimpleMem\n|-- Channels (31)     ResponseRouter fan-out + WAMP desktop mirror + per-channel agent binding\n|-- Providers (15)    Universal gateway . AES-256 keys . cost/latency/capability routing\n|-- Multimodal        Whisper STT . 6 TTS engines . MiniCPM VLM . VRAM-tiered\n|-- Hive              PeerLink P2P (NAT-traversed) . FederatedAggregator (equal-weighted)\n|                     Gossip + verification . hash-gated handshake . EventBus + WAMP bridge\n|-- Idea Engine       Thought experiments . ComputePledge . type-aware agents . Hive View\n|-- Compute           3-tier topology (flat/regional/central) . SmartLedger . ComputeMesh . ComputeEscrow\n|-- Economics         AdService (70/50) . RevenueAggregator (90/9/1) . log-scaled compute democracy\n|-- Security          33 guardrails . Ed25519 master key . 3-tier cert chain . RuntimeMonitor\n|                     ImmutableAuditLog . tool allowlist . ActionClassifier . DLP . rate limiter\n|-- HevolveArmor      AES-256-GCM modules . BCC compile-to-C . RFT AST renaming . anti-debug\n|-- Platform          ServiceRegistry . AppRegistry . AppManifest . Bootstrap . EnvironmentManager\n|-- Desktop           Shell APIs . app installer . NixOS modules . LiquidUI . themes . remote desktop\n|-- CLI               hart (21 subcommands) . OpenAI-compatible client . Aider in-process backend\n`-- Other             AP2 . Google A2A . MCP . skills . marketing . trading . coding agent . vision\n```\n\nFull architecture: [docs.hevolve.ai/architecture](https://docs.hevolve.ai/architecture/overview/).\n\n```\nPOST /chat                                Core agent (LangChain + AutoGen)\nPOST /v1/chat/completions                 OpenAI-compatible (drop-in)\nPOST /time_agent                          Scheduled task execution\nPOST /visual_agent                        VLM + computer use\nGET  /status                              Health\n\n# Hive + thought experiments\nPOST /api/social/experiments/auto-evolve  Start evolution cycle\nGET  /api/social/hive/active              All parallel agents (Hive View)\nPOST /api/social/hive/<id>/inject         Inject mid-experiment variable\nGET  /api/social/tracker/experiments      Experiment tracker with task progress\n\n# Channels\nGET  /api/social/channels/catalog         All 31 channels + capabilities\nPOST /api/social/channels/bindings        Bind a channel to an agent\nPOST /api/social/channels/pair/generate   QR for cross-device pairing\n\n# Goals + dashboard\nPOST /api/goals                           Create an autonomous goal\nGET  /api/social/dashboard/agents         Truth-grounded agent overview\n\n# Compute + earnings\nGET  /api/compute-earnings/summary        Per-node earnings breakdown\nGET  /api/settings/compute                Local compute policy\nPUT  /api/settings/compute                Update policy\nPUT  /api/settings/provider               Provider config (cause alignment, electricity rate)\nPUT  /api/settings/provider/join          Opt into provider role\n\n# A2A protocol\nGET  /a2a/<prompt_id>_<flow_id>/.well-known/agent.json\nPOST /a2a/<prompt_id>_<flow_id>/execute\n```\n\n195+ endpoints total. [Full reference](https://docs.hevolve.ai/api/core/).\n\n```\nchat / tool call / observed outcome\n   v\nautoresearch hypothesis            (what could improve next response)\n   v\n33-rule guardrail filter           (immutable, hash-verified, rejects unsafe)\n   v\nhive vote                          (humans + agents, confidence-weighted)\n   v\ntop-k dispatched to parallel sandboxes\n   v\nbenchmark replay vs baseline       (per-agent baseline at agent_data/baselines/)\n   v\nRSI-2 monotonic gate               (must beat last commit on every metric)\n   v\nPR review                          (auto-rejects regression, hive contests merge)\n   v\nupgrade orchestrator               (BUILD -> TEST -> AUDIT -> BENCHMARK -> SIGN -> CANARY -> DEPLOY)\n   v\nFederatedAggregator broadcasts the delta to peer nodes\n   v\nhart-update-service (OTA) pulls signed upgrade on every node\n```\n\nOwner can pause, resume, or veto at any stage. [Mechanism details](https://docs.hevolve.ai/features/overview/).\n\n``` php\nSame-user devices\n  trust = SAME_USER          -> no encryption (user_id auth), LAN or WAN\n  \nCross-user peers\n  trust = PEER               -> E2E encryption (per-link key)\n  \nThrough relay (NAT-bound)\n  trust = RELAY              -> E2E encryption (relay can't read)\n\nCrossbar = safety measure (telemetry metadata + kill switch). Never content path.\n\nConnection budget per tier:  flat=10  regional=50  central=200\nALL tiers participate equally in hive consensus.\nFederation handshake = byte-for-byte guardrail hash match. Mismatch -> refused.\n```\n\nPeerLink is wired into bootstrap, gossip, federation, compute_mesh, world_model_bridge. [Wire format](/hertz-ai/HARTOS/blob/main/docs/architecture/peer_link.md).\n\n| Storage | Network | Use case | |\n|---|---|---|---|\n`flat` |\nSQLite WAL | localhost | Single device, laptop, Raspberry Pi, Nunba desktop |\n`regional` |\nMySQL QueuePool | LAN / VPN | Office cluster, family hive, edge node |\n`central` |\nMySQL + Docker | public mesh | Federated cloud workers |\n\nSame code path. Env-detected at boot via `HART_OS_MODE`\n\nor `/etc/os-release ID=hart-os`\n\n. Port resolution: override > env var > OS / app mode default.\n\n| Audience | Where to start |\n|---|---|\nDevelopers |\n|\n\n[Add a channel adapter](https://docs.hevolve.ai/features/overview/)- wire a new chat surface[Add a provider](https://docs.hevolve.ai/neuro-providers/)- new LLM / TTS / STT / VLM backend[Add a benchmark](/hertz-ai/HARTOS/blob/main/integrations/agent_engine/benchmark_registry.py)- register an adapter, gets RSI-2 protection[PeerLink wire format](/hertz-ai/HARTOS/blob/main/docs/architecture/peer_link.md)- direct P2P protocol[Federation protocol](/hertz-ai/HARTOS/blob/main/docs/architecture/FEDERATION.md)- hash-gated peer handshake[HART SDK](/hertz-ai/HARTOS/blob/main/docs/developer/sdk.md)- Python client +`hart`\n\nCLI**Node operators**[Run a node](https://docs.hevolve.ai/provider/joining/)- lend compute, host a region, earn from witnessed traffic[Compute settings](#api-surface)- cause alignment, electricity rate, idle policy**End users**[Nunba desktop](https://github.com/hertz-ai/Nunba)- chat / social / encounter app** Security reviewers**[Guardrail network](/hertz-ai/HARTOS/blob/main/security/hive_guardrails.py)·[Master key](/hertz-ai/HARTOS/blob/main/security/master_key.py)·[Audit log](/hertz-ai/HARTOS/blob/main/security/immutable_audit_log.py)·[DLP](/hertz-ai/HARTOS/blob/main/security/dlp_engine.py)**Researchers**[Auto-evolve](/hertz-ai/HARTOS/blob/main/integrations/agent_engine/auto_evolve.py)·[RSI-2 trigger](/hertz-ai/HARTOS/blob/main/integrations/agent_engine/rsi_trigger.py)·[Federated aggregator](/hertz-ai/HARTOS/blob/main/integrations/agent_engine/federated_aggregator.py)·[Hive contests](/hertz-ai/HARTOS/blob/main/integrations/agent_engine/hive_contest.py)Front it with `/v1/chat/completions`\n\n(any OpenAI client), the [ hart CLI](/hertz-ai/HARTOS/blob/main/docs/developer/sdk.md), or build for the desktop with\n\n[Nunba](https://github.com/hertz-ai/Nunba).\n\n```\nAdvertisers pay for witnessed impressions\n   |\n   v\nAd service           70% witnessed view, 50% unwitnessed\n   |\n   v\nCompute democracy    log scaling, max 5% influence per entity, +20% diversity bonus\n   |\n   v\n   90% -> Contributors  (compute, hosting, training)\n    9% -> Infrastructure (regional hosts, bandwidth)\n    1% -> hevolve.ai     (master key, central coordination, security)\n```\n\nIdle GPU in Tokyo serves Berlin. Reward score weighted by `gpu_hours`\n\n, `inferences`\n\n, `energy_kwh`\n\n, `api_costs`\n\n. Per-node `cause_alignment`\n\nand `electricity_rate_kwh`\n\naffect dispatch routing. [Joining the Hive](https://docs.hevolve.ai/provider/joining/).\n\n| Section | What's in it |\n|---|---|\n|\n\n[Quickstart](https://docs.hevolve.ai/getting-started/quickstart/)[Features](https://docs.hevolve.ai/features/overview/)[API](https://docs.hevolve.ai/api/core/)`/chat`\n\n, OpenAI-compatible, 195+ endpoints", "url": "https://wpnews.pro/news/show-hn-hart-os-an-open-source-ai-os-built-so-frontier-ai-needs-no-datacenter", "canonical_source": "https://github.com/hertz-ai/HARTOS", "published_at": "2026-07-26 18:40:08+00:00", "updated_at": "2026-07-26 18:52:09.930960+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-infrastructure", "ai-agents", "ai-products"], "entities": ["Hevolve", "HART OS", "HART", "Model Bus", "PeerLink", "Liquid Shell", "Nunba", "OpenAI"], "alternates": {"html": "https://wpnews.pro/news/show-hn-hart-os-an-open-source-ai-os-built-so-frontier-ai-needs-no-datacenter", "markdown": "https://wpnews.pro/news/show-hn-hart-os-an-open-source-ai-os-built-so-frontier-ai-needs-no-datacenter.md", "text": "https://wpnews.pro/news/show-hn-hart-os-an-open-source-ai-os-built-so-frontier-ai-needs-no-datacenter.txt", "jsonld": "https://wpnews.pro/news/show-hn-hart-os-an-open-source-ai-os-built-so-frontier-ai-needs-no-datacenter.jsonld"}}