Files
openhuman/gitbooks/technology/neocortex.md
T
Steven EnamakelandGitHub bfaabd3b86 fix/rename (#20)
* 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.
2026-03-26 17:04:46 -07:00

6.3 KiB

Neocortex

Neocortex is OpenHuman's memory engine. It is a human-like AI memory system designed to work accurately with over 1 billion tokens of data while supporting the computational demands of a subconscious system.

Neocortex goes far beyond vector databases that simply store embeddings and retrieve whatever is semantically similar. It understands time, entities, and relationships. It builds knowledge graphs. It forgets strategically. It models memory the way the human brain does.

Why existing memory solutions fall short

Traditional AI memory tries to remember everything. It retrieves whatever is similar, but similarity alone says nothing about importance. A message from six months ago that happens to share keywords with your current query adds noise, not signal.

The deeper problem is architectural. Research from Google's Titans project shows that as LLMs absorb more data, they become less accurate. Larger context windows do not fix this. They make things worse: slower, more expensive, more error-prone.

Existing solutions like SuperMemory, Mem0, HydraDB, and MemGPT are not capable of supporting a conscious system, nor can they process data accurately at a scale of over 10 million tokens. This is likely why attempts at AI super-intelligence today remain slow, expensive, and frequently inaccurate.

Neocortex was built to solve all of these problems simultaneously.

Performance

Neocortex achieves performance that is orders of magnitude ahead of alternatives:

Indexing speed: 10 million tokens in under 10 seconds. Roughly 1,000x faster than other solutions. This means every single thing that happens in your digital life can be processed and made available to your agent in near real-time.

Scale: Over 1 billion tokens supported. This is the Big Data moment for AI memory. No other system operates at this scale with comparable accuracy.

Cost: $1 to index 5 million tokens. Roughly 10x cheaper than other decent AI memory solutions. Neocortex achieves this because it does not use any LLMs to manage its intelligence. The memory layer itself has zero language model dependency.

Hardware: Runs on the CPU of a MacBook Air. No GPU required. This makes Neocortex deployable anywhere, not just on expensive cloud infrastructure.

Benchmark data is open-sourced on GitHub.

Architecture: tiered memory

Neocortex uses a tiered memory architecture modeled on how the human brain manages information:

HOT tier holds the most recent and actively relevant context. This is what your agent draws on for immediate queries and real-time interactions.

WARM tier contains important information that has cooled in immediate relevance but remains readily accessible. Context from the past few days or weeks that is still useful.

COOL tier stores older context that is less immediately useful but still retrievable when the right cues appear. Think of project details from last month that you are not actively working on.

COLD tier holds the oldest and least-accessed information. Kept but heavily deprioritized. Reactivated only when specific context cues surface.

Intelligent pruning moves memories between tiers based on recency, frequency of access, and contextual relevance. Nothing is ever permanently deleted. Memories can always be reactivated.

The neuroscience of forgetting

The tiered architecture is grounded in neuroscience research.

A Carnegie Mellon University study demonstrated that intentionally forgetting some things helps us remember others by freeing up working memory resources. Memory formation depletes a limited working memory resource that recovers over time.

Further research by Ryan and Frankland, published in Nature Reviews Neuroscience (2022), established that forgetting is an active biological process with dedicated molecular machinery. Memories become inaccessible rather than erased; the engram cells persist. Environmental cues can reactivate "lost" memories.

A TIME article on the science of forgetting reinforced this: neurons have a completely separate set of mechanisms dedicated to active forgetting. Culling information is as essential for cognition as gathering it.

This validates the core design principle of Neocortex. AI systems that try to remember everything are architecturally wrong. The brain does not work that way. Neocortex compresses, forgets strategically, and builds structured representations instead.

Knowledge graph, not flat text

Neocortex does not store flat text. It builds knowledge graphs: structured representations of entities, relationships, and temporal chains.

Semantic deduplication strips redundant noise before it enters the graph. In group chats, 80%+ of messages are repetitive. Neocortex removes this automatically.

Cross-source entity resolution means that the same concept mentioned across different platforms is understood as one entity. A "Q4 deck" referenced in Slack, a Notion page, and an email thread becomes a single node in the graph, not three disconnected fragments.

Temporal context weighting applies time-decay functions so recent events carry more weight than older ones. This mirrors how human attention naturally prioritizes recency.

The result: millions of tokens of organizational noise compressed into a structured, queryable knowledge graph that any AI model can reason over in real time.

Neocortex and the subconscious

Neocortex serves as the foundation for OpenHuman's subconscious, going well beyond retrieval.

Good memory recall is the prerequisite for consciousness. Neocortex provides this by recalling memories ranked on three factors: time, interactions, and randomness. The randomness element is critical. It is what enables the subconscious system to make unexpected connections and surface emergent insights.

More on the subconscious system in The Subconscious.