Getting Started with OpenHuman: From Install to Your First Useful Answer

At a glance

OpenHuman is a native desktop assistant that pre-loads your context from 118+ connectors before the conversation begins.

The managed path is a single subscription that includes all models plus TokenJuice token savings; bring-your-own-model and local-only are the alternative. Exact pricing is not published in these sources — verify on the site before you sign up.

Before you install

System requirements

OpenHuman requires at least 4 GB of RAM. If you plan to sync large mailboxes or repos, or to run a local AI model via Ollama, 16 GB or more is recommended. On macOS the app will prompt for Accessibility and Input Monitoring permissions (needed for the voice hotkey); Camera and Microphone access is optional and only required if you use the Meeting Agent.

What is local and what is managed

OpenHuman is local data combined with managed services by default — it is not a purely local product. Your Memory Tree, Obsidian-compatible vault, workspace config, and SQLite store all live on your machine and are encrypted locally. Workflow data stays on device. What goes through OpenHuman's hosted backend by default: account sign-in, model routing, web-search proxying, and connector OAuth (via the Composio integration layer). A custom/local mode lets you supply your own model (Ollama), your own search provider, or your own Composio API key, but some real-time trigger webhooks and managed features still require the hosted backend even then.

Install

Use a native package whenever possible — native packages are signed and go through your OS package-manager's verification chain. The script install at the bottom has no integrity check; treat it as a last resort.

macOS (Homebrew tap)

brew tap tinyhumansai/core
brew install openhuman

Linux — Debian / Ubuntu (signed apt repo)

sudo apt-get install -y --no-install-recommends gnupg2 curl ca-certificates
curl -fsSL https://tinyhumansai.github.io/openhuman/apt/KEY.gpg \
  | sudo gpg --dearmor -o /etc/apt/keyrings/openhuman.gpg
echo "deb [signed-by=/etc/apt/keyrings/openhuman.gpg arch=amd64] \
  https://tinyhumansai.github.io/openhuman/apt stable main" \
  | sudo tee /etc/apt/sources.list.d/openhuman.list
sudo apt-get update
sudo apt-get install -y openhuman

Linux — Arch (AUR)

yay -S openhuman-bin

The openhuman-bin AUR recipe is pending publication; check the repo for current status before running this.

Windows

Download the signed .msi from the latest GitHub release page and run it.

Manual installers

All installer formats — .dmg, .deb, .AppImage, .msi — are available on the latest release page at github.com/tinyhumansai/openhuman/releases/latest.

Script install (unverified — prefer native packages)

The install scripts below perform no integrity check. Use a native package from the options above whenever your OS supports one.

# 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

Linux AppImage caveat

The .AppImage build can crash on launch under Wayland and on Arch-based distros (the error reads sharun: Interpreter not found!). The .deb avoids these failure modes. If you hit this issue, see GitHub issue #2463.

First run: install → first useful answer

1. Launch the app. Open OpenHuman from your Applications folder, Start menu, or app launcher. The desktop mascot loads and greets you.
2. Sign in. The sign-in screen reads "Sign in! Let's Cook". Social login is available. If you want to point at a self-hosted backend instead of the default managed services, open the Advanced panel and enter a custom RPC URL before completing sign-in.
3. Connect your first integration. Click Connect next to a service — Gmail is a natural first choice. A browser window opens for OAuth. Once you authorize, the connection activates and the first sync runs on the next 20-minute auto-fetch cycle.
4. Ask your first question. Type something like "What do I need to know from the last 12 hours?" OpenHuman's automatic model routing picks the right model for the task — you don't choose it yourself. The answer draws from whatever data has synced into your Memory Tree so far.
5. Browse your Memory tab. Open the Memory tab to see the summaries OpenHuman has built. They live as .md files in an Obsidian-compatible vault on your machine — you can read them, edit them, and link them by hand, just like any Obsidian note.

How your context gets built

Once a service is connected, OpenHuman builds and maintains your context automatically through a four-stage pipeline.

Auto-fetch runs every 20 minutes against every active connection and pulls fresh data into the pipeline. You do not initiate syncs manually; the agent's model of your world drifts toward the present on its own.

TokenJuice compresses each payload before it reaches a model. HTML is converted to Markdown, long URLs are shortened, verbose output is deduped and summarized, and CJK characters and emoji are preserved grapheme-by-grapheme. Token reduction reaches up to ~80% compared to the raw connector output. This is what makes it practical to include email threads, GitHub PRs, and Slack history in a single context window without exhausting it.

