Steven EnamakelandGitHub
bfaabd3b86
* chore: update AlphaHuman version to 0.49.3 and configure updater plugin in tauri.conf.json - Bumped the AlphaHuman package version in Cargo.lock to 0.49.3. - Added updater configuration in tauri.conf.json to enable automatic updates with specified endpoints. * refactor: rename AlphaHuman to OpenHuman across the codebase - Updated all instances of "AlphaHuman" to "OpenHuman" in comments, tooltips, and constants to reflect the new branding. - Adjusted relevant documentation and prompts to ensure consistency with the new name. * refactor: update documentation and configurations to reflect OpenHuman branding - Replaced all instances of "AlphaHuman" with "OpenHuman" in documentation, comments, and configuration files to ensure consistency with the new branding. - Updated deep link URLs and related authentication flows to use the new "openhuman://" scheme. - Adjusted paths and references in the skills system and other related files to align with the new project name.te * refactor: standardize OpenHuman references and update configurations - Replaced all instances of "AlphaHuman" with "OpenHuman" across documentation, comments, and configuration files to maintain branding consistency. - Updated URLs and paths to reflect the new "openhuman://" scheme. - Adjusted environment variable names and related settings to align with the new project identity. - Enhanced documentation for clarity and accuracy regarding the OpenHuman framework.r * chore: update subproject commit reference in skills directory * refactor: update backend URL to reflect new service domain - Changed default backend URL from "https://api.openhuman.xyz" to "https://api.tinyhumans.ai" in both JavaScript and Rust configuration files. - Ensured consistency across the codebase regarding the new backend service endpoint. * feat: introduce identity and migration modules for OpenHuman - Added a new identity module to support AIEOS v1.1 JSON format, including structures for identity, psychology, linguistics, motivations, capabilities, physicality, history, and interests. - Implemented a migration module to facilitate data migration from OpenClaw memory, including SQLite and Markdown sources, with detailed reporting on migration statistics and warnings. - Established utility functions for handling multimodal content and image processing within the OpenHuman framework. - Enhanced the agent system with new dispatcher and classifier functionalities to improve tool management and message classification. * chore: remove Android project files and configurations - Deleted various Android project files including .editorconfig, .gitignore, build.gradle.kts, gradle.properties, and others to clean up the project structure. - Removed all related resources, layouts, and source files from the Android app directory to streamline the codebase. - This cleanup is part of a larger effort to refactor and simplify the project structure. * refactor: update login flow and remove Telegram integration - Removed the TelegramLoginButton component and its references from the OAuthLoginSection, streamlining the login options. - Updated the AppRoutes to remove the login route, reflecting changes in the authentication flow. - Enhanced the RotatingTetrahedronCanvas component with improved geometry and lighting effects for better visual presentation. - Adjusted the TypewriterGreeting component's styling for consistency. - Cleaned up the Welcome page to integrate the OAuthLoginSection directly, improving user experience. * chore: update subproject commit reference in skills directory * chore: update test configurations and improve test assertions - Modified test scripts in package.json to use a specific Vitest configuration file for consistency. - Updated assertions in loader tests to ensure loading durations are non-negative. - Enhanced tool loading tests to clarify expected behavior regarding localStorage and cache management. - Adjusted agent tool registry tests to improve error handling and ensure accurate statistics. - Refined device detection tests to reflect updated fallback URLs. * fix: enhance parameter formatting and remove unused components - Updated the `formatParameters` function to handle cases where schema properties are empty, returning a more informative response. - Deleted the `DownloadScreen` component and associated device detection utilities to streamline the codebase and remove unused functionality. - Adjusted tests to reflect changes in the tool loading and agent tool registry, ensuring accuracy in assertions. * chore: simplify Vitest configuration by removing unused include patterns - Updated the Vitest configuration to remove unnecessary test file patterns, streamlining the test setup for better clarity and maintainability. * refactor: update paths and comments for AI configuration and file watching - Modified Vite configuration to ignore only the `src-tauri` directory. - Updated logging messages to reflect the correct path for writing AI configuration files. - Adjusted fetch calls in the file watcher to use the new path for `TOOLS.md`. - Revised comments and logic in Rust code to clarify the handling of AI configuration file paths, including legacy fallback options. * chore: remove unused updater secrets from GitHub Actions workflow - Deleted UPDATER_GIST_URL and UPDATER_GIST_ID environment variables from the package-and-publish workflow, streamlining the configuration. * chore: comment out Vitest thresholds for clarity - Commented out the thresholds section in the Vitest configuration to improve clarity and maintainability, as it is currently not in use. * ran formatter * chore: update updater public key in tauri configuration - Replaced the existing public key in the updater plugin configuration with a new value to ensure proper functionality and security. * chore: update ESLint configuration and refactor components - Added `localStorage` and `sessionStorage` as readonly globals in ESLint configuration for better linting support. - Removed unused imports from `SkillsPanel.tsx` to clean up the code. - Changed the type of `watcherInterval` in `file-watcher.ts` for improved type safety. - Refactored toast management logic in `Intelligence.tsx` to enhance clarity and maintainability. - Simplified import statements in `IntelligenceProvider.tsx` for consistency. - Streamlined object property shorthand in `agentToolRegistry.ts` for cleaner code. * refactor: improve error handling and type safety in Intelligence component - Enhanced toast notification logic to defer state updates, preventing potential issues with setState in effects. - Updated the source filter dispatch to use a more specific type for improved type safety. * refactor: enhance type safety across various components and services - Updated type definitions from `any` to `unknown` in multiple files to improve type safety and prevent potential runtime errors. - Refactored state management in `TauriCommandsPanel` to use more specific types. - Adjusted context and parameters in several interfaces to ensure consistent typing. - Added ESLint directive to `polyfills.ts` for intentional global assignments. - Streamlined type handling in utility functions and API responses for better clarity and maintainability. * refactor: streamline import statements and improve code clarity - Consolidated import statements in `agentToolRegistry.ts` and `intelligenceSlice.ts` for better readability. - Simplified the `createTestStore` function in `test-utils.tsx` to enhance code conciseness. - Cleaned up the `isExecutionStepProgressEvent` function in `intelligence-chat-api.ts` for improved clarity and maintainability.
8.2 KiB
icon
| icon |
|---|
| brain |
How It Works
OpenHuman is built on three technology pillars: a memory engine called Neocortex, a subconscious system inspired by human neuroscience, and a privacy-preserving architecture that keeps raw data on your device. Understanding how these work together is understanding how OpenHuman thinks.
The problem OpenHuman solves
Current AI systems fall into the category of Artificial Narrow Intelligence (ANI). They perform well within bounded domains, but they depend on carefully designed architectures and human-defined operational boundaries. They lack three things needed to get closer to general intelligence: persistent memory at scale, a form of consciousness or instinct, and the ability to ingest data without becoming inaccurate or expensive.
Research from Google's Titans project demonstrates the core issue clearly. As LLMs try to absorb more data, they become less accurate. Larger context windows do not solve this. They make the models slower, more expensive, and more prone to errors. This means the path to superhuman AI requires solving for context that is high accuracy, high speed, and low cost.
OpenHuman solves this in two steps.
Step 1: Neocortex, the memory engine
Neocortex is a human-like AI memory system that can accurately work with over 1 billion tokens. It is the foundation everything else is built on.
Speed. Neocortex indexes 10 million tokens in under 10 seconds. That is roughly 1,000x faster than other memory solutions. Everything that happens in your digital life can be processed in near real-time.
Accuracy. Neocortex goes far beyond vector databases. Vector databases retrieve whatever is semantically similar, but similarity alone does not indicate importance. Neocortex understands time and entities, ranking memories by recency, interaction patterns, and contextual relevance. It scores extremely high on RAG benchmarks (open-sourced on GitHub).
Cost. Neocortex does not use any LLMs to manage its intelligence. It runs on the CPU of a MacBook Air and costs $1 to index 5 million tokens. That is roughly 10x cheaper than other solutions. If an AI system is going to consume massive amounts of data, the economics have to work. They do.
Human-like recall for consciousness. This is the critical piece. Neocortex recalls memories and ranks them based on time, interactions, and randomness. This recall capability is what makes the subconscious system possible.
Neocortex uses a tiered memory architecture:
HOT memory holds the most recent and actively relevant context. WARM memory contains important information that has cooled slightly in relevance. COOL memory stores context that is less immediately useful but still retrievable. COLD memory holds the oldest and least-accessed information, kept but deprioritized.
This mirrors how the human brain works. A research paper from Carnegie Mellon University puts it concisely: intentionally forgetting some things helps us remember others by freeing up working memory resources. Further research published in Nature Reviews Neuroscience (Ryan & Frankland, 2022) confirms that forgetting is an active process, not passive decay. The brain has dedicated molecular machinery for it. Memories become temporarily inaccessible rather than erased. Environmental cues can reactivate them.
This is exactly what Neocortex does. Memories move from HOT to COLD tiers, but they are never deleted. Context cues bring them back. AI systems that try to remember everything, the vector database dump approach, are architecturally wrong. The brain does not work that way.
Additional capabilities of Neocortex:
Semantic deduplication strips redundant noise. In group chats, 80%+ of messages are repetitive. Neocortex removes this before it ever reaches the knowledge graph.
Cross-source entity resolution means a mention of "the Q4 deck" in Slack, a Notion page, and an email thread are understood as the same artifact. One entity, not three disconnected references.
Temporal context weighting uses time-decay functions so recent events carry more weight than older ones, matching how human attention naturally works.
Step 2: The personalized subconscious
With good memory and good recall, OpenHuman can do something no other AI agent does: maintain a personalized subconscious.
In the human brain, there is a specialized neuron called the Purkinje cell. It is mainly responsible for random thoughts and plays a significant role in consciousness. The human brain has both a conscious and subconscious mind that work together to build intelligence. Most agentic systems follow the conscious mind model only. They wait for instructions and execute them. They cannot think on their own.
Inspired by the Purkinje cell, OpenHuman uses Neocortex to periodically trigger global memory recalls. These recalls are fed into a subconscious loop that produces actions, confirmations, or new connections. Memory recalls are cheap, fast, and happen over 10,000 times a day for less than $1.
The result is an AI that does not just respond to your prompts. It thinks about your data in the background. It makes connections you did not ask for. It surfaces patterns and risks proactively.
The success metric for the subconscious is what the team calls the "mirror test": when you read the subconscious output, it should feel like looking at yourself in a mirror. Not a generic AI output. A reflection of your own thinking, priorities, and context.
How the pieces connect
When you use OpenHuman, here is what happens:
Connect your data sources. Telegram, Slack, Gmail, Notion, blockchain wallets, and more. Each connection expands your knowledge graph.
Neocortex compresses. Millions of tokens of organizational history become structured intelligence: entities, relationships, timelines, sentiment. Noise is stripped. Signal is preserved.
The subconscious runs. Thousands of recall loops per day surface proactive insights, track evolving patterns, and update the knowledge graph.
You interact naturally. Ask anything about your life, your team, your projects. Not general knowledge. Your knowledge. What did your team decide? What is the status? What did you miss? OpenHuman already knows.
Privacy is maintained. Raw data stays on device, encrypted with AES-256-GCM. Encryption keys never leave the device. Only compressed metadata and summaries are processed server-side.
The architecture: OpenClaw foundation
OpenHuman is built on top of the OpenClaw architecture and is open-sourced under the GNU GPL3 license. The full codebase is publicly available on GitHub.
The architecture uses multi-agent orchestration, where specialized agents are dynamically spawned for specific tasks rather than relying on one monolithic model. An orchestrator agent manages routing, personality, and context distribution. Specialist agents handle specific domains: communication analysis, document synthesis, task management, trading. These agents execute in parallel, not sequentially, for real-time responsiveness.
All agents share a common compressed context provided by Neocortex. This effectively creates a virtual context window far larger than any single model can support.
Limitations
OpenHuman works with probabilistic models. It may occasionally miss nuance, misinterpret sarcasm, or over-prioritize certain messages. This is more likely in highly informal conversations, fast-moving threads, or contexts with limited data.
OpenHuman is not AGI. It is a meaningful step closer, with better memory and better orchestration for memory, taking inspiration from the human brain. But human judgment still matters. OpenHuman helps you think faster. It does not think for you.
Everything is in early alpha. Feedback and contributions are welcomed.