Development Overview

OpenHuman is open source under GNU GPL3. This page is the high-level shape; the deep developer architecture lives in the Deep Architecture Reference in the codebase.

Shape

OpenHuman is a React + Tauri v2 desktop app with a Rust core that does the heavy lifting.

┌──────────────────────────────────────────────────┐
│ Tauri shell (app/src-tauri/) │
│ • Windowing, OS integration, sidecar lifecycle │
│ • CEF sub-WebViews for integration providers │
└──────────────────────────────────────────────────┘
  │ JSON-RPC (HTTP) ↕
┌──────────────────────────────────────────────────┐
│ Rust core (`openhuman` binary, `src/`) │
│ • Memory tree pipeline │
│ • Integration adapters + auto-fetch scheduler │
│ • Provider router (model routing) │
│ • TokenJuice compression │
│ • Native tools (search, fetch, fs, git…) │
│ • Voice (STT input, TTS output, meeting assistant) │
└──────────────────────────────────────────────────┘
  │
┌──────────────────────────────────────────────────┐
│ React frontend (app/src/) │
│ • UI, navigation │
│ • Communicates with core via `coreRpcClient` │
│ • No business logic — display only │
└──────────────────────────────────────────────────┘

Where the logic lives:

• Rust core: All business logic. Memory tree, integrations, model routing, tools, voice. Authoritative.
• Tauri shell: Windowing, process lifecycle, IPC. Delivery mechanism, not where features live.
• React frontend: UI and orchestration. Calls core via JSON-RPC.

Data Flow

1. Connect. OAuth into integrations. Backend stores token; core never sees it in plaintext.
2. Auto-fetch. Every twenty minutes the scheduler iterates each active connection and requests each native provider to sync.
3. Normalize. Provider outputs (email threads, GitHub diffs, Slack channel dumps) are normalized into Markdown with provenance.
4. Chunk. Markdown is split into deterministic chunks of ≤3k tokens.
5. Store. Chunks go into SQLite (<workspace>/memory_tree/chunks.db) and as .md files into <workspace>/wiki/.
6. Score. Background workers run embeddings, entity extraction, hot scoring.
7. Summarize. Source/topic/global summary trees are built and refreshed from the chunk pool.
8. Retrieve. When you ask a question, the agent queries the memory tree (search/drill/topic/global/retrieve).
9. Compress. Tool outputs and large source data are processed by TokenJuice before entering LLM context.
10. Route. The router picks the right provider+model for the task prompt.

Privacy Boundary

Stays on your machine:

• Memory tree SQLite database
• Obsidian Markdown vault
• Audio capture buffers and any local model state

Goes through OpenHuman backend (under one subscription):

• LLM calls (model providers)
• Web search agents
• Integration OAuth and tool agents
• TTS streaming

Open Source

• Repo: github.com/tinyhumansai/openhuman. GNU GPL3.
• Issues and PRs welcome. Project is in early testing phase.
• For contributors, the spec developer guide is the Deep Architecture Reference.

Next Steps

• Getting Set Up - Build from source
• Architecture - Complete architecture
• Testing Strategy - Testing hierarchy