The Memory Tree canonicalizes the compressed data into Markdown chunks of at most 3,000 tokens each. Those chunks are scored and folded into hierarchical summary trees stored in SQLite on your machine. Because the tree is hierarchical — high-level summaries sitting above the detailed chunks — the agent can load the branch relevant to your query rather than scanning the full history.

The Obsidian vault is the same data in a different shape: every chunk also lands as a .md file in a folder that any Obsidian installation can open. You can read, edit, tag, and backlink your memory just like any note-taking workflow. Changes you make by hand persist alongside the auto-generated summaries.

Connecting more of your stack

Each integration in the connectors panel shows one of three states: Not connected, Connected, or Manage. Click Connect to start the OAuth flow; once authorized, the connection moves to Connected and starts feeding the next auto-fetch cycle. Click Manage to review or revoke the connection.

Managed mode (default)

In managed mode OpenHuman's backend owns the Composio API key, brokers OAuth tokens, enforces rate limits, and fans out real-time trigger webhooks on your behalf. Your tokens are encrypted and never stored in plaintext — the agent receives the results of tool calls, not the credentials used to make them. This is the path of least resistance and handles webhook wiring automatically.

Direct mode

Bring your own Composio API key and OpenHuman switches to direct mode for that connection. Synchronous tool calls work exactly as in managed mode, but real-time trigger webhooks are your responsibility to host and wire. This makes sense if you already have a Composio account or need fine-grained control over which API key each integration uses.

What a connected service does

A connected service plays four roles simultaneously: it is an agent tool (the agent can call it to take actions), a memory source (the auto-fetcher pulls data from it into the Memory Tree), a profile signal (its data shapes OpenHuman's model of you), and a trigger source (real-time events from it can activate the agent automatically). OpenHuman supports 118+ integrations covering Gmail, Notion, GitHub, Slack, Stripe, Google Calendar, Drive, Linear, Jira, and dozens of category peers.

What it does out of the box

Native tools

OpenHuman ships with four built-in tool categories without any connector configuration. Web search lets the agent query the web in real time. The web-fetch scraper retrieves and compresses full page content. The coder toolset gives the agent filesystem access, git operations, lint and test runners, and grep-style code search. Voice handles speech-to-text input and routes output through ElevenLabs text-to-speech, with the desktop mascot providing lip-sync animation.

The desktop mascot

OpenHuman has a face. The mascot reacts to what the agent is doing, speaks responses aloud, and can join a Google Meet as an active participant — it sees the meeting, listens, and responds as a real attendee. When you are not actively prompting it, the agent keeps thinking in the background, updating its model of your world from the latest connector data.

Model routing

The managed backend selects the appropriate model for each workload — reasoning-heavy tasks get a reasoning model, fast lookups get a smaller model, vision tasks route to a vision model. One subscription covers all the models the router uses; you do not manage separate API keys per model.

Messaging

The agent can send and receive messages across the communication channels you have connected. Inbound messages can trigger the agent; outbound messages can be drafted and sent on your behalf. The exact channels depend on which connectors you have authorized.

Going local / advanced

Local AI via Ollama

For supported on-device workloads you can route queries to a local model running in Ollama rather than the managed cloud backend. This keeps query data fully on your machine. Performance and capability depend on the model you choose and your hardware — 16 GB RAM is the practical floor for most useful local models.

Direct Composio mode

Supply your own Composio API key in the connector settings to switch any integration from managed OAuth brokering to a direct connection under your own account. See the Connecting more of your stack section above for what this means for webhook wiring.

Shared agentmemory backend

If you run multiple AI coding tools alongside OpenHuman, you can share a single durable memory store between them. Set memory.backend = "agentmemory" in config.toml to enable the agentmemory backend. Once enabled, Claude Code, Cursor, Codex, and OpenCode can all read from and write to the same store, so context built up in one tool is available in the others.

Self-hosted backend

The Advanced panel on the sign-in screen accepts a custom RPC URL. Point it at a self-hosted OpenHuman backend to keep account sign-in, model routing, and search proxying on infrastructure you control. Setup documentation is in the GitBook docs.

Further reading

On this wiki:

• OpenClaw vs OpenHuman vs Hermes Agent — architecture comparison of three open-source agents, useful for understanding how OpenHuman's memory model compares to alternatives.
• The Agent Loop — the reason–act–observe cycle that underlies OpenHuman's auto-fetch and model-routing pipeline.
• Tools, Actions & Environments — the taxonomy of what an agent can reach for, mapping directly onto OpenHuman's connector tools and native tool categories.

Project sources:

• OpenHuman on GitHub — Tauri/Rust source, connector interface, and release assets.
• OpenHuman docs (GitBook) — setup guides, connector documentation, and advanced configuration.
• Latest release — signed installers for all platforms.