Shipped: Omega 3.0 — Metacognitive AI Architecture

An independently architected, local-first AI operating system exploring persistent cognition, autonomous learning, agentic execution, and biologically inspired memory architecture.

2,565 published files | 1,971 Python files | 1,217 testing and QA files | 341 directories | Eight cognitive phases | Four coordinated execution lanes

Omega 3.0 is an open-source artificial intelligence research platform developed by Omega AI LLC.

The project began with a fundamental question:

What if an AI system could maintain its own persistent memory, learn from experience, reason about previous decisions, coordinate specialized capabilities, and continuously evolve its knowledge—without depending on an ever-growing conversation history?

That question evolved into a comprehensive metacognitive AI architecture integrating persistent memory, mathematical neuromodulation, autonomous coding agents, browser and computer control, real-time speech, multimodel inference, and a complete plugin/MCP ecosystem.

Rather than treating the language model as the entire intelligence system, Omega treated models as replaceable reasoning components within a persistent cognitive architecture.

One of Omega 3.0's foundational architectural decisions was separating long-term memory from the language model's active context.

Traditional agent systems commonly depend on accumulating conversation history, repeatedly summarizing previous interactions, or retaining cached attention state across turns.

Omega took a different approach.

Each cognitive episode could construct a bounded working context using verified memories, task state, project history, previous decisions, and retrieved evidence.

After execution, the system consolidated meaningful experiences into persistent storage, allowing subsequent episodes to reconstruct relevant context without carrying the entire conversation forward.

The model could discard its previous context. The architecture retained its memory.

This reduced architectural dependence on cross-turn KV-cache retention and growing prompts. Individual transformer inference still used normal attention and KV caching internally.

The result was an architecture designed for continuity across independent inference sessions, model changes, interrupted tasks, and system restarts.

Omega's cognitive execution cycle consisted of eight coordinated processing phases:

1. PRESSURE: Evaluates incoming stimuli, priorities, and cognitive activation.
2. GLOBAL A: Interprets intent and determines the appropriate cognitive pathway.
3. META A: Constructs execution plans, action contracts, and tool requirements.
4. AUTO: Performs model inference, autonomous execution, agent actions, and tool operations.
5. META B: Evaluates execution outcomes and prepares structured feedback.
6. GLOBAL B: Reconciles results, decisions, state, and remaining objectives.
7. OMEGA: Performs metacognitive reflection over actions, outcomes, and possible improvements.
8. DEEPSLEEP: Consolidates experiences into memory, reconciles associations, and publishes updated retrieval structures.

Four dedicated execution lanes supported conversation, coding agents, browser automation, and reflection.

Durable queues, episode ownership, cross-lane messaging, and recovery mechanisms coordinated these systems as components of one architecture rather than independent chatbots.

Omega implemented a deterministic, filesystem-backed memory architecture using 12 Dewey-organized memory lobes.

Its memory infrastructure included:

• Canonical memory records with source provenance
• Episodic working memory and SRAM
• Deterministic coordinate routing
• Associative and causal relationship graphs
• Semantic retina and sparse memory representations
• Memory strength and reinforcement mechanisms
• Verified recall with source-integrity checks
• Generation-bound retrieval projections
• Cross-session memory consolidation
• Specialized coding and development memory domains

Memory was not merely stored conversation text.

It represented experiences, relationships, decisions, outcomes, knowledge, and task-specific evidence available for future cognitive episodes.

Associated memory-organ research extended Omega's architecture using a single 17-million-parameter Ettin encoder as its complete learned memory-model component.

Retrieval was evaluated independently of a separate answer-generation LLM.

Historical internal results:

• 98.3% Any-Gold@5
• 92.8% All-Gold@5
• 99.2% All-Gold@28
• 24/24 byte-identical stratified replays

These measurements evaluated whether the memory architecture retrieved annotated supporting evidence—not whether a language model generated the correct final answer.

A separately authored, 500-question memory-only evaluation reported:

• 93.5% evidence recall
• 100% performance on six of ten measured abilities
• Abstention improvement from 20% to 60%
• 100% refusal precision in the reported epistemic-gate evaluation

A second 500-question evaluation tested challenging memory scenarios involving branch merges, corrupted records, false testimony, validity intervals, and identity continuity.

Reported results included:

• 86.8% evidence recall
• 88.8% abstention performance
• 2.5% misleading-evidence endorsement, reduced from 15%
• At least 97% on five challenging memory-ability categories

Earlier answer-generation evaluations using frozen retrieved evidence reported:

