What is OpenHuman?

Imagine having a super-smart assistant that lives on your computer, reads your emails, checks your calendar, browses your documents — and remembers all of it. That's OpenHuman.

It's a desktop application you install on your computer (Mac, Windows, or Linux). Unlike ChatGPT or Claude which live in the cloud and forget you the moment you close the tab, OpenHuman lives on your machine and builds a personal knowledge base from your actual data.

What happens when you use it?

Let's trace what happens from the moment you open the app to when it responds to your question. Think of it like a postal system — you drop a letter (your question), it goes through a sorting facility (the Rust core), and a response comes back to your mailbox (the screen).

The starting line: where the app begins

Every application has a “front door” — the first line of code that runs when you launch it. In OpenHuman, that's a file called main.rs written in Rust. Let's see what it does:

fn main() {
    // Load settings from a .env file
    let _ = dotenvy::dotenv();

    // Start the error tracking system
    let _sentry_guard = sentry::init(...);

    // Grab the command-line arguments
    let args: Vec<String> =
        std::env::args().skip(1).collect();

    // Hand off to the core engine
    if let Err(err) =
        openhuman_core::run_core_from_args(&args)
    {
        eprintln!("{err}");
        std::process::exit(1);
    }
}
            

Check your understanding

Meet the troupe

Like a movie production where the director, actors, camera crew, script supervisor, and editor each have distinct jobs, OpenHuman splits its work across five components:

Where the code lives

The project is organized like a house with distinct rooms. Each folder has a clear purpose:

How they're wired together

Click any component to learn what it does and how it connects to the others:

The layering in action: how the app boots

When you open the app, React loads a chain of “providers” — each one sets up a different piece of the puzzle before the UI appears. It's like building a sandwich layer by layer:

App() {
  return (
    <Sentry.ErrorBoundary>
      <Provider store={store}>
        <PersistGate>
          <BootCheckGate>
            <CoreStateProvider>
              <SocketProvider>
                <ChatRuntimeProvider>
                  <Router>
                    {/* Your screens appear here */}
                  </Router>
                </ChatRuntimeProvider>
              </SocketProvider>
            </CoreStateProvider>
          </BootCheckGate>
        </PersistGate>
      </Provider>
    </Sentry.ErrorBoundary>
  )
}
            

Check your understanding

The postal system inside your app

Think of OpenHuman's internals like a city's postal system. The React frontend is a citizen dropping letters in a mailbox. The Tauri shell is the mail truck carrying letters between the citizen and the post office (the Rust core). Inside the post office, different departments (memory, agent, integrations) send internal memos to each other via pneumatic tubes (the event bus).

Trace a message from click to response

Watch what happens when you type “Summarize my latest emails” and press Enter:

The internal memo system: Event Bus

Inside the Rust core, modules don't call each other directly. Instead, they broadcast events — like sending a memo to the entire office. Anyone who cares about that memo can act on it. Watch how a scheduled job triggers a notification:

What an event looks like in code

Events in OpenHuman are defined as a Rust enum called DomainEvent. Each variant is a different type of event that can happen:

pub enum DomainEvent {
    // An agent turn started
    AgentTurnStarted {
        session_id: String,
        channel: String,
    },
    // A memory entry was stored
    MemoryStored {
        key: String,
        category: String,
        namespace: String,
    },
    // A scheduled job completed
    CronJobCompleted {
        job_id: String,
        success: bool,
    },
}
            

Check your understanding

Your data, organized like a library

Imagine a library where every book is about you — your emails are in one section, your calendar events in another, your code commits in a third. A librarian (the Memory Tree system) reads every new book, writes a summary card, and files it in the right section. When you ask a question, the librarian knows exactly which books to pull.

That's essentially what OpenHuman does. Here's how the “librarian” works:

118+ connections, one-click setup

OpenHuman connects to the tools you already use. Each integration is exposed to the AI agent as a “tool” — a capability it can use. Think of each tool as a different hand the AI can reach out with:

How memories get created

Let's watch the components collaborate when new data arrives from Gmail:

In code: the memory pipeline events

The Memory Tree system uses events to coordinate the pipeline. Here's what those events look like:

pub enum DomainEvent {
    // Memory events
    MemoryStored {
        key: String,
        category: String,
        namespace: String,
    },
    MemoryIngestionStarted {
        document_id: String,
        title: String,
    },
    MemoryIngestionCompleted {
        document_id: String,
        chunks_created: usize,
    },
}
            

Check your understanding

TokenJuice: making every word count

Think of tokens like postage stamps. Every word sent to the AI costs a stamp. Most raw data — HTML emails, API responses, web pages — is packed with formatting junk that adds stamps without adding meaning. TokenJuice strips the junk so you send fewer stamps.

// Secret scrubbing patterns in main.rs
static SECRET_PATTERNS: Lazy<Vec<(Regex, &str)>> =
    Lazy::new(|| vec![
    (r"(?i)(bearer\s+)\S+",  "${1}[REDACTED]"),
    (r"(?i)(api[_-]?key[=:\s]+)\S+",
                          "${1}[REDACTED]"),
    (r"(?i)(token[=:\s]+)\S+",
                          "${1}[REDACTED]"),
    (r"sk-[a-zA-Z0-9]{20,}",
                          "[REDACTED]"),
]);
            

Smart model routing: the right brain for the job

Not every question needs the smartest (and most expensive) AI model. “What time is it?” doesn't need the same brain as “Analyze my quarterly revenue trends.” OpenHuman routes each task to the right model — like a hospital routing patients to the right specialist:

You can also run models locally via Ollama for complete privacy — no data leaves your machine at all.

Security: multiple layers of protection

OpenHuman treats your data like a bank treats money — multiple vaults, multiple guards, multiple audit trails. Here are the key security layers:

Skills: giving the agent new abilities

The agent isn't limited to built-in tools. OpenHuman has a skills system that lets it learn new tricks — like installing apps on your phone. Skills run in a sandbox (a safe, isolated space) powered by QuickJS.

The big picture

You've now seen how OpenHuman works end-to-end. Here's the full architecture in one view:

Final quiz