mrkeyoor.com_
Thu 24 Sept 19:58 UTC
AI Toolsevaluationupdated 26 Aug 2026

openhuman review

OpenHuman is an early-beta desktop assistant that keeps a local memory of your files and connected accounts, then uses agents to research, automate work, and answer through chat or messaging channels. It combines an Obsidian-readable memory store, visual workflows, model routing, and a broad tool catalog in one application.

+200stars / 7d
Verdict

Our build finished in 55 seconds after installing 1,313 packages and 897 MB, but the test run still had no final result at the 900-second cap, so OpenHuman is an ambitious beta rather than a dependable personal data hub. Try the installer if you specifically want local memory plus visual agent workflows and can use a separate profile with low-value accounts. Wait for a completed test run and resolution of the config-permission issue before connecting a primary inbox, private chat archive, or production credentials.

We ran it

Lab card: what happened when we ran openhumanScreenshot of openhuman (tinyhumans.ai/openhuman)
Install✓ · 54s1313 packages · 897 MB
Build✓ · 55s
Tests✗ timed out · 900sran, no count parsed
Repo5117 files~1,332,302 lines of source · 83.9 MB · 19 CI workflows · Dockerfile · tests dir

Answers from our run

Does openhuman build from source?

Dependencies installed in 54 seconds (1313 packages), and the build succeeded in 55 seconds. We cloned commit 0b8b02c into a clean Debian container with 3 CPUs and no project-specific setup.

Do openhuman's tests pass?

We could not finish them: the suite was still running after 15 minutes in our container.

Who should not use openhuman?

Anyone needing stable production software today: the README labels OpenHuman an early beta and says to expect rough edges.

What are the alternatives to openhuman?

OpenClaw, Hermes Agent, AnythingLLM. Our build finished in 55 seconds after installing 1,313 packages and 897 MB, but the test run still had no final result at the 900-second cap, so OpenHuman is an ambitious beta rather than a dependable personal data hub.

Setup3/5Installers help, while source setup needs Node, Rust, and submodules
Docs4/5Broad feature docs and a specific contributor toolchain guide
Community4/537,755 stars and current pushes, with a busy 302-item queue
Maturity2/5Early beta, timed-out tests, and an open secret-permission issue

Who it’s for

Early adopters who want one desktop home for personal memory, research, and agent workflows.
Users willing to connect email, documents, calendars, or chat accounts to a local memory system.
Developers who want to inspect a Rust and TypeScript agent stack under GPL-3.0.
People who value a visual app and installer more than a terminal-first agent harness.

Who it’s NOT for

Anyone needing stable production software today: the README labels OpenHuman an early beta and says to expect rough edges.
Users who only want a small chat client: the source checkout spans 5,117 files, a desktop shell, workflows, memory, messaging, browser tools, and media features.
Teams unwilling to audit local secret handling: open issue #5635 says config.toml is initially written mode 644 before startup corrects it to 600.
Proprietary products that cannot comply with GPL-3.0 obligations when distributing modified code.
Source contributors without a current toolchain: the guide requires Node 24+, pnpm 10.10.0, Rust 1.93.0, CMake, Ninja, desktop prerequisites, and recursive submodules.

Setup reality

In our sandbox, pnpm installed 1,313 packages in 54 seconds and used 897 MB. The build succeeded in 55 seconds. Tests ran until the 900-second cap, so the suite did not complete. The log tail shows several UI test files passing and mock servers listening on 127.0.0.1:5005, then ends during OrchestrationRedirect.test.tsx; it does not show a final count or cause.

The packaged desktop installer is the easier route. Useful cloud-backed features need an OpenHuman subscription or chosen provider keys, while connected accounts require OAuth. Local-only inference can use Ollama through Privacy Mode, and messaging or email channels need their own account configuration.

Building from source needs Node 24+, pnpm 10.10.0, Rust 1.93.0, CMake, Ninja, platform desktop libraries, and initialized git submodules. The monorepo has Docker and Compose files, but the primary experience is a desktop application with local SQLite and Obsidian data.

1,313 packages support an unusually broad desktop agent

Our pnpm install pulled 1,313 packages and occupied 897 MB, which fits the size of OpenHuman's promise. This is a desktop assistant, local memory system, visual workflow builder, research tool, messaging bridge, and agent coordinator. The Rust and TypeScript monorepo contains 5,117 files and about 1,332,302 lines of source. That breadth may appeal to someone who wants one personal AI application. It also means every connected account, model route, browser action, and stored memory adds another behavior to understand.

The most distinctive feature is the memory design. OpenHuman says it stores compressed, scored Markdown trees in local SQLite and mirrors them to an Obsidian vault that the user can inspect and edit. Connected sources can refresh on a 20-minute loop. This is more tangible than a hidden remote chat history, but it makes data ingestion a central trust decision. An inbox, calendar, document store, or chat account can reveal far more than an isolated prompt, even when the resulting index stays on the machine.

What happened when we ran it