• 86.4% accuracy (432/500) with Mistral Large
• 78.0% best result using a local 4B model
• 76.7% three-trial mean with Gemma 4B
• A local-model progression of 51.8% → 69.2% → 78.0%

These historical evaluations used the documented LongMemEval evaluation methodology and GPT-4o judge.

All results are internal research measurements. The standalone memory-organ evaluations and the final integrated Omega 3.0 mainline are distinct implementation and validation states.

Omega's Distributed Memory Engine (DME) explored hardware-accelerated associative recall using bit-packed memory representations and graph topology.

The Thought Engine implemented:

• Parallel memory-plane overlap scoring
• Graded direct and partial matching
• Strong and weak graph relationship classes
• Graph-edge hop planes
• Multi-hop associative retrieval
• Deterministic ranking and tie-breaking
• Authority-aware evidence weighting
• Verifier-gated recall

Rather than asking a language model to discover every association, DME could computationally identify relationships across stored memory structures.

Related XDNA2 NPU research implemented custom whole-array overlap kernels with quantized ONNX operations, sharded memory tiles, VitisAI execution, and profiling-based hardware-placement verification.

Recorded hardware results:

• 19.4 ms per 512-query batch on XDNA2 versus 2.6 seconds on the compared serial CPU path—approximately 134× faster
• 15.8 ms/query for a 261,952-bit memory-plane workload, compared with approximately 5.6 seconds using NumPy at the tested scale
• A separate profiled overlap configuration measured 0.015 ms/query at batch 64, compared with 3.6 ms on its CPU fallback

These figures measure specific memory-processing kernels, not complete end-to-end multi-hop recall. Direct NPU integration into the complete hop scorer remained experimental.

Omega implemented a mathematical neuromodulation system called Symphony.

It modeled functional analogues of several biological signaling mechanisms:

Dopamine: Reward-prediction error, calculated by comparing observed outcomes with learned expectations.

Serotonin: A patience and retention-related signal.

Stress: Modulated the retention response to adverse outcomes.

Plasticity: Influenced memory encoding and reinforcement.

Cognitive churn: Detected repeated unsuccessful behavior, diminishing novelty, and reward plateaus.

These signals could affect memory salience, encoding strength, retention parameters, and cognitive priorities.

The architecture also included an optional, explicitly gated reinforcement mechanism capable of strengthening or weakening previously recalled memory traces using outcome-based reward-prediction error.

The objective was not to claim that the system experienced biological emotions. It was to investigate whether useful aspects of biological learning regulation could be expressed as deterministic, testable software mechanisms.

DeepSleep was far more than a background memory-save operation.

After a cognitive episode, DeepSleep coordinated memory consolidation, canonical persistence, structural relationship reconciliation, and updated memory projections.

Its mechanisms included:

• Promoting episodic information into canonical memory
• Reconciling structural and adaptive associations
• Compiling graphs from canonical records
• Tracking supersession, contradiction, provenance, and entity relationships
• Publishing immutable, versioned retrieval generations
• Using consistency checks and publication authority to avoid mixed memory snapshots
• Maintaining recoverable memory state across interrupted operations

Omega also included an interactive memory-graph visualization within its HUD.

The visualization responded to memory events and telemetry, refreshing the displayed graph while preserving the user's view state.

This provided a visible representation of how the system's persistent memory structure changed over time as cognitive experiences were consolidated.

Execution produced experience. Experience influenced memory. DeepSleep consolidated that memory into the knowledge structures used by subsequent cognition.

Omega incorporated a full multi-turn agentic coding architecture directly into its cognitive execution system.

This was not limited to generating code snippets.

The coding agent could maintain persistent project and task identities, perform development operations, inspect results, and continue work across multiple execution episodes.

Capabilities included:

• Persistent coding jobs and task plans
• Multi-turn development and continuation
• Project-scoped memory retrieval
• Workspace file inspection and modification
• Command execution and development tooling
• Iterative implementation and testing
• Source and execution evidence tracking
• Durable cross-lane handoffs
• Project-context rehydration
• Verification-driven completion

An important architectural feature was run-scoped project memory.

Previously recorded engineering decisions, development evidence, and relevant project history could be retrieved from canonical memory and verified against the active coding run before being supplied to the model.

This allowed coding workflows to retain project awareness without continuously carrying their entire historical conversation inside an LLM context window.

The system also distinguished actual tool evidence from model-generated claims of completion.

A coding model declaring that something was finished did not automatically establish that files had changed or tests had passed.

Omega incorporated autonomous browser control through Chrome DevTools Protocol integrations and a dedicated browser execution lane.

Implemented browser capabilities included:

