OpenHuman: a local brain, a fleet orchestrator, and a deep researcher

Everything worth knowing about tinyhumansai/openhuman: a local-first personal AI agent in Rust and React (Tauri/CEF) that builds a persistent memory of the user’s data, orchestrates agent fleets over durable graphs, and automates tasks through visual workflows the agent itself proposes.

---

What OpenHuman is

OpenHuman is an open-source desktop application that the tinyhumansai organization describes as “your personal AI super intelligence.” It’s not a language model or an inference server — it’s an agent harness with its own core, an identity-bearing user interface (mascot, themes, voice), and an optional subscription plan that bundles models, search, and media generation.

The README sums it up as three things: a brain that builds a local, persistent memory of the user’s world; an orchestrator that runs agent fleets over durable graphs; and a deep researcher that sweeps the user’s data and the web before they finish typing the question. The project explicitly calls itself early beta (“Expect rough edges”) and draws a line against AGI: “OpenHuman is not AGI. But it is a meaningful architectural step closer, with better memory, better orchestration, and better tooling.”

The core is written in Rust (60% of the codebase, including the openhuman-core binary and the JSON-RPC surface) and the interface in TypeScript/React on top of a Tauri with CEF shell (Chromium Embedded Framework). The repository includes 53 pages of GitBook documentation, README translations into Chinese, Japanese, Korean, German, and Urdu, and its own Discord and subreddit community.

Origin: “We are killing OpenClaw”

The repository was created on February 18, 2026 by the tinyhumansai organization, and its first release tag (v0.49.32) appeared on March 31, 2026. The project’s public face is Steven Enamakel (senamakel), creator and top contributor (6,589 contributions per the API), identified on his GitHub profile as part of @tinyhumansai.

The launch came with a deliberate provocation. On April 20, 2026, Enamakel posted the opening tweet on X: “We are killing OpenClaw. Introducing OpenHuman, a self-learning AI with memory that gets better the more you use it. Comment ‘Openhuman’ and I’ll send the download link.” OpenClaw is the most popular open-source personal agent of the moment (see the comparison below); the announcement named it head-on as the rival to take down, and the project’s official YouTube channel titled a video the same day “We killed OpenClaw.” (~3,757 views). The marketing strategy was direct confrontation with the sector’s de facto standard, not a technical announcement.

The README claims that “within a week of launch, OpenHuman became the number one trending repo on GitHub for nine straight days.” That’s a project-stated figure I didn’t independently verify; a user’s tweet quoted on the official site (slash1s) says it “just hit #7 trending overnight,” which suggests the trending spike was real even though the exact numbers aren’t verifiable from the sources retrieved.

The ideological thread of the memory design traces back to Andrej Karpathy: Karpathy’s “LLM Knowledge Bases” tweet from April 2, 2026 (60,887 likes, 7,388 retweets, retrieved via fxtwitter) describes his practice of using LLMs to build personal Markdown knowledge bases. OpenHuman explicitly presents itself as “the Karpathy-style super intelligence layer for your AI agents,” and its memory (scored Markdown trees in SQLite, mirrored as an Obsidian vault) is the implementation of that recipe. A third-party video titled “The Karpathy-Style Super Intelligence Layer for your AI Agents (OpenHuman)” (Build Things With AI, ~3,483 views) uses that same connection as its hook.

Philosophy and principles

Principles verifiable in the README and official documentation:

