Files
openhuman/gitbooks
21f4f9d8d2 deploy openhuman-core to fly.io
## Summary

- Add `fly.toml` template for deploying `openhuman-core` headlessly to Fly.io, complementing the existing DigitalOcean and Docker Compose paths
- Document Fly.io as a fourth cloud deployment option in `gitbooks/features/cloud-deploy.md` with step-by-step setup (launch, volume, secrets, deploy, desktop connect)
- Include production-safe secret recommendations (`OPENHUMAN_AUTO_UPDATE_RPC_MUTATIONS_ENABLED=false`, `OPENHUMAN_AUTO_UPDATE_RESTART_STRATEGY=supervisor`) and token rotation guidance
- Document a known UID mismatch gotcha that surfaces when switching between the local `Dockerfile` build (UID 10001) and the pre-built GHCR image (UID 1000)

## Problem

There was no documented path for deploying `openhuman-core` to Fly.io, leaving users to figure out the configuration themselves. The UID mismatch between the local Dockerfile and the pre-built GHCR image also produced a silent `Permission denied (os error 13)` on the workspace volume with no documented fix.

## Solution

- `fly.toml` ships as a ready-to-use template with persistent volume mount, health check against `/health`, and non-sensitive env defaults. Sensitive values (`OPENHUMAN_CORE_TOKEN`, `BACKEND_URL`, etc.) are set via `fly secrets` as documented.
- The Fly.io section mirrors the structure of the existing DO and Docker Compose sections for consistency.
- The UID mismatch gotcha is documented with a concrete `chown -R` + `fly machine restart` fix.
- CI workflow is documented inline so users can opt in without a file being auto-triggered on the upstream repo.

## Submission Checklist

- [x] Tests added or updated — `N/A: documentation-only change, no executable code modified`
- [x] **Diff coverage ≥ 80%** — `N/A: documentation-only change`
- [x] Coverage matrix updated — `N/A: documentation-only change`
- [x] All affected feature IDs listed — `N/A: documentation-only change`
- [x] No new external network dependencies introduced — `N/A: no code changes`
- [x] Manual smoke checklist updated — `N/A: does not touch release-cut surfaces`
- [x] Linked issue closed — `N/A: no associated issue`

## Impact

- No runtime impact — documentation and template file only
- `fly.toml` is a template; upstream CI will not trigger Fly.io deploys (no `FLY_API_TOKEN` secret is set on the upstream repo)

## Related

- Closes: —
- Follow-up PR(s)/TODOs: Investigate unifying UID between local `Dockerfile` and GHCR image builds to eliminate the UID mismatch gotcha permanently

---

## AI Authored PR Metadata

### Linear Issue
- Key: N/A
- URL: N/A

### Commit & Branch
- Branch: `main` (fork: `umarhadi/openhuman`)
- Commit SHA: `9314fd6be519662fb931414b256de3c57f54e7b8`

### Validation Run
- [x] `pnpm --filter openhuman-app format:check` — N/A (no app code changed)
- [x] `pnpm typecheck` — N/A (no app code changed)
- [x] Focused tests: N/A
- [x] Rust fmt/check — N/A (no Rust code changed)
- [x] Tauri fmt/check — N/A (no Tauri code changed)

### Validation Blocked
- N/A

### Behavior Changes
- Intended behavior change: None — documentation and template only
- User-visible effect: Contributors can now follow a documented path to deploy `openhuman-core` to Fly.io

### Parity Contract
- Legacy behavior preserved: Existing DO and Docker Compose deploy paths unchanged
- Guard/fallback/dispatch parity checks: N/A

### Duplicate / Superseded PR Handling
- Duplicate PR(s): None known
- Canonical PR: This PR
- Resolution: N/A

<!-- This is an auto-generated comment: release notes by coderabbit.ai -->
## Summary by CodeRabbit

* **New Features**
  * Added Fly.io as a supported cloud deployment platform alongside existing options.

* **Documentation**
  * Expanded cloud deployment guide with full Fly.io setup: prerequisites, app launch/configuration, persistent volumes, secrets management, pointing desktop to hosted core, sample CI/CD workflow, image/tag guidance, log viewing, redeploy steps, and troubleshooting for volume UID mismatches.