• Navigation and tab management
• Page observation and screenshots
• Pointer movement, clicking, dragging, and scrolling
• Text entry and keyboard actions
• Structured page and document extraction
• Multi-step tool sequences
• Full-page observation and scanning
• OCR-assisted perception
• Action verification and execution budgets

Browser research could participate in broader multi-turn workflows through durable, coordinated handoffs.

For example, a research task could gather evidence, transfer relevant findings to a coding workflow, and preserve that context for subsequent implementation and verification.

Omega also explored natural, hands-free interaction through a local speech architecture.

Its voice infrastructure included speech recognition, streaming text-to-speech, continuous conversation handling, voice-activity detection, interruption handling, and proactive interaction.

The system could begin speaking as response text arrived rather than waiting for an entire answer to finish generating.

A proactive lifecycle tracked autonomous questions, delivered results, and subsequent conversational outcomes.

The objective was to make interaction with a complex computing system conversational while maintaining structured execution and operator control.

Omega incorporated a substantial integration architecture supporting external tools and services.

Its plugin/MCP infrastructure included:

• MCP client and tool integration
• Signed plugin/package verification
• Granular execution permissions
• OAuth authorization and credential custody
• Isolated plugin workers
• Lifecycle and dependency management
• Execution approval boundaries
• Persistent operation records
• Error attribution and recovery mechanisms

These subsystems allowed specialized capabilities to participate in a shared cognitive framework without automatically granting unrestricted access to external systems.

Omega 3.0 was independently architected and developed with extensive assistance from a broad ecosystem of AI development tools and platforms.

Tools used during its evolution included Claude, OpenAI Codex, GitHub Copilot, Kimi, Google Antigravity, Mistral AI, OpenCode, OpenRouter, Microsoft Azure, NanoAgent, and others.

AI-assisted coding, architectural planning, debugging, review, testing, and implementation were coordinated throughout development.

The project required substantial work across Python, JavaScript, model runtimes, cognitive architecture, persistent storage, concurrency, local inference, Windows/Linux environments, CPU/GPU/NPU execution, browser automation, and software integration.

Omega 3.0 was an ambitious attempt to build an entire AI computing environment around a persistent cognitive architecture.

As the project evolved, each new subsystem increased the engineering burden: memory, reasoning, tools, browser control, multimodel inference, voice, security, orchestration, plugins, and platform integration all had to continue functioning as one coordinated system.

During the rapid evolution of the agentic AI ecosystem, maintaining and advancing that entire architecture became unsustainable for a single engineer.

Rather than continue adding complexity, I chose to retire Omega 3.0 as an active product and preserve its technical work for public inspection.

Its successor research project, Odin, returns to the original objective.

Instead of recreating an entire computing platform, Odin focuses on building a single intelligence architecture capable of persistent learning, associative reasoning, and the development of new knowledge from experience.

Omega 3.0 represents the engineering exploration that helped establish that direction.

Omega 3.0 was engineered as a genuinely portable, local-first AI operating environment rather than an application permanently tied to one computer or installation.

Working extensively with Claude, I completed its cross-platform portability architecture for a broad range of Windows and Linux environments.

The system incorporated:

• Dedicated Windows (Omega.exe) and Linux (Omega-Linux) launchers
• Self-contained, platform-specific Python runtimes and dependency environments
• Relocatable, product-relative filesystem and runtime paths
• Portable model, configuration, and persistent-memory infrastructure
• Environment-aware process and service management
• CPU/GPU execution support and hardware-specific acceleration paths
• SSD-based deployment designed to move between compatible machines without reconstructing the entire application environment

The objective was to allow the cognitive architecture, its persistent memory, agent infrastructure, and execution environment to travel together instead of depending on a specific host machine.

Optional hardware acceleration remained dependent on compatible devices and drivers.

Omega 3.0 demonstrated that a complex, persistent AI operating environment could be engineered for genuine cross-platform portability—not merely packaged as a Windows-only AI application.

The public GitHub release preserves the architecture as a source-only research archive; large model weights, compiled runtimes, and deployment binaries are intentionally excluded.

---

Omega 3.0 is now publicly available as a source-only research archive.

The repository includes implementation code, system contracts, research documentation, architectural explanations, and extensive testing infrastructure. It is not presented as a turnkey production installation or a demonstration of achieved artificial general intelligence.

Historical research results are reported with their original evaluation scope and limitations.

Public source code: github.com/leeno7786-coder/omega3-research-archive

Architecture, benchmarks, and visual evidence: omega2ai.com/omega-3/

Omega AI LLC — Independent AI Systems Research & Engineering