OpenHuman: Open-Source Private AI Agent App with Local Memory

Yet another alternative to OpenClaw & Hermes Agent.

OpenHuman is a free, open-source personal AI agent from TinyHumans for Windows, macOS, and Linux. It connects to services such as Gmail, Slack, GitHub, and Notion, stores useful context in local memory, and uses that context to answer questions or perform tasks.

Later conversations draw on earlier messages, files, meetings, and project activity instead of starting with an empty chat history. Before the main model responds, SuperContext retrieves the relevant information from the local Memory Tree. The same memory remains readable and editable as Markdown in an Obsidian-compatible vault.

Is OpenHuman Free?

The OpenHuman desktop app is free to download, and the source code uses the GNU GPL-3.0 license. TinyHumans also lists a Free hosted plan at $0 per month. Hosted model calls, web search, managed OAuth connections, and other backend services consume usage credits.

The Free tier uses the standard pay-as-you-go rate. All three plans list access to the same product capabilities. Basic and Pro subscriptions reduce the per-call price.

Highlights

• Stores scored memory in local SQLite and Markdown.
• Syncs active account connections every twenty minutes.
• Searches memory and files before each main request.
• Compresses verbose tool output through TokenJuice.
• Connects more than 100 OAuth services.
• Loads curated MCP servers and sandboxed skills.
• Routes workloads across hosted and local models.
• Runs code, search, scraping, browser, and media tools.
• Coordinates specialist agents on durable graphs.
• Creates visible workflows with approval gates.
• Receives messages across 17 supported channels.
• Joins Meet, Zoom, Teams, and Webex calls.
• Processes Screen Intelligence on the desktop.
• Enforces on-device inference through Privacy Mode.

Use Cases

• Build a desktop agent around personal work history.
• Search email, calendar, code, and chat together.
• Inspect and edit AI memory in Obsidian.
• Review automations before they change connected services.
• Coordinate local CLI agents from one visual hub.
• Run selected AI workloads on local hardware.
• Capture meetings and desktop context into memory.

OpenHuman Download and System Requirements

The desktop app runs on Windows, macOS, and Linux. OpenHuman recommends at least 4 GB of RAM for the app. Large mailboxes, large repositories, or local model inference are more practical with 16 GB or more. Local AI needs at least 8 GB of RAM for a useful model configuration, and model weights require several gigabytes of disk space.

Install and Set Up OpenHuman

Install a native package

Install the macOS build through the TinyHumans Homebrew tap:

brew tap tinyhumansai/core
brew install openhuman

Windows installation uses the signed MSI from the latest release. Debian and Ubuntu installations use the matching AMD64 or ARM64 package:

sudo apt-get install -y --no-install-recommends ./OpenHuman_*_amd64.deb

The AppImage can fail under Wayland or on systems that lack libraries such as libgbm.so.1. Debian and Ubuntu installations should use the .deb package because apt resolves the runtime dependencies.

Install from Scripts

# macOS or Linux x64
curl -fsSL https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.sh | bash
# Windows PowerShell
irm https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.ps1 | iex

Build OpenHuman from source

A source build needs Git, Node.js 24 or newer, pnpm 10.10.0, Rust 1.93.0 with rustfmt and clippy, CMake, Ninja, ripgrep, and the desktop build dependencies for your operating system. Clone the repository with its submodules before installing JavaScript packages:

git clone https://github.com/tinyhumansai/openhuman.git
cd openhuman
git submodule update --init --recursive
pnpm install

Run the web interface alone or launch the desktop shell during development:

# Web interface
pnpm dev
# Desktop application
pnpm --filter openhuman-app dev:app

Run the focused type, format, and Rust checks before changing the production build:

pnpm typecheck
pnpm format:check
cargo check -p openhuman --lib

Complete the first launch

1. Launch OpenHuman and sign in. The Advanced panel accepts a custom core RPC URL for a private backend.
2. Review the operating-system permission prompts. Screen Intelligence needs screen access, the voice hotkey can need input monitoring, and meeting agents need camera and microphone access.
3. Connect one account such as Gmail. Read the OAuth scopes and approve only the data needed for your tasks.
4. Wait for the first auto-fetch cycle. The initial Gmail ingest should begin within twenty minutes.
5. Ask a request tied to the connected data, such as “What is waiting on me?” or “Extract action items from my recent conversations.”
6. Open Memory and select View vault in Obsidian. Check the summaries under <workspace>/wiki/ before granting more sources.
7. Add model routes, channels, MCP servers, or skills after the memory and first request behave as expected.

Connect Ollama or LM Studio

