Deploy and Host OpenHuman Core on Railway

OpenHuman is an open-source personal AI agent with a persistent, local-first memory of your world — a "Memory Tree" that ingests your Gmail, Notion, GitHub, and 100+ other services into a readable Obsidian-style knowledge graph, so the agent knows your context instead of starting cold every session. This template hosts the OpenHuman core — the Rust backend and its RPC endpoint — on Railway, so your memory brain and auto-fetch loop run 24/7 in the cloud, and your desktop OpenHuman app connects to it from anywhere.

What This Template Deploys

A single always-on service. A persistent volume holds the Memory Tree — the SQLite database and Markdown vault that make up your entire accumulated memory — so nothing is lost between restarts.

About Hosting

Understanding OpenHuman's architecture is essential to using this template correctly, because it hosts one specific part of the system.

This hosts the core backend, not the desktop app. OpenHuman ships primarily as a desktop application (Rust core + Tauri UI) with a mascot, screen awareness, and voice — features that belong on your own machine. But the brain — the persistent memory, the 20-minute auto-fetch loop that pulls your connected services, and the orchestration engine — is the Rust core, and it exposes an RPC endpoint. OpenHuman is explicitly built to support a custom core RPC URL for self-hosted backends. This template runs that core in the cloud.

Why put the core on Railway? The auto-fetch loop and background "subconscious" that diffs your world and writes your morning brief only run while the core is running — on your laptop, that stops when you close the lid. Hosted on Railway, your memory brain stays live around the clock, whether your machine is on or not. Your desktop app connects to this always-on core via its RPC URL and token instead of running the core locally.

The RPC token secures your entire memory. OPENHUMAN_CORE_TOKEN is the bearer credential for the RPC endpoint — and that endpoint has access to your complete personal memory graph. Set a strong token, keep it private, and connect your desktop app with it. Railway's automatic HTTPS encrypts the connection in transit.

The volume is your brain. The Memory Tree lives as a SQLite database plus a Markdown vault on the mounted volume. That is your accumulated memory of every connected service. Without a persistent volume, a redeploy erases it — so it's mounted here, and worth backing up.

You bring the models: OpenHuman routes to OpenAI-compatible endpoints (DeepSeek, an Ollama server, OpenRouter), so add your model API keys or point it at a model server. Inference happens at the provider; the core orchestrates.

Typical cost: ~$10–20/month on Railway for an always-on core with memory storage, plus your model API usage. OpenHuman is GPL-3.0 and free.

How It Compares

Desktop-only OpenHuman keeps everything on your machine but goes idle when the app is closed. Cloud assistants run 24/7 but own your data and start from scratch. Hosting the core on Railway gives you the best of both — an always-on memory brain and auto-fetch loop, with your data on a volume you control and the desktop app as your client.

Deploy in Under 5 Minutes

1. Click Deploy on Railway — the OpenHuman core builds automatically (~3 minutes)
2. Set OPENHUMAN_CORE_TOKEN to a strong secret — this authenticates your app to the core
3. Confirm the volume is mounted for the Memory Tree (SQLite + Markdown vault)
4. Add your model API keys (or point at a model server) so the core can run inference
5. In your desktop OpenHuman app, set the custom core RPC URL to your Railway domain and the token

Once connected, your app uses the cloud core, and the auto-fetch loop runs continuously.

Common Use Cases

• Always-on personal memory — keep the Memory Tree and auto-fetch loop running 24/7 so your agent always has fresh context
• Cloud-hosted digital brain — move OpenHuman's core off your laptop so it works while your machine is off
• Multi-device access to one brain — point desktop and other clients at a single hosted core with shared memory
• Private agent backend — run the orchestration and memory engine on infrastructure you own, models via your own keys
• Team or personal knowledge continuity — a durable, self-hosted memory graph that accumulates instead of resetting

Configuration

OPENHUMAN_CORE_TOKEN guards your entire memory. The RPC endpoint can read and write your full personal memory graph. Use a strong, unique token, never a default, and only share it with your own clients. Railway's HTTPS encrypts it in transit.

The Memory Tree volume is your brain — back it up. Your accumulated memory (SQLite + Markdown vault) lives on the volume. Without it, a redeploy erases everything the agent has learned about your world.

Dependencies for OpenHuman Core Hosting

• Railway account — expect ~$10–20/month for an always-on core with storage
• A persistent Railway volume for the Memory Tree (included)
• The OpenHuman desktop app as the client that connects to this core
• A model API key or OpenAI-compatible endpoint for inference

Deployment Dependencies

• OpenHuman GitHub Repository
• OpenHuman Documentation
• OpenHuman Releases
• Railway Volumes Documentation

Implementation Details

The template runs the OpenHuman Rust core with its RPC server exposed on Railway's assigned port. The core is the authoritative half of OpenHuman's architecture — business logic, execution, persistence, and the memory engine — while the desktop Tauri app is a client that connects over an RPC transport. OpenHuman supports a self-hosted core via a custom RPC URL and the OPENHUMAN_CORE_TOKEN bearer credential (honored for CLI, Docker, and cloud deployments), which is what makes this hosting model possible.

A persistent volume holds the Memory Tree: a SQLite database and a Markdown vault (Obsidian-compatible) where connected-service data is compressed into scored, hierarchical Markdown. The auto-fetch loop refreshes this on a roughly 20-minute cycle, and because the core runs continuously on Railway, that ingestion and the background "subconscious" loop keep working when your local machine is off.

Inference is delegated to whatever OpenAI-compatible model endpoint you configure, so the core runs on CPU and orchestrates rather than doing local inference. The desktop app connects by setting its core RPC URL to the Railway domain and authenticating with the token.

Frequently Asked Questions

Does this run the OpenHuman desktop app, mascot, and screen awareness? No — those are desktop features that stay on your machine. This hosts the core backend: the memory engine, auto-fetch loop, and RPC endpoint. Your desktop app connects to this cloud core as its backend.

Why host the core in the cloud? So the memory brain and auto-fetch loop run 24/7. On a laptop they stop when the app closes; on Railway they keep ingesting your services and preparing briefings around the clock.

How does my desktop app connect? OpenHuman supports a custom core RPC URL. Set it to your Railway domain and authenticate with OPENHUMAN_CORE_TOKEN, and the app uses the hosted core instead of a local one.

Do I need a model API key? Yes, for inference. OpenHuman routes to OpenAI-compatible endpoints — a provider API (DeepSeek, OpenAI, OpenRouter) or a model server you run. Add your key or endpoint so the core can think.

Does my memory survive a redeploy? Yes, on the mounted volume — the SQLite database and Markdown vault persist. Without the volume, everything the agent learned is lost, so keep it mounted and back it up.

Is OpenHuman free? Yes, GPL-3.0 open source. You pay only for Railway infrastructure and your own model API usage.

Why Deploy OpenHuman Core on Railway?

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying the OpenHuman core on Railway you get an always-on personal AI backend — a persistent Memory Tree, a continuous auto-fetch loop, and a secure RPC endpoint your desktop app connects to, with your entire memory graph on a volume you own. Keep your digital brain running around the clock, on infrastructure you control.