In our 3 CPU, 8 GB sandbox, pnpm installation succeeded in 54 seconds. It added 1,313 packages and used 897 MB. The build completed successfully in 55 seconds. The measured checkout had 19 CI workflow files, a Dockerfile, a Compose file, a tests directory, and monorepo workspaces. Those are solid build signals for a large source tree, though they do not establish whether the desktop app can connect an account or complete an agent workflow.

The tests did not finish within our 900-second cap. The tail shows several UI files passing, including 6 tests for LoadingState, 6 for UserTurnBody, 3 for FeedbackVoteControl, and 4 for AgentEditorToolsPicker. Repeated mock servers reported listening on 127.0.0.1:5005. The log then reached OrchestrationRedirect.test.tsx and ended without a final summary. We cannot state a passed, failed, or total test count, and the tail does not identify why the run remained active.

Local memory still needs a threat model

OpenHuman documents encrypted on-device data, OS keyring storage, approval gates, optional sandboxing, and a Privacy Mode intended to prevent inference from leaving the machine. Those are relevant controls for an assistant that can ingest mail and documents. Privacy Mode can route work to a local Ollama model, while normal use may involve the project's subscription, user-supplied provider keys, managed search, or OAuth integrations. Users should map each feature to its network destination instead of treating the word local as a complete answer.

An open config permission report gives one concrete reason for review. On August 20, 2026, pre-production logs showed config.toml created with mode 644, briefly readable by other local users, before startup changed it to 600. The issue says the file may hold API keys and connection identifiers. The automatic correction narrows exposure but does not fix creation. On a shared machine, that is enough reason to wait for the write path to be corrected.

Visual workflows trade typing for operational scope

OpenHuman can propose a workflow as a graph, show it on a canvas, and save it after review. Saved workflows can react to schedules, webhooks, or channel events, with approvals around side effects. That is a friendlier model than copying an agent-generated script into cron. The underlying promise is still automation, so a visible graph needs the same care around retries, duplicate actions, revoked credentials, and partial failure as code. A canvas makes the plan inspectable; it does not make the action harmless.

The orchestrator adds checkpointed agent graphs, worker fleets, run journals, and communication with other agents. Messaging support covers 17 channels according to the README, and the integration catalog claims more than 100 OAuth sources plus MCP and skill directories. Those figures describe advertised reach, not our lab verification. Our 900-second run never produced a final test summary, and we did not connect any external account. Trial one workflow with one low-risk integration before enabling recurring sync across a personal stack.

Source contribution requires two full toolchains

The packaged installer is the sensible first look, while contributors face a specific build list: Node 24 or newer, pnpm 10.10.0, Rust 1.93.0, CMake, Ninja, ripgrep, desktop prerequisites, and recursive git submodules. Web-only UI work can avoid some desktop compilation, but the complete app crosses JavaScript, Rust, and platform-native boundaries. Our 55-second build succeeded in the prepared lab image; a fresh workstation still needs the README's platform packages and submodule setup.

GPL-3.0 also shapes reuse. Individuals can inspect, modify, and run the code, while a company distributing a modified application needs to review the license obligations with its counsel. The latest v0.63.12 release, published August 7, contained only a version bump and release housekeeping. GitHub showed 37,755 stars, 302 open issues and pull requests combined, and a last push on August 25, so development is active even though the latest tag says little about feature stability.

Early beta is the correct buying label

The README itself calls OpenHuman early beta and tells users to expect rough edges. That is more useful than its claims about personal superintelligence. A 1,332,302-line application with a successful build can still have unfinished integration, permission, and shutdown behavior, as the 900-second test cap and open config issue demonstrate. New users should create a separate OS profile, connect disposable or low-value accounts, inspect the Obsidian and SQLite output, and verify exactly which requests leave the machine.

OpenHuman is worth testing if the combination of editable local memory and visual agent workflows matches how you want to work. OpenClaw is a better fit for an agent centered on existing chats, Hermes for terminal control, and AnythingLLM for a narrower document assistant. Do not hand OpenHuman your primary digital life on day one. Give it 1 bounded source and 1 reversible workflow, then expand only after the stored data, approvals, and network behavior match the documentation.

Alternatives

ProjectWhat it isPick it when
OpenClaw gh↗A self-hosted personal agent that works through existing chat channels and local devices.pick this instead when messaging access matters more than a desktop memory and workflow interface.
Hermes Agent gh↗A terminal-first agent with persistent skills, tools, and messaging integrations.pick this instead when you want a hackable command-line agent and prefer to bring your own models.
AnythingLLM gh↗A desktop and self-hosted app for chatting with private documents and multiple model providers.pick this instead when document chat is the main job and OpenHuman's agent economy and workflow scope feel excessive.

What people are saying

  1. [github-trending] tinyhumansai/openhuman

Sources

  1. OpenHuman README
  2. OpenHuman v0.63.12 release
  3. OpenHuman config permission issue 5635

More ai tools reviews

monty · Step-Code · agenticSeek · starnet · lap · stable-diffusion.cpp · the whole board →