Local AI ships turned off. OpenHuman detects Ollama at http://localhost:11434 and LM Studio at http://localhost:1234/v1. Confirm that Ollama is running before opening the Local AI settings:

curl http://localhost:11434/api/tags

Open Settings > AI & Skills > Local AI, select a memory tier, and download the requested chat and embedding models. A typical small setup uses gemma3:1b-it-qat for chat and bge-m3 for embeddings.

ollama pull gemma3:1b-it-qat
ollama pull bge-m3

The default local tier keeps embeddings and memory processing on the device while chat and deeper reasoning remain on the cloud route. Custom routing can move those workloads to Ollama or LM Studio. OpenHuman may fall back to a remote route when the local runtime becomes unreachable. Privacy Mode blocks that fallback and permits only configured on-device inference.

How OpenHuman Builds and Uses Memory

Memory Tree and Neocortex

OpenHuman treats connected accounts as memory sources as well as agent tools. A periodic scheduler checks each active connection every twenty minutes. Each connection keeps its own cursor, last-sync time, deduplication set, and daily budget. A restart reloads that state from local storage and the next scheduler tick continues the sync.

Neocortex converts incoming text into canonical Markdown chunks, removes repeated material, identifies entities and time relationships, and folds the chunks into source, topic, and daily summary trees. The local SQLite database lives at <workspace>/memory_tree/chunks.db. Memory ages through hot, warm, cool, and cold tiers. Older context remains retrievable while recent or frequently used facts receive more attention.

Obsidian vault and memory history

The agent’s readable memory lives under <workspace>/wiki/. Generated summaries, notes, and folders for connected services appear as normal Markdown files. You can open the directory in Obsidian, edit a summary, add a note, or create links between topics. A later ingest reads those changes back into the memory system.

Git-backed memory history records changes to summary files and shows what changed since the last review. An optional agentmemory backend can share a durable memory store with Claude Code, Cursor, Codex, and OpenCode through config.toml.

SuperContext and the subconscious loop

SuperContext runs a retrieval pass across the Memory Tree and local files before the main model sees a request. This prefetch step supplies recent decisions, project names, prior messages, and relevant documents at the start of the agent turn.

The subconscious loop periodically recalls memory, compares new activity with existing context, and updates longer-running goals. It can surface a briefing, advance a standing task, or record a new connection between events. Goals and todos persist across threads, and each conversation can maintain its own task board.

Agent Orchestration and Visual Workflows

Checkpointed agent graphs

OpenHuman runs agent turns on the open-source tinyagents graph engine. Each turn has durable checkpoints, typed state, tool events, and a run journal. A task can pause for approval, survive an application restart, and resume from the saved step. Specialist agents can work in parallel and delegate further when a task needs research, code, communication, or another domain.

The orchestration hub shows active sessions, blocked runs, and a Needs you area for pending decisions. Repeated tool-call loops trigger a circuit breaker, and a halted subagent returns an incomplete status or root-cause summary. Run journals retain tool calls, model usage, timing, and per-call cost data for later inspection.

Agent-proposed workflows

OpenHuman uses the open-source tinyflows engine for saved automations. Describe an automation in chat and the agent drafts a typed workflow graph. A proposal card lists the steps in plain English, and the canvas shows the nodes and routes before anything is saved.

The proposal tool cannot create or activate a workflow on its own. You save and activate the graph from the app. Scheduled runs, webhooks, and channel events can trigger the saved flow. Approval gates stop side effects until you confirm them, and run history records the input and output of each step.

Integrations, MCP servers, and skills

The managed catalog covers more than 100 services across email, calendars, documents, storage, code, messaging, CRM, commerce, and project management. One connected service can become an agent tool, a Memory Tree source, a personalization signal, and a workflow trigger. Managed connections use Composio for OAuth and request brokering, and the app does not ask for a separate Composio API key.

Direct mode accepts your own Composio credentials for synchronous tool calls. Real-time trigger webhooks then need your own webhook infrastructure. MCP servers extend the agent with external tool protocols, while skills package repeatable instructions and executable behavior in isolated environments.

Screen Intelligence, voice, and meetings

Screen Intelligence captures the desktop approximately every five seconds when enabled. The on-device vision model converts each capture into a structured text summary and discards the raw image. Per-app controls can exclude a banking app, password manager, medical portal, or any other sensitive window.

Native voice combines speech-to-text, text-to-speech, a push-to-talk control, and a speaking desktop mascot. Meeting agents can join Google Meet, Zoom, Microsoft Teams, and Webex, stream a live transcript, respond when addressed, and file the transcript, summary, and action items into searchable history.

Privacy and Data Handling

