Where to Find OpenHuman Documentation: Complete Guide to GitBook and Repository Resources

OpenHuman documentation lives both on the public GitBook site at tinyhumans.gitbook.io/openhuman and inside the tinyhumansai/openhuman repository via markdown files like README.md, gitbooks/developing/architecture.md, and AGENTS.md.

The tinyhumansai/openhuman project maintains a dual-layer documentation strategy that combines a continuously updated GitBook site for user-friendly navigation with version-controlled markdown files for offline reference and source-level accuracy. Whether you are setting up your first agent or auditing the security architecture, this guide maps every documentation resource from quick-start guides to inline Rust API comments.

Primary Documentation Entry Points

GitBook Online Documentation

The primary navigation hub for OpenHuman is the GitBook site at https://tinyhumans.gitbook.io/openhuman/. This hosts the complete developer guide, getting-started tutorials, feature walkthroughs for Memory Tree and Token Compression, and the API reference. The GitBook content is generated from the markdown files stored in the repository’s gitbooks/ directory, ensuring the online version stays synchronized with code releases.

Repository README

Every documentation journey should start with the root README.md. This file provides high-level project overviews, installation instructions, quick-start badges, and a direct hyperlink to the GitBook site. As noted in the source analysis, the README functions as the project’s status board and primary landing page for new contributors.

In-Repository Documentation Structure

Architecture and Design Documents

For a detailed blueprint of the monorepo layout, runtime scope, socket synchronization, and security layers, reference gitbooks/developing/architecture.md. This file contains diagrammatic descriptions of the tool protocol and data flow that power the OpenHuman runtime. It is the authoritative source for understanding how the backend communicates with the frontend Tauri layer.

Feature-Specific Guides

The gitbooks/features/ directory contains individual markdown pages for specific capabilities:

• Memory Tree (memory-tree.md): Explains the persistent memory architecture
• Token Compression: Details on optimizing context window usage
• Native Tools: Documentation for web-search, scraper, and voice integration
• Privacy & Security: Security layer specifications and sandboxing policies

Contribution and Agent Documentation

Three critical files govern development workflows and system behavior:

• AGENTS.md: Describes the agent harness, tool registration mechanisms, and sandboxing model for AI agents
• CONTRIBUTING.md: Contains dev environment setup instructions, test commands (cargo test, pnpm test), and pull request guidelines
• docs/ (directory): Houses low-level design notes, security audit reports, release process documentation, and advanced "how-to" guides

Code-Level Documentation

Rust Source Documentation

The src/ directory uses Rust doc comments (//! and ///) to document modules and API signatures. The entry point at src/main.rs initializes Sentry, dispatches CLI arguments, and contains module-level exports that define the core runtime. When browsing offline, run cargo doc --open to generate browsable HTML from these comments.

Frontend Application Documentation

For the React/Tauri UI layer, reference app/README.md for npm scripts, linting configurations, and component architecture. Configuration constants that mirror backend build tags and feature flags are documented in app/src/utils/config.ts, which serves as the source of truth for environment-specific frontend behavior.

Programmatically Accessing OpenHuman Documentation

You can fetch or launch documentation directly from the command line using the following utilities.

Open README in Default Browser (Rust)

This helper binary resolves the GitHub URL and launches your system browser:

// src/bin/open_docs.rs
use std::process::Command;

fn main() {
    let url = "https://github.com/tinyhumansai/openhuman/blob/main/README.md";

    #[cfg(target_os = "linux")]
    let opener = "xdg-open";
    #[cfg(target_os = "macos")]
    let opener = "open";
    #[cfg(target_os = "windows")]
    let opener = "cmd";

    let status = if cfg!(target_os = "windows") {
        Command::new(opener).args(&["/C", "start", "", url]).status()
    } else {
        Command::new(opener).arg(url).status()
    };

    match status {
        Ok(s) if s.success() => println!("Opened documentation in browser!"),
        _ => eprintln!("Failed to launch your browser."),
    }
}

Run with cargo run --bin open_docs to jump directly to the README.

Fetch Architecture Markdown via HTTP (Rust)

For CLI previews without cloning the repository:

use reqwest::blocking::Client;
use std::error::Error;

fn fetch_architecture() -> Result<String, Box<dyn Error>> {
    let url = "https://raw.githubusercontent.com/tinyhumansai/openhuman/main/gitbooks/developing/architecture.md";
    let body = Client::new().get(url).send()?.text()?;
    Ok(body)
}

fn main() -> Result<(), Box<dyn Error>> {
    let arch = fetch_architecture()?;
    println!("--- OpenHuman Architecture (excerpt) ---\n{}", &arch[..500]);
    Ok(())
}

List Local Documentation Files (TypeScript)

When working with a local clone, enumerate available guides:

// scripts/list-docs.ts
import { readdir } from "fs/promises";

async function listDocs() {
  const gitbooks = await readdir("./gitbooks", { withFileTypes: true });
  for (const entry of gitbooks) {
    if (entry.isFile() && entry.name.endsWith(".md")) {
      console.log(`gitbooks/${entry.name}`);
    }
  }
}

listDocs().catch(console.error);

Execute with pnpm ts-node scripts/list-docs.ts to see all markdown documentation shipped with the repo.

Summary

• Start with the root README.md for installation steps and the GitBook link
• Use the GitBook site (tinyhumans.gitbook.io/openhuman) for comprehensive developer guides and feature tutorials
• Reference gitbooks/developing/architecture.md for offline system architecture and security layer details
• Check AGENTS.md for agent harness specifics and sandboxing policies
• Consult CONTRIBUTING.md and the docs/ directory for development workflows and security audits
• Generate docs from source using cargo doc for the Rust API and check app/README.md for frontend development

Frequently Asked Questions

Where is the official OpenHuman GitBook documentation hosted?

The official documentation is hosted at https://tinyhumans.gitbook.io/openhuman/. This site provides the complete developer guide, API reference, and feature walkthroughs, and it is continuously updated from the markdown files in the repository's gitbooks/ directory.

What is the difference between README.md and AGENTS.md?

The README.md provides a high-level project overview, installation instructions, and quick-start information for all users, while AGENTS.md specifically documents the agent runtime, including tool registration protocols, sandboxing policies, and the agent harness architecture for developers building AI agents.

How do I access the architecture documentation without internet access?

Clone the repository and open gitbooks/developing/architecture.md locally. This file contains the complete architectural blueprint including diagrams of the monorepo layout, socket synchronization, and security data flow, allowing offline reference to the system design.

Can I access OpenHuman documentation from the command line?

Yes, you can build the Rust documentation locally by running cargo doc --open in the project root, or use helper scripts to open the GitHub-hosted README in your default browser. The repository also includes TypeScript utilities in the scripts/ directory for listing local markdown documentation files.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}