<!-- review_stack_entry_start -->

[![Review Change Stack](https://storage.googleapis.com/coderabbit_public_assets/review-stack-in-coderabbit-ui.svg)](https://app.coderabbit.ai/change-stack/tinyhumansai/openhuman/pull/2295?utm_source=github_walkthrough&utm_medium=github&utm_campaign=change_stack)

<!-- review_stack_entry_end -->
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Co-authored-by: umarhadi <hi@umarhadi.dev>
Co-authored-by: Steven Enamakel <enamakel@tinyhumans.ai>
2026-05-20 16:44:35 -07:00
..
2026-05-10 02:52:14 +00:00
2026-05-20 16:44:35 -07:00
2026-05-09 00:17:29 -07:00
2026-05-14 05:40:41 +00:00

description, icon
description icon
Personal AI assistant for your desktop. Connects to 118+ services, builds a local-first memory of your life, self-reflects, and can interact with you over audio and video. diamond

Welcome to OpenHuman

OpenHuman is an open-source AI assistant designed to be the memory and doer for everything you do across your tools. Built on Rust + Tauri and licensed under GNU GPL3, it closes the gap between what AI models can do and what they actually know about you.

Every model in the world, all 200+ of them, shares the same fundamental limitation: they are stateless. You type a prompt, get a response, and the context evaporates. Even the ones with "memory" store a few bullet points. A few bullet points is a sticky note, not intelligence.

OpenHuman solves this with a stack that's calmly, deliberately different:

  • A local-first Memory Tree. Every source you connect. Gmail, Slack, GitHub, Notion, your own notes, flows through a deterministic pipeline: canonical Markdown, ≤3k-token chunks, scored, folded into per-source / per-topic / per-day summary trees. Stored in SQLite on your machine. No vector-soup black box.
  • An Obsidian-style wiki on top of it. The same chunks the agent reasons over land as .md files in a vault you can open in Obsidian, browse, edit, and link by hand. Inspired by Karpathy's obsidian-wiki workflow. You can't trust a memory you can't read.
  • 118+ third-party integrations. One-click OAuth into Gmail, GitHub, Slack, Notion, Stripe, Calendar, Drive, Linear, Jira and more - no API keys to wire by hand, no plugin marketplace to navigate.
  • Auto-fetch. Every twenty minutes, OpenHuman pulls fresh data from every active connection and folds it into the Memory Tree without you asking, so the agent already has tomorrow's context this morning.
  • An agent built for big data. Smart token compression (TokenJuice) compacts verbose tool output before it ever enters the model's context, so sweeping through your last six months of email costs single-digit dollars. Automatic model routing sends each task to the right model - hint:reasoning to a frontier model, hint:fast to a cheap one, vision to vision - all under one subscription. Optional local AI via Ollama or LM Studio keeps supported workloads on-device.
  • Batteries included. A complete agent toolbelt is wired in by default: web search, a web-fetch scraper, a full coder toolset (filesystem, git, lint, test, grep), browser & computer control, cron & scheduling, memory tools, agent coordination for spawning sub-agents, and native voice - STT in, TTS out, mascot lip-sync, and a live Google Meet agent that joins meetings, transcribes them into your Memory Tree, and can speak back into the call. No "install a plugin to read files" friction.
  • Simple, UI-first. A clean desktop experience and short onboarding paths take you from install to a working agent in a few clicks - no config-first setup, no terminal required. The agent has a face: a desktop mascot that speaks, reacts to its surroundings, joins your Google Meets as a real participant, remembers you across weeks, and keeps thinking in the background even when you've stopped typing.

Together, these turn OpenHuman into something fundamentally different from a chatbot. It is an AI agent that consumes large amounts of personal data at low cost, maintains a persistent and evolving understanding of your world, and takes proactive actions on your behalf.

{% hint style="warning" %} OpenHuman is not AGI. But it is a meaningful architectural step closer, with better memory, better orchestration, and better tooling. {% endhint %}