OpenHuman keeps its core memory on the computer. The local files cover the memory database, Markdown vault, workspace configuration, model state, and runtime state. Hosted services handles account sign-in, managed model calls, web search proxying, OAuth token brokering, and managed integration requests.

Local AI and Privacy Mode solve different problems. Local AI assigns selected workloads to Ollama, LM Studio, MLX, or another compatible endpoint. Normal routing can send other tasks to hosted models and may use cloud fallback after a local failure. Privacy Mode applies a structural block to cloud inference and displays egress information before a tool or integration sends data away from the machine.

Screen Intelligence deserves deliberate permission choices because it observes visible desktop activity on a continuous cycle. Exclude sensitive apps before enabling it. Workflow approval gates also deserve review when a flow can send a message, modify a file, place a trade, or write to a connected service.

OpenHuman vs OpenClaw

OpenHuman and OpenClaw are open-source personal agent systems with persistent state, tools, skills, messaging channels, scheduled work, and multi-agent capabilities. OpenHuman is built on the OpenClaw architectural foundation. It adds a native desktop interface around personal data ingestion, readable memory, agent graphs, and visual workflows. OpenClaw keeps the Gateway at the center of channels, nodes, sessions, hooks, and operator configuration.

OpenHuman concentrates memory review, screen context, workflow approvals, and agent run inspection in one desktop application. OpenClaw exposes more of the operating layer through Gateway configuration and channel plugins. OpenHuman can also orchestrate OpenClaw sessions as part of a wider agent fleet.

OpenHuman vs Hermes Agent

OpenHuman and Hermes Agent both preserve context, load skills, connect MCP servers, schedule tasks, coordinate subagents, and receive messages outside the terminal. Their memory models differ. Hermes separates compact factual memory from procedural skills that the agent can create or revise after a task. OpenHuman ingests connected account history into a local Memory Tree and exposes the same context through an editable Markdown vault.

Hermes Agent travels more easily across terminals, servers, containers, and messaging gateways. OpenHuman keeps more of the setup and inspection inside a native app. Its main distinction is the combination of scheduled account ingestion, editable personal memory, and visual workflow review.

Pros

• GPL-licensed source code.
• Readable Obsidian memory vault.
• Native desktop installers.
• Visible approval-gated workflows.
• Managed and local model routes.
• Durable agent orchestration.
• Detailed run and cost history.

Cons

• Hosted features need an account.
• Managed inference costs credits.
• Strict local use needs configuration.
• Large local models need more RAM.

Alternatives and Related Resources

• Automate Anything: 10 Best & Open-source AI Agents
• 7 Best & Open-source Claude Cowork Alternatives
• 7 Best CLI AI Coding Agents
• Most Popular Agent Skills on GitHub for Coding Agents

FAQs

Q: Does the free OpenHuman plan include unlimited AI usage?
A: No. The Free plan has no monthly subscription fee and uses the standard pay-as-you-go rate for hosted calls. The desktop app and GPL-3.0 source code are free to download, but managed model, search, and integration activity can consume credits.

Q: Can OpenHuman run fully local?
A: Privacy Mode can restrict inference to configured on-device models. The default setup is not fully local because sign-in, managed OAuth calls, web search proxying, and some real-time triggers still use hosted services. A custom backend requires additional setup and infrastructure.

Q: Can OpenHuman run offline?
A: Local chat, Screen Intelligence, auto-complete, and configured voice tasks can continue on the desktop while the local runtime is ready. Hosted model routing, managed account connections, web search, and deeper server-side analysis need an internet connection.

Q: Can I edit OpenHuman memory in Obsidian?
A: Yes. OpenHuman mirrors memory into Markdown under <workspace>/wiki/. You can edit summaries, add notes, and create links in Obsidian. A later ingest reads the updated files back into the memory system.

Q: Does Screen Intelligence upload screenshots?
A: Screen Intelligence processes screenshots through the on-device vision model and discards each raw image after analysis. A text summary remains in local memory. You can exclude individual apps or disable the feature completely.

Q: What happens if Ollama stops during a request?
A: Standard local routing may fall back to the configured remote provider when Ollama becomes unreachable. Check the Local AI status before sensitive work. Privacy Mode blocks cloud inference and prevents that remote fallback.

Q: Can OpenHuman replace OpenClaw or Hermes Agent?
A: OpenHuman covers many of the same personal-agent tasks and can orchestrate external agents. Its native app, scheduled account ingestion, editable Memory Tree, and visual workflows distinguish it. OpenClaw exposes deeper Gateway operations, while Hermes Agent carries its memory and learned skills across more terminal and server deployments.

Last Updated: July 16, 2026