OpenHuman – Open Desktop AI Assistant with Proactive Work Context

1. What Is OpenHuman

OpenHuman is an open desktop "personal AI super intelligence" from tinyhumansai—not a passive chatbot but a desktop agent that proactively senses work context. Every 20 minutes it syncs 118+ third-party apps into a local persistent memory system so the AI understands habits and information flow before you ask. Built with Rust, TypeScript, and Tauri for macOS, Linux, and Windows, it emphasizes private deployment, ease of use, and depth.

Technical positioning and domain: Personal AI assistant / agent focused on desktop context awareness and long-horizon memory—combining auto-sync, hierarchical memory, model routing, and local-first privacy vs. generic chat or brittle plugins.

Development background: tinyhumansai targets private assistants that actually remember context without manual wiring, choosing Rust/Tauri for performance and privacy.

Core value: Fixes the cold-start problem: traditional assistants forget everything each session; OpenHuman preloads mail, calendar, repos, and tasks so work starts with full situational awareness.

Technical characteristics: Memory Tree compresses synced data into ≤3k-token Markdown chunks; TokenJuice cuts API cost up to ~80%; model routing picks light/reasoning/vision backends; Ollama or LM Studio enables offline local models.

2. Key Features

• Memory Tree hierarchical persistence: Normalized ≤3k-token Markdown segments scored and folded into a summary tree in local SQLite—cross-session memory without repeating context every chat.

• 118+ OAuth integrations + MCP/Skills ecosystem: Gmail, Notion, GitHub, Slack, Linear, Jira, Stripe, Calendar, Drive, Outlook, Telegram, Discord, and more—no custom connector code. On top of that, OpenHuman browses 5,000+ MCP servers (Model Context Protocol — Smithery + official registry) and a 90,000-entry Skills catalog (from HermesHub, ClawHub, LobeHub, etc.), installable as typed tools or capability bundles with one click.

• 20-minute auto-fetch: Background sync pulls fresh data; next morning the agent already knows yesterday's mail, tasks, and code changes.

• TokenJuice compression: HTML→Markdown, URL shortening, ASCII cleanup before LLM calls—up to ~80% token savings on paid APIs.

• Built-in model routing: Auto-selects fast, reasoning, or vision models under one subscription-style setup.

• Obsidian Vault export: Synced chunks as Obsidian .md files—Graph View for human-readable knowledge graphs.

• Desktop mascot UX: Visual agent with STT and ElevenLabs TTS/lip sync; can join Google Meet as a participant for live notes.

• Built-in toolchain: Web search, scraping, filesystem/Git/lint/test/grep tools without extra plugins.

3. How to Use

OpenHuman is still in Early Beta (latest v0.58.7, 2026‑06‑30). All steps below are based on official docs and the main branch README.

1. Installation

The official recommendation is now native package install paths because they go through signing checks and let the OS package manager resolve runtime dependencies; script installs still exist but are explicitly noted as unsigned. Everyday users should prefer native packages.

Option A: Native packages (recommended)

• macOS (Homebrew tap):

  brew tap tinyhumansai/core
  brew install openhuman
  

• Linux (Debian/Ubuntu — release .deb):

  # Download from https://github.com/tinyhumansai/openhuman/releases/latest
  # OpenHuman_<version>_amd64.deb or _arm64.deb, then:
  sudo apt-get install -y --no-install-recommends ./OpenHuman_*_amd64.deb
  

• Linux (Arch): the repo ships a packages/arch/openhuman-bin AUR recipe — install with yay -S openhuman-bin.
• Windows: download the signed .msi from GitHub Releases and run it.
• Manual: grab .dmg / .deb / .AppImage / .msi directly from Releases.