• Local-first: data is compressed and stored in SQLite on the user’s own machine, “no black-box vector soup.” The README links directly to the Obsidian vault as evidence that the memory is human-readable and human-editable.
• Persistent memory as the core advantage: the thesis is that “most agents start cold” and take days or weeks before becoming useful; OpenHuman markets itself as the first harness that “knows you in minutes, not weeks,” thanks to the 20-minute auto-fetch and Memory Trees.
• UI-first and human: “install a working agent in a few clicks, no config files, no terminal.” The mascot that talks, reacts, and remembers the user is a first-class feature, not decoration.
• Privacy with a switch: Privacy Mode is “a toggle, and no inference leaves your machine, enforced in the Rust core,” with on-device encrypted data, secrets in the OS keyring, an approval gate, and optional sandboxing.
• Orchestrator, not chatbot: instead of a single-agent loop, OpenHuman runs graphs with checkpoints that can pause for humans, survive restarts, and resume; sub-agents go up to three levels deep; stuck ones return root-cause reports.
• One subscription, not a lock-in: the model-routing approach picks the right LLM per workload on top of a subscription, but lets any job be pointed at bring-your-own keys or a local Ollama model, mixing all three modes freely.
• Minimizing vendor sprawl: against the “bring-your-own-everything” model of OpenClaw and Hermes, OpenHuman bundles search (Exa), models, image/video generation, and 17 messaging channels into a single account.

How it works

The documented architecture (GitBook, developing/architecture and developing/architecture/agent-harness pages) is organized into layers:

1. Rust core (openhuman-core): a JSON-RPC process on local port 7788 by default; runs memory, orchestration, native tools, and Privacy Mode.

2. Desktop shell (Tauri + CEF): a React frontend that talks to the core; there’s also a “child” mode where the shell manages the embedded core’s token.
3. The brain: Memory Tree compresses documents, emails, and chats into scored Markdown trees stored in SQLite; Obsidian Wiki mirrors those trees as an editable vault; Auto-fetch connects 100+ OAuth integrations and feeds the brain every 20 minutes; TokenJuice compresses tool output before it reaches the model (“up to 80% fewer tokens, same information”).

4. The orchestrator: tinyagents (a sibling open-source repository) runs turns as graphs with checkpoints; tinyflows runs durable workflows; an “always-on split brain” combines a fast triage (reflex) agent with a deep-reasoning core delegated to work fleets, directed by a “subconscious.”

5. The researcher: web search managed by Exa included in the subscription (or with a bring-your-own key), a scraper, a real browser, native in-process Whisper voice, image generation (Seedream/SeedEdit), and video (Seedance/Veo).

6. Channels: 17 messaging channels (Telegram, Discord, Slack, WhatsApp, Signal, iMessage…) plus native email (IMAP IDLE + SMTP). The docs also list the ability to join Meet/Zoom/Teams/Webex meetings with voice and live transcription (a README claim).
7. Agent economy: an @handle on tiny.place enables agent-to-agent orchestration encrypted with the Signal protocol, with rewards and trade in USDC via x402; “keys never touch disk.”

Workflows are the feature that differentiates the product most in practice: the agent proposes the automation, the user reviews it on a visual canvas and saves it; saved flows are durable, trigger on a schedule, webhook, or channel event, survive restarts, and gate side effects behind human approval.

The ecosystem

tinyhumansai organization repositories

The GitHub API returns 41 public repositories in the organization. The most relevant by stars (measured August 30, 2026):

Repository	Stars	Forks	Role
tinyhumansai/openhuman	38,875	3,817	Main product
tinyhumansai/tinycortex	249	39	“The fastest AI memory model — your second brain”
tinyhumansai/tiny.place	131	27	“A social economy for autonomous AI agents”
tinyhumansai/opencompany	98	35	“Run a billion-dollar startup with just one person. Your entire company run by OpenHuman”
tinyhumansai/tinyagents	46	14	A recursive LLM harness (RLM) in Rust; the base for the orchestrator’s graphs
tinyhumansai/tinyflows	31	15	“Open-source agentic workflows built with Rust”
tinyhumansai/tinyjuice	13	7	“A juicy token compression algorithm. Compresses up to 95% of tokens losslessly”
tinyhumansai/medulla	10	1	“Manage up to 1,000 agents with automations and flows”
tinyhumansai/tauri-cef	9	11	A Tauri build with CEF for desktop apps that are “smaller, faster, and more secure”
tinyhumansai/constitution	6	3	“The constitution for all AI agents”
tinyhumansai/skill-registry	6	6	Agent Skills registry for OpenHuman (an index.json catalog of installable SKILL.md skills)
tinyhumansai/tinymemory	6	9	An agent-ready memory system
tinyhumansai/tinychannels	5	8	“Every messaging channel for OpenHuman”

