Where to Find OpenHuman Documentation: Complete Guide to GitBook, README, and Source Files

OpenHuman documentation is available on the GitBook site at tinyhumans.gitbook.io/openhuman, in the repository root README.md, and throughout the codebase in markdown files under gitbooks/ and docs/ directories.

The tinyhumansai/openhuman repository maintains comprehensive openhuman documentation both online and in-source. Whether you are setting up a local development environment or researching architectural decisions, the project provides multiple entry points ranging from high-level guides to inline code comments.

Primary Documentation Sources

The fastest way to get oriented with the project is through the three primary documentation hubs shipped with every release.

GitBook Online Documentation

The GitBook site at https://tinyhumans.gitbook.io/openhuman/ serves as the primary navigation hub for newcomers. It contains the full developer guide, architecture deep-dives, getting-started tutorials, feature walkthroughs, and API reference materials. The root README.md links directly to this site via a "Docs" badge, making it the authoritative source for the latest published guides.

Root README

The README.md file in the repository root provides the immediate entry point for installation instructions, quick-start steps, and a badge-driven status board. It functions as the high-level project overview and dispatcher, pointing contributors toward deeper resources like the architecture documents and contribution guidelines.

Architecture Deep Dive

For system design details, refer to gitbooks/developing/architecture.md. This file contains a diagrammatic description of the monorepo layout, runtime scope, socket synchronization, tool-protocol specifications, security layers, and data flow. It is the definitive reference for understanding how the Rust backend and TypeScript frontend interact.

In-Repository Documentation Structure

Beyond the primary entry points, the repository organizes feature-specific and workflow documentation into dedicated markdown files.

Agent and Contribution Guides

• AGENTS.md: Describes the agent harness, tool registration mechanisms, and sandboxing model.
• CONTRIBUTING.md: Outlines how to set up a development environment, run tests, and submit pull requests.

Feature-Specific Documentation

The gitbooks/features/ directory contains individual pages for specialized components:

• Memory Tree implementation
• Token Compression algorithms
• Native Tools (web-search, scraper, voice)
• Privacy and security policies

Technical Design Notes

The docs/ directory houses low-level design notes, security audit reports, release process documentation, and advanced "how-to" guides. These files are maintained for contributors who need to understand the rationale behind specific implementation choices.

Code-Level Documentation

The source code itself serves as the ground-truth reference for API signatures and implementation details.

Rust Source Comments

In src/main.rs and the broader src/ directory, you will find inline //! doc comments and module-level mod.rs exports. These Rust-doc comments document the core binary entry point, Sentry initialization, and CLI dispatch logic.

Frontend Configuration

The app/src/utils/config.ts file contains frontend configuration constants that mirror backend build tags, environment variables, and feature flags. The app/README.md explains how to develop the React/Tauri UI, including available npm scripts, linting rules, and testing procedures.

How to Access Documentation Programmatically

You can programmatically open or fetch documentation from within the project using the following utilities.

Open the README in Your Default Browser

The following Rust binary opens the GitHub README directly in 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 this with cargo run --bin open_docs to jump straight to the documentation.

Fetch Architecture Documentation via API

To retrieve the architecture markdown directly for CLI preview:

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

Use this TypeScript snippet to enumerate all local markdown documentation:

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

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 every documentation file shipped with the repository.

Summary

• Start with the GitBook site at tinyhumans.gitbook.io/openhuman for the complete developer guide and tutorials.
• Reference the README.md in the repository root for installation steps and quick-start links.
• Study gitbooks/developing/architecture.md for detailed system design and data flow diagrams.
• Consult AGENTS.md and CONTRIBUTING.md for specific guidance on agent development and contribution workflows.
• Explore docs/ and gitbooks/features/ for low-level technical notes and feature-specific guides.
• Read inline comments in src/main.rs and app/src/utils/config.ts for implementation-level API documentation.

Frequently Asked Questions

Where is the official OpenHuman documentation hosted?

The official openhuman documentation is hosted on GitBook at https://tinyhumans.gitbook.io/openhuman/. This site provides the primary developer guide, architecture documentation, and API reference. The repository also mirrors these documents in the gitbooks/ directory so you can reference the exact source that generated the online content.

How do I find the architectural documentation for OpenHuman?

The architectural blueprint is located at gitbooks/developing/architecture.md in the repository. This file contains detailed descriptions of the monorepo layout, runtime scope, socket synchronization, tool-protocol, and security layers. You can view it directly on GitHub or fetch it programmatically using the Rust example provided above.

What is the purpose of the AGENTS.md file?

AGENTS.md provides a high-level description of the agent harness, including how tools are registered and how the sandboxing model operates. This file is essential reading for developers who want to understand how OpenHuman isolates and manages agent execution environments.

Can I access the documentation offline?

Yes. Since all openhuman documentation lives in the repository as markdown files (under gitbooks/, docs/, and the root directory), you can access the complete documentation offline by cloning the repository. The GitBook site is generated from these same files, ensuring consistency between online and offline sources.

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