⚠️ Linux caveats: AppImage can crash under Wayland, miss libgbm.so.1, or error with sharun: Interpreter not found! on Arch (see issue #2463). Debian/Ubuntu users should prefer the .deb path — apt resolves runtime deps.

Option B: Script install (unsigned — use with caution)

## 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

⚠️ Warning: these scripts are served live from raw.githubusercontent.com with no separate signature (install.sh.asc / install.ps1.asc are not yet shipped alongside releases — see issue #2620), so tampering cannot be detected. Prefer Option A.

On Debian/Ubuntu, install.sh resolves the latest .deb first and installs it with apt-get. Set OPENHUMAN_INSTALLER_LINUX_PACKAGE=appimage to force the AppImage path.

Option C: Website download

Visit https://tinyhumans.ai/openhuman, pick your platform's installer, and double-click to install.

2. First Launch & Login

Sign in with your OpenHuman account. By default you use the managed backend: sign-in, model routing, web search proxying, and third-party OAuth handshakes are all handled by OpenHuman's servers (through the Composio connector layer). This means most users never need their own API keys.

Power users who want full control can switch to custom/local mode under Settings → Automation & Channels and bring their own models, search, or Composio credentials. Note: real‑time trigger webhooks must be self‑hosted in that mode.

3. One‑click Integrations

After launching the app, the onboarding UI walks you through connecting your tools. Click "Connect" on any integration — a browser OAuth window pops up. Once authorized:

1. The integration immediately becomes a typed tool the agent can call;
2. On the next 20‑minute tick it joins Auto‑fetch and syncs data into your local SQLite Memory Tree;
3. It also feeds your profile signals and can act as a trigger source for automations.

The integration catalog has grown: beyond the 118+ curated OAuth connectors (Gmail, GitHub, Slack, Notion, Stripe, Calendar, Drive, Linear, Jira, Outlook, Telegram, Discord, and more), OpenHuman browses:

• 5,000+ MCP servers (Model Context Protocol — Smithery + the official registry), installable as new typed tools with one click;
• 90,000+ Skills (aggregated from HermesHub, ClawHub, LobeHub, etc.) as installable SKILL.md capability bundles.

Find the directory under Settings → Skills or the "Connect" page. Start with your top 3–5 apps (Gmail / Notion / GitHub / Calendar / Slack) — you'll have rich context within hours.

4. Mascot & Chat Interaction

• Click the desktop mascot to start a conversation — voice input (STT) and ElevenLabs TTS with real‑time lip‑sync.
• The agent can join Google Meet as a real participant, transcribe the meeting live, and fold the transcript into the Memory Tree.
• Chat supports attachments (images, video, documents) via drag‑and‑drop and paste; code blocks get syntax highlighting.
• v0.58.x brought a Meetings redesign: platform selector, master‑detail Recent Calls layout, auto‑refresh, correct wake‑word forwarding, and more.

5. SuperContext — No Cold Starts

A recent differentiator:

• Tick "SuperContext" in the Composer (chat input), or set context.super_context_enabled = true in config.toml.
• When enabled, the first turn of every new thread deterministically spawns a read‑only context_scout sub‑agent that sweeps the Memory Tree, local files, and connected data, assembling a bounded context bundle — prepended to your message before the main model ever reads it.
• Net effect: your very first question already has context — zero round‑trips.

6. Goals & Todos

• Long‑term goals: MEMORY_GOALS.md is a human‑editable list that self‑reflects against recent activity.
• Per‑thread goal: each thread can carry a single durable goal with an optional token budget — the agent works across turns, idle periods, and interruptions (autonomous idle continuation).
• Kanban todo board: every conversation hosts a todo panel you and the agent build together — plans, acceptance criteria, approval gates, and all.

7. Memory Tree & Obsidian Wiki

• Memory Tree: all synced content is canonicalized into ≤3k‑token Markdown chunks, scored, and folded into hierarchical summary trees in local SQLite (not user‑editable — it's the agent's reasoning substrate).
• Obsidian Wiki: the same chunks land as .md files in a local vault — open it in Obsidian for Graph‑View browsing and manual editing.
• Two faces of the same data: Memory Tree for the AI, Obsidian Wiki for you.
• Optional: if you self‑host agentmemory across Claude Code / Cursor / Codex / OpenCode, set memory.backend = "agentmemory" in config.toml to share one durable memory store across multiple tools.

8. Theme Studio (Optional)

Head to Settings → Theme Studio:

• Switch among 5 built‑in theme families (Classic, Ocean, Sepia, Matrix, HAL 9000 × light/dark/auto = 15 combos).
• Visually tweak every colour token with live contrast warnings.
• Pick fonts, WebGL‑mesh / flat / custom‑image backdrops.
• Import/export themes as JSON — editing a preset auto‑forks a custom theme so originals stay pristine.

9. Local AI (Opt‑in, Off by Default)

Since v0.58, local AI is explicit opt‑in and ships off to avoid unnecessary hardware footprint. Turn it on when you need it:

Prerequisites:

• Install Ollama or LM Studio (LM Studio needs its local server enabled, default http://localhost:1234/v1).
• 8 GB+ RAM (16 GB+ recommended), plus several GB of disk for model weights.
• Default local models: all-minilm:latest (~23 MB embeddings), gemma3:1b-it-qat (~700 MB summaries).

Steps:

1. Open Settings → AI & Skills → Local AI.
2. Pick a preset: embeddings only, memory + reflection, or everything local.
3. To route Chat / Reasoning locally, set the provider fields in config.toml:

   local_ai.runtime_enabled = true
   local_ai.opt_in_confirmed   = true
   chat_provider        = "ollama:llama3.1:8b"
   reasoning_provider   = "ollama:qwen2.5:14b"
   embeddings_provider  = "ollama:all-minilm:latest"
   

4. OpenHuman performs a startup health check; if Ollama / LM Studio is unreachable, requests transparently fall back to cloud — no dead state.
5. Override the LM Studio port with OPENHUMAN_LM_STUDIO_BASE_URL (or local_ai.base_url).

Background workloads — embeddings, summary‑tree building, heartbeat, learning reflection, subconscious — are especially good candidates for local AI: they use small models and handle sensitive data.

10. Built‑in Tools (Zero Install)

Just issue commands in chat:

• Search for the latest AI papers → Web Search
• Scrape this page → Web Scraper
• grep "TODO", git status, cargo test → Coder toolset (filesystem, git, lint, test, grep)
• Scheduled tasks → Cron & Scheduling; browser/desktop control and agent coordination are documented in the native-tools pages.

11. Messaging Channels (Let the Agent Reach You)

Set your default under Settings → Automation & Channels → Messaging Channels:

• Telegram (primary): bidirectional, 80+ automated actions (send messages, manage groups, search history…), credentials encrypted.
• Discord: send/receive messages.
• Web: the in‑app, fully‑local browser‑based chat interface.

4. Pros and Cons

5. Comparison with Similar Tools

Selection guidance: Knowledge workers wanting zero-config cross-app context should pick OpenHuman. Teams needing MIT licensing and deep CLI customization may prefer OpenClaw or Hermes with DevOps effort.

6. Editor's Take

OpenHuman's pairing of auto-sync with hierarchical memory solves the "every chat starts from zero" failure mode of most assistants. TokenJuice makes sustained use economically viable—a real product concern, not an afterthought.

Cross-app project summaries (GitHub + Linear + Slack) can save hours weekly; Obsidian export is a standout for PKM users building Karpathy-style LLM notebooks. The mascot is fun but secondary to core productivity.

First-sync friction and routing inflexibility are fixable; the memory/sync core already delivers for PMs, tech leads, and privacy-conscious enterprises.

— Strong innovation and utility; minor UX and ecosystem gaps.

7. Use Cases

• Cross-app project context: One question yields PR status, board tasks, and Slack threads together.

• Smart email triage: "What needs a reply today?" based on synced Gmail memory.

• Meeting copilot: Mascot in Meet for notes, action items, and attendee history from memory.

• Repo Q&A: Ask about functions, refactor rationale, or PR debates with synced GitHub context.

• Obsidian knowledge base: Auto-archive mail/docs/chat into linked notes you curate.

• Multi-tool workflows: Calendar ↔ Drive ↔ Stripe chains for demo prep or client status checks.

8. FAQ

Q: Chinese support?

A: UI and STT support Chinese; some synced app data may be English-heavy. Set UI language to Chinese for best UX.

Q: Is it free?

A: Software is open (GPL-3.0); cloud models require subscription. Ollama or LM Studio local path is fully free.

Q: Does data leave my machine?

A: Synced workflow data stays local encrypted. Cloud model queries send prompts to providers; Ollama or LM Studio keeps everything offline.

Q: Performance impact?

A: Rust/Tauri keeps footprint low; background sync usually <5% CPU. Tune interval or off-hours sync if needed.

Q: Custom routing rules?

A: Supported since v0.58+. Set *_provider fields in config.toml per workload. For example, chat_provider = "ollama:llama3.1:8b" routes chat to a local Ollama model; reasoning_provider = "ollama:qwen2.5:14b" routes reasoning. Unset or cloud values keep the default cloud route. LM Studio is also supported as a local provider via its OpenAI-compatible endpoint. See Settings → AI & Skills → Local AI for preset configurations.

Q: Obsidian disk usage?

A: ~2–5 KB per chunk; ~100–200 MB/year typical for moderate use—prune retention in settings.

Q: Bad speech recognition?

A: Use quiet rooms or better mics; fall back to typing; noise suppression improvements expected.

9. Project Links

• Website: https://tinyhumans.ai/openhuman
• GitHub: https://github.com/tinyhumansai/openhuman