Briefing
OpenHuman, the desktop AI agent from TinyHumans.ai, is reportedly built around one of the more unusual memory systems in any consumer AI tool. Its Memory Trees architecture takes everything you do, read, write, and say and folds it into an Obsidian-style Markdown wiki you can actually open and read yourself, while the agent queries it underneath. It pairs 118+ third-party integrations that pull fresh data every 20 minutes with a local knowledge base, Neocortex, that the maker says scales to a billion tokens on your own machine. The release said to carry all this, version 0.53.43, is reportedly dated 13 May 2026, though that specific version and date could not be confirmed against the project's public release history.
Most AI assistants forget you the moment a chat window closes. You explain your project, your preferences, the thing you tried last week that didn't work, and then next session you start over. OpenHuman's pitch is the opposite: an agent that quietly keeps a running record of your working life so you never have to brief it from scratch again.
The twist is where that record lives. Instead of locking your history inside a database you can't inspect, OpenHuman writes it to plain Markdown files on your computer. You can read them. You can edit them. If you ever want to walk away, you take the files with you. That design choice is the whole point, and it's what makes the system worth a closer look.
For a business team, the stakes are practical. An agent that remembers your codebase, your tickets, your meetings, and your half-finished decisions is genuinely useful. An agent that watches your screen and syncs more than a hundred services is also a privacy question you have to answer before you turn it on. OpenHuman's answer is to do as much as possible on-device. Here's how the pieces fit together.
The Memory Pipeline
Data reaches the Memory Tree through three routes: active input (what you type or say to the agent), passive observation (screen activity, browser history, file changes), and synced integrations (the 118+ outside services).
Active Input
Every conversation with OpenHuman gets transcribed, summarised, and sorted. Voice input runs through an on-device Whisper-derived speech-to-text model tuned for the Tauri runtime before anything else happens. The agent doesn't just keep the transcript. It pulls out entities, relationships, and action items and writes them as structured frontmatter inside the Markdown files.
---
date: 2026-06-12T14:33:00Z
type: conversation
entities: ["postgres", "migration", "v2.3.1"]
projects: ["billing-rewrite"]
sentiment: concerned
follow_up: true
---
Discussed database migration strategy for billing-rewrite. User is worried about
data integrity during the cutover. Suggested blue-green deployment pattern.
User prefers rolling migration with rollback capability.(The exact frontmatter fields above are illustrative; the official docs confirm scored Markdown memory chunks and summary trees, but not this precise schema.)
Passive Observation: Screen Intelligence
Screen Intelligence is the feature that sets OpenHuman apart. A small animated mascot sits on your screen, takes periodic screenshots, and runs them through a local vision model. It picks out applications, code, documents, and interface elements. Write code in VS Code and it reads the file names, function signatures, and error messages. Review a pull request on GitHub and it reads the diff and the comments.
That feed drives inline autocomplete that reacts to context, and not only code completion. Task completion too. If you've been reading up on something across a few browser tabs and then jump to your terminal, OpenHuman might offer a relevant command based on what it just watched you read.
Privacy here is local-first. All screen processing happens on the device, reportedly using an on-device Gemma 3 vision model. No screenshots leave your machine. Neocortex keeps the extracted text and metadata, not the raw images.
Synced Integrations
OpenHuman's 118+ integrations refresh every 20 minutes. The list covers GitHub, GitLab, Linear, Notion, Slack, Discord, Gmail, Google Calendar, and a long tail beyond those. Each integration maps its external data onto a shared schema in the Memory Tree format, so a GitHub issue, a Linear ticket, and a Notion task all land as the same underlying entity type, just with source-specific metadata attached.
interface MemoryNode {
id: string;
source: 'github' | 'linear' | 'notion' | 'conversation' | 'screen' | ...;
type: 'task' | 'note' | 'entity' | 'relationship' | 'code_snippet';
content: string; // Markdown body
metadata: Record<string, unknown>;
embeddings: Float32Array; // For semantic search
created: Date;
modified: Date;
parent?: string; // Tree reference
children?: string[];
}Compression and the Subconscious Loop
Raw context piles up fast, and left alone it would bury any knowledge base. OpenHuman's Subconscious is a background self-learning loop that keeps compressing the Memory Trees. According to the maker and early reviews, it runs on a few time horizons:
- Hourly: Merge duplicate entities, resolve aliases, update relationship graphs.
- Daily: Generate daily summaries, prune low-signal observations, promote high-signal patterns.
- Weekly: Produce weekly reflection documents that surface recurring themes, forgotten commitments, and emerging priorities.
(The Subconscious loop and daily summarisation are documented; the exact hourly/daily/weekly cadence above is described by the article rather than confirmed verbatim in the docs.)
Compression leans on a stack of summarisation models. Small local models do the routine merging. Larger models, routed through the multi-model subscription, take on the harder synthesis. What you end up with is a tree where the recent leaves stay detailed and older branches get folded down into summarised trunk documents.
Neocortex: Local Knowledge Base
Neocortex is the storage and search engine behind the Memory Tree. It supports up to a billion tokens locally and runs a hybrid search: BM25 for exact matches, dense embeddings for semantic similarity, and graph traversal for relationship queries. You ask in plain language and it translates the question into a structured graph query:
"What did I say about the billing migration last week?"That resolves to a filtered walk through conversation nodes, restricted by date, matching the entities "billing" and "migration," then ranked by recency and how strongly the relationships connect.
Tauri and Distribution
OpenHuman ships as a Tauri desktop app with native builds for macOS (DMG) and Windows (the GitHub docs list an MSI installer rather than a plain EXE). Picking Tauri over Electron reportedly keeps the binary under 15 MB and idle memory under 200 MB, though those specific figures aren't confirmed in the official release notes or docs. The Rust backend handles screen capture, file system watching, and the Neocortex search engine. The React frontend draws the Memory Tree UI and the desktop mascot.
One Subscription, Multi-Model Routing
Plenty of competitors bill per model or per token. OpenHuman uses a single subscription that covers multi-model routing instead. The system picks the cheapest model that can do the job: local models for simple classification, cloud models for harder synthesis, premium models only when the task earns it. The auto-fetching integrations and the Subconscious loop keep running in the background, so the Memory Tree stays current without you prompting it.
If you want to look under the hood yourself, the GitBook getting-started guide and the project releases are the places to start.