The rest of the organization (tinybus, tinydocs, tinyvoice, tinydesktop, tinywallet, tinybox, portal, tinymcp, tinyworkspaces, tinyhosts, tinyruntime*, tinyskills, tinybrowser, tinyloops, tinytools, tinysweeper, mascots, whisper-rs-sys, homebrew-core, plugins-workspace, sdk, rust-template, .github) sits between 0 and 2 stars and rounds out the internal stack: bus messaging, embedded Python/Node runtimes, a Rust MCP loader, a web3 wallet for agents, and community mascot assets (Rive files).

CONTRIBUTING.md also mentions tinyhumansai/openhuman-skills as the repository where skills are developed (the main repo consumes bundles built from GitHub or a local path); that repository returns a 404 from the API when queried, so its status is unverified (it may be private or renamed).

Forks, derivatives, and community-inspired projects

GitHub search (August 30, 2026) finds:

• mwakidenis/openhuman (18 stars, a fork): described as “Your Personal AI super intelligence. Private, Simple and extremely powerful” — the highest-starred unofficial fork found.
• ZOROZ22/benthon-openhuman-core (0 stars): “Benthon fork of OpenHuman (GPL-3.0) — local-first memory + agent core, unbranded…”
• vincentwi/hermes-memory-tree (1 star) and wisecoach/hermes-memory-tree (0): “an OpenHuman-inspired memory system for Hermes Agent — 6-stage async pipeline, 7…” The second is written in Chinese (“我让hermes抄OpenHuman生成的”: “I made hermes copy what OpenHuman generates”). It’s the only non-English derivative that explicitly documents porting the Memory Tree pattern to another agent.
• romanyukzhenya82-sketch/kai9000-orchestrator (4 stars): “KAI-9000 multi-agent orchestrator — Android + Termux + OpenHuman v0.63.9. 20 skills.”
• openhumancy/openhumancy-skill (7 stars): a skill for delegating real-world tasks to human workers via OpenHumancy (a different project, with no verifiable relation to tinyhumansai).

No complete translations of the product into other languages were found in the form of forks; the official translations exist only as READMEs (zh-CN, ja-JP, ko, de, ur-pk).

Related projects OpenHuman integrates or cites

• agentmemory (27,741 stars, Apache-2.0): OpenHuman ships an optional Memory backend that proxies to agentmemory; with memory.backend = "agentmemory" in config.toml, the same persistent store feeds OpenHuman alongside Claude Code, Cursor, Codex, and OpenCode.
• OpenClaw (388,021 stars) and Hermes (238,169 stars): the two personal-agent harnesses OpenHuman explicitly compares itself against in its README (see the comparison section).
• EverMind-AI/Raven (3,682 stars): “The Harness of Harnesses: a reliable, persistent, self-evolving multi-agent ecosystem” — surfaced in a GitHub search for “openhuman agent” but its relationship to OpenHuman is unverified in the sources retrieved; cited here only as a nearby find.
• karpathy/LLM Knowledge Bases: not a repository but the April 2026 tweet cited as the memory design’s inspiration.

Official and semi-official status

• Product Hunt: OpenHuman launched as a product (post_id 1136902, “An open source AI harness built with the human in mind”) and earned both daily and weekly “Top Post” badges, per the badges embedded in the README; the badge timestamps (May 16 and May 21, 2026) place the public launch in that window. The vote count couldn’t be retrieved — Product Hunt’s page blocks automated access (Cloudflare verification) as of this research.
• GitHub trending: the README claims nine consecutive days at #1 trending within the first week; a project-stated claim, unverified independently.
• No formal standard: no official de facto standard designation, nor adoption by an outside vendor, was found in the sources consulted. Its status is that of a young startup’s project (early beta) with aggressive marketing traction, not an institutionally backed technology.

Quick-start guide

Installation and first boot

The README and INSTALL.md document these paths (measured August 30, 2026):

• Direct download: installers from tinyhumans.ai/openhuman or from the GitHub Releases page (.dmg, .deb, .AppImage, .msi).
• macOS (Homebrew Cask): brew install --cask openhuman.
• Linux (Debian/Ubuntu): download OpenHuman_<version>_amd64.deb (or arm64) from releases and sudo apt-get install -y --no-install-recommends ./OpenHuman_*_amd64.deb.
• Linux (Arch): an AUR recipe openhuman-bin is included in the repository (packages/arch/openhuman-bin/); once published, yay -S openhuman-bin.
• Windows: run the signed .msi from the latest release.
• Install scripts (flagged as “unverified installation,” with no script signing): curl -fsSL https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.sh | bash (macOS/Linux) or irm https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.ps1 | iex (Windows PowerShell). On Debian/Ubuntu, install.sh resolves the .deb first and installs it with apt; OPENHUMAN_INSTALLER_LINUX_PACKAGE=appimage forces AppImage.

First boot: no terminal, no config files — “install a working agent in a few clicks.” The app is a desktop UI with a mascot; the typical flow is connecting accounts (Gmail, Notion, GitHub, Slack…) via OAuth, letting the 20-minute auto-fetch fill up memory, and chatting. The subscription covers models and search; a bring-your-own key or a local Ollama model also work.

Common workflows

• To build full context of your stack: connect your OAuth accounts; auto-fetch downloads locally every 20 minutes; Memory Tree compresses everything to Markdown in SQLite and mirrors it into the Obsidian vault, which you can open and edit directly.
• To request an automation: ask for it in chat; the agent proposes a tinyflows graph, you review it on the visual canvas and save it; it triggers on a schedule, webhook, or channel event, with side effects gated behind approval.
• To use shared memory with other coding agents: already self-hosting agentmemory for Claude Code or Codex? Add memory.backend = "agentmemory" to config.toml and the same persistent store feeds OpenHuman and your other agents.
• To work with local-only models: point the model router at a local Ollama model for any workload; with Privacy Mode on, no inference leaves the machine (enforced in the Rust core).
• For local development: pnpm dev (web only), pnpm --filter openhuman-app dev:app (macOS desktop shell), pnpm dev:app:win (native Windows), or cargo run --bin openhuman-core (standalone Rust core on port 7788).

Essential configuration

The files and settings a new user touches first:

1. config.toml: product configuration (e.g. memory.backend = "agentmemory" for the memory proxy).
2. .env (root, for development): Rust core, Tauri shell, and shared runtime settings; the .env.example template documents OPENHUMAN_CORE_PORT=7788 and OPENHUMAN_CORE_RPC_URL=http://127.0.0.1:7788/rpc as normal local values.
3. app/.env.local (web development): frontend VITE_* variables; VITE_BACKEND_URL only if you need a non-production backend.
4. rust-toolchain.toml: pins Rust 1.96.1 for building from source (the README mentions 1.93.0; CONTRIBUTING.md and the file itself are the authoritative source).
5. Privacy Mode / model router (in the UI): the 100%-local-inference toggle and the choice between subscription, bring-your-own key, or Ollama.

Common pitfalls and fixes

Documented in INSTALL.md, CONTRIBUTING.md, and Discussions:

• AppImage under Wayland: can fail to start, be missing system libraries (e.g. libgbm.so.1), or throw sharun: Interpreter not found! on Arch-based distros (issue #2463). Fix: use the .deb on Debian/Ubuntu or native packages.
• Unsigned install scripts: curl | bash and irm | iex can’t detect tampering (issue #2620, closed once native packages were promoted; current release assets don’t include install.sh.asc/install.ps1.asc). Prefer native packages.
• Port 1420 reserved on Windows: Hyper-V/WSL reserve TCP ranges; check with netsh interface ipv4 show excludedportrange protocol=tcp and set $env:OPENHUMAN_DEV_PORT = "14320" (N and N+1 both need to be free).
• C4819/C2220 errors in MSVC with a non-UTF-8 codepage: set $env:CL = "/utf-8" before pnpm dev:app:win.
• WSL1 + X11 unsupported: the Tauri/CEF stack can hang or render blank; use native Windows or WSLg. The app warns on startup if it detects DISPLAY without WAYLAND_DISPLAY.
• No certificate on macOS: run bash scripts/setup-dev-codesign.sh once to create “OpenHuman Dev Signer”; without it, dev:app fails with “no identity found.”
• No submodules: without git submodule update --init --recursive before pnpm install, desktop builds fail (Tauri/CEF sources vendored under app/src-tauri/vendor/).
• Authentication issues: Discussions show several recurring threads of users unable to complete SSO (GitHub/Google) or the self-hosted core’s local login (e.g. #2567, #2560, #2189, #2182); SUPPORT.md routes those cases.

Integrations and migration

• With other agents: agent-to-agent messaging uses E2E Signal-protocol sessions, so “you can connect anything (Claude Code, Codex, OpenClaw, Hermes)” and orchestrate it from OpenHuman (README).
• With your existing memory: if you already self-host rohitg00/agentmemory, the memory.backend = "agentmemory" backend reuses it with no migration.
• With MCP and skills: the README claims support for 5,000+ MCP servers and 90,000+ skills (the official tinyhumansai/skill-registry catalogs installable SKILL.md skills).
• Migrating from OpenClaw or Hermes: no migration procedure is documented; the value proposition is starting from scratch by connecting your OAuth accounts and letting auto-fetch build memory in minutes.
• Migrating to local-only: the model router lets you move any workload from the subscription to bring-your-own keys or Ollama without changing the app.

Current metrics

Measured August 30, 2026, GitHub API.

Metric	Value
Stars	38,875
Forks	3,817
Watchers	198
Commits (default branch)	~9,681
Open issues per the API	321
Primary languages	Rust, TypeScript, JavaScript, Shell
License	GPL-3.0
Created	February 18, 2026
Metadata last updated	August 30, 2026
Latest release	v0.63.12, August 7, 2026
Total releases retrieved	56 (from v0.49.32, March 31, 2026)

The top contributors returned by the API, by contribution count: senamakel (Steven Enamakel, 6,589), graycyrus (476), M3gA-Mind (455), YellowSnnowmann (386), github-actions[bot] (335), oxoxDev (299), sanil-23 (219), and CodeGhost21 (150). Caveats: the API’s open_issues_count may include open pull requests, not just issues; the commit count (~9,681) was derived from the last page of the API’s pagination link with per_page=1; the creator’s 86% share of contributions indicates one-person-led development.

How to contribute

CONTRIBUTING.md documents a full process:

1. Prerequisites: Git, Node.js ≥24.0.0, pnpm 10.10.0, Rust 1.96.1 (with rustfmt and clippy), CMake, Ninja, ripgrep, vendored Tauri/CEF submodules, and GTK/WebKit packages for Linux desktop builds. On Windows, additionally: Visual Studio C++ Build Tools (MSVC v143), LLVM/Clang, and a specific install order.
2. Clone: fork, clone, git remote add upstream git@github.com:tinyhumansai/openhuman.git, git submodule update --init --recursive, pnpm install.
3. Configure: cp .env.example .env and cp app/.env.example app/.env.local; never commit tokens.
4. Develop: pnpm dev (web), pnpm --filter openhuman-app dev:app (macOS desktop), pnpm dev:app:win (Windows), cargo run --bin openhuman-core (core).
5. Verify: pnpm typecheck, pnpm lint, pnpm format:check, pnpm test, pnpm test:rust, pnpm test:e2e, cargo check (root and app/src-tauri).
6. Open a PR: against upstream main, with the .github/PULL_REQUEST_TEMPLATE.md filled out, a closing keyword (Closes #…), and — for PRs authored by AI agents or remote environments — an “AI Authored PR Metadata” section with the exact command and error of any failing check. Changed-line coverage must be ≥80% in CI.
7. Conventions: Redux for app state, the Rust core as the source of truth for business rules, a controller registry for new Rust functionality, greppable logs with no secrets or full PII.

There’s also CONTRIBUTING-BEGINNERS.md with a copy-pasteable prompt to have a coding AI agent guide your first PR, AGENTS.md and CLAUDE.md with repository rules for agents, and a “Contributor Hall of Fame” (free merch and special Discord access).

How the community received it

The evidence gathered shows a reception dominated by the company’s own marketing and community, with scant Hacker News debate:

• Hacker News barely registers the project. The highest-engagement thread is “OpenClaw is toast. OpenHuman just landed” (id 47839564, April 20, 2026, 3 points, 1 comment): senamakel himself pitched it as “a self-learning AI with memory that gets better the more you use it; comment ‘Openhuman’ and I’ll send the download link.” Show HN: OpenHuman, an AI agent with a subconscious loop (id 47876182, April 2, 2026) got 2 points and 0 comments; Tinyhumansai/openhuman: Your Personal AI super intelligence (id 48125601, May 13, 2026) got 2 points and 0. Show HN: TinyAgents – a Rust based recursive LLM harness (id 48727680, June 30, 2026, 4 points, 1 comment) got a reply from da-x: “Everyone is cooking their own harnesses (e.g. mine is a very simple tool-use loop)” — a sign the harness space is saturated with parallel attempts. Overall: no substantial independent technical debate to verify on HN, no extended praise or criticism.
• X/Twitter: senamakel’s April 20, 2026 launch tweet (“We are killing OpenClaw…”) has 190 likes and 36 retweets (retrieved via fxtwitter) — modest for an announcement claiming a #1 trending spot. The official site (tinyhumans.ai/openhuman) embeds testimonials from Maksim Liashch (@LyashchMaxim: “OpenHuman just dropped and it’s the first agent that actually knows you in minutes, not weeks, inspired by Karpathy’s knowledge base flow”), 0xMarioNawfal (@RoundtableSpace), and slash1s (@slash1sol: “Every $420/mo AI SaaS just got an open-source killer”).
• YouTube: the official TinyHumans AI channel posted “OpenHuman Demo Video” (~11,085 views), “We killed OpenClaw.” (~3,757 views), and “We built an AI that kills Zapier and then open-sourced it” (~105 views), plus three community AMAs (#1 “Token Maxxing, OpenCompany & Medula Reveal,” #2 “App Walkthrough & Bring Your Own LLM,” #3 “Real User Demo: Miranda’s OpenHuman Workflow”), at 48–60 views each. Third-party: “The Karpathy-Style Super Intelligence Layer for your AI Agents (OpenHuman)” (Build Things With AI, ~3,483 views), “OpenHuman VS Hermes AI: Who Wins?” (Julian Goldie SEO, ~5,604 views), “OpenHuman: AI That Lives On Your Laptop?” (TechWealth Hub, ~1,438 views), “Hermes 3 vs OpenHuman: The Ultimate Open Source Agent Memory Face Off” (Open Source Spotlight, ~414 views), “OPENHUMAN - Your Local-First AI Super Intelligence” (Kuro, ~331 views), and “OpenHuman The Private AI Super Intelligence That Actually Remembers You” (Eddy Says Hi, ~382 views). The dominant third-party pattern is the OpenHuman vs. Hermes vs. OpenClaw comparison.
• Reddit: r/tinyhumansai exists (linked from the README) but access to Reddit’s JSON API was blocked by bot detection during this research; no threads, scores, or specific opinions could be retrieved. Unverified.
• GitHub Discussions: recent threads are largely usage issues (SSO/authentication, local core login, subscription pricing in #1980 “Sub price,” OAuth problems in #2608 “terrible oauth,” a Korean-language thread about blocked chat and tokens in #4013, and a Chinese-language one about login in #2189), alongside design threads (e.g. #2370 “Workflows & Automations — agent-first builder” and #5001 “Implement PCP”). No substantial community design debate was retrieved.

In summary: the project’s visibility is high on the company’s own channels (YouTube, X, site, Product Hunt) and in third-party comparisons; independent technical discussion (HN, Reddit, blogs) wasn’t retrieved in any substantial volume, so no consensus or rejection should be inferred beyond what’s shown here.

Comparison with similar projects

The README itself publishes a comparison table; competitor figures were verified against the GitHub API on August 30, 2026:

Approach	Verifiable overlap	Verifiable difference
openclaw/openclaw (388,021 stars, created November 24, 2025)	Open-source, cross-platform personal AI agent; “Any OS. Any Platform. The lobster way. 🦞”	OpenClaw is terminal-first and bring-your-own-models per OpenHuman’s README table; OpenHuman bets on UI-first, a subscription, and self-built memory. OpenHuman’s launch announcement explicitly named it as the rival to “kill.”
NousResearch/Hermes-Agent (238,169 stars, MIT, created July 22, 2025)	An open-source personal agent that “grows with you”; self-learning per the README table	Hermes is also terminal-first and bring-your-own-models; the README’s memory comparison rates it “Self-learning” against OpenHuman’s “Memory Tree + Obsidian vault.” Third-party video “OpenHuman VS Hermes AI: Who Wins?” (~5,604 views).
Claude Cowork (proprietary, cited in the README’s table)	A desktop assistant + CLI with per-chat memory	Per OpenHuman’s table: proprietary, cloud-only, no auto-fetch, no visual workflows, no messaging channels. Not independently verified (an Anthropic product).
rohitg00/agentmemory (27,741 stars, Apache-2.0)	Persistent memory for coding agents; “#1 on real-world benchmarks”	Not a full harness — a memory runtime. OpenHuman optionally integrates it as a backend (memory.backend = "agentmemory"), it doesn’t compete with it.
EverMind-AI/Raven (3,682 stars)	“The Harness of Harnesses: a reliable, persistent, self-evolving multi-agent ecosystem”	Relationship to OpenHuman unverified; surfaced in GitHub search, but no retrieved source links it to the project.
n8n / Zapier (cited as inspiration in the README)	Visual automation with triggers	“Heavily inspired by n8n and Zapier” (README): the difference is that in OpenHuman the agent proposes the flow and the user approves it on a canvas.

The more useful comparison isn’t by star count: OpenHuman competes in the niche of “local-first personal agent with a UI and memory built in minutes,” against terminal-first harnesses (OpenClaw, Hermes) and against productivity SaaS solutions. Its verifiable differentiation is the combination of Memory Tree + auto-fetch + agent-proposed visual workflows + Privacy Mode, plus the single-subscription model.

Use cases and who this repository can help

• Professionals who hate starting from scratch with every agent: if your current workflow is “explain the same architecture every session” (the problem agentmemory and OpenHuman share as motivation), the 20-minute auto-fetch + Memory Tree + Obsidian vault give you full context of email, calendar, repos, and documents in a single sync pass, with no training period.
• Teams already self-hosting agentmemory for Claude Code, Cursor, Codex, or OpenCode: the optional memory.backend = "agentmemory" backend lets them add OpenHuman on top of the same persistent store without duplicating memory or migrating data.
• Users who want a personal assistant that reaches them where they already are: the 17 messaging channels (Telegram, Discord, Slack, WhatsApp, Signal, iMessage…) plus native IMAP/SMTP email turn the agent into just another contact, not an app you have to open.
• People with strict privacy requirements: Privacy Mode (100% local inference enforced in the Rust core), on-device encrypted data, OS-keyring secrets, and optional sandboxing cover the “no data leaves my machine” case without giving up the desktop UI.
• Automation builders who prefer n8n/Zapier but want the agent to build the flows: asking for the automation in chat and approving it on the visual canvas is a different workflow than drawing nodes by hand; the triggers (schedule, webhook, channel events) and approval gates make it suitable for tasks with real side effects.
• Developers who want a multi-agent harness in Rust: tinyagents (graphs with checkpoints, fleets up to 3 levels deep, root-cause reports for stuck agents, run replay with per-call cost) and tinyflows are open source and reusable outside OpenHuman; TinyAgents’ Show HN (id 48727680) shows there’s independent interest in the component.
• Anyone researching agent economics: tiny.place (agent handles, Signal-protocol-encrypted A2A orchestration, x402 USDC rewards) is more a research use case than a production one, documented in the GitBook’s features/tinyplace section.
• Code researchers: the repository itself (9,681 commits, 41 repos in the organization, GPL-3.0) is a relevant corpus for studying how a startup structures a Rust+React agent harness with CEF, a bring-your-own-key subscription model, and a direct-confrontation marketing strategy against the market leader.

Resources

• Repository: https://github.com/tinyhumansai/openhuman
• Official documentation (GitBook): https://tinyhumans.gitbook.io/openhuman/
• Official site and downloads: https://tinyhumans.ai/openhuman
• Installation guide: https://github.com/tinyhumansai/openhuman/blob/main/INSTALL.md
• Contribution guide: https://github.com/tinyhumansai/openhuman/blob/main/CONTRIBUTING.md (and CONTRIBUTING-BEGINNERS.md)
• Official skills: https://github.com/tinyhumansai/skill-registry (registry of installable SKILL.md skills)
• Community: Discord https://discord.tinyhumans.ai/ · Reddit https://www.reddit.com/r/tinyhumansai/ · Discussions https://github.com/tinyhumansai/openhuman/discussions
• X/Twitter: @tinyhumansai (org) · @senamakel (creator)
• Demo videos and AMAs (TinyHumans AI channel):
  • “OpenHuman Demo Video - Tinyhumans.ai” (~11,085 views): https://www.youtube.com/watch?v=sHbMMPaxF3k
  • “We killed OpenClaw.” (~3,757 views): https://www.youtube.com/watch?v=xA8AlN5k10o
  • “We built an AI that kills Zapier and then open-sourced it” (~105 views): https://www.youtube.com/watch?v=ajkiBd5OdpU
  • Community AMAs: #1 https://www.youtube.com/watch?v=D2PGKuhIlAo · #2 https://www.youtube.com/watch?v=kjIV6HfFhKw · #3 https://www.youtube.com/watch?v=i7Yp9nX8xBE
• Third-party videos: “The Karpathy-Style Super Intelligence Layer for your AI Agents (OpenHuman)” (Build Things With AI, ~3,483 views): https://www.youtube.com/watch?v=Moy0xNYPn34 · “OpenHuman VS Hermes AI: Who Wins?” (Julian Goldie SEO, ~5,604 views): https://www.youtube.com/watch?v=RFS9tExWkZA
• Hacker News threads: 47839564 (announcement, 3 pts) · 47876182 (Show HN subconscious loop, 2 pts) · 48125601 (repo submission, 2 pts) · 48727680 (Show HN TinyAgents, 4 pts)
• Product Hunt: https://www.producthunt.com/posts/1136902 (daily and weekly Top Post badges; vote count not retrievable due to bot blocking)
• Memory inspiration: Karpathy’s “LLM Knowledge Bases” tweet (April 2, 2026): https://x.com/karpathy/status/2039805659525644595
• Optional memory backend: https://github.com/rohitg00/agentmemory
• Package registries: no official OpenHuman packages on npm/PyPI/crates.io/Docker Hub were found in this research. Note: openhuman on npm (0.1.5, 2023) and on PyPI (1.1.3, “OpenHuman: Virtual human assistant”) are unrelated projects that collide on the name.
• Official blog or changelog: GitHub Releases notes serve as the changelog: https://github.com/tinyhumansai/openhuman/releases (56 releases retrieved, from v0.49.32 to v0.63.12)

---

Note: this article combines OpenHuman’s README, INSTALL.md, and CONTRIBUTING.md, the GitHub API (measured August 30, 2026), the official GitBook documentation, the official tinyhumans.ai site, the Hacker News API (Algolia), Product Hunt (README badges; the page is bot-blocked), X via fxtwitter, the TinyHumans AI YouTube channel, and GitHub searches. Figures change over time; the project’s own claims (GitHub trending, site testimonials) are flagged as such. Reddit threads couldn’t be retrieved due to bot blocking and are flagged as unverified.