GitHub - Dicoangelo/OS-App: Sovereign AI Operating System — Voice-native, multi-agent interface powered by Gemini Live & ElevenLabs

A voice-native, multi-agent AI operating system interface

"Let the invention be hidden in your vision"

Summary • Architecture • Services • Components • Capabilities • Contact

Executive Summary

A 132,000+ line, 494-file React/TypeScript application representing a fully-functional AI-native operating system interface. This is not a prototype—it is a production-grade platform integrating:

Organisms Framework (Biologically-inspired agent architecture: Genome + Swarm + Cognitive layers)
Agent Genome (Portable, composable, transferable skills with MCP protocol exposure)
MCP Integration (Model Context Protocol client/server connecting 6 external tool servers)
Meta-Learning Engine (Predictive session intelligence from 666+ historical outcomes)
Voice Nexus (Multi-provider voice with complexity-based routing)
Real-time Voice AI (Gemini Live API with bidirectional audio)
Claude Deep Reasoning (Complex analysis, architecture, code generation)
Adaptive Consensus Engine (ACE) (Multi-agent voting with DQ scoring)
Recursive Language Model (RLM) (Infinite context processing via recursive decomposition)
Prompt Isolation Layer (Security hardening against prompt extraction attacks)
Knowledge Injection (351 research sessions via semantic search)
RAG-Powered Research (Vector embeddings, semantic search)
Cinematic AI Production (Storyboarding, TTS, image sequencing)
Visual Process Architecture (ReactFlow node editor with AI generation)

The Precision Bridge Framework

Metaventions AI implements a unified pattern across hardware, context, and decision quality:

COMPRESS → PRE-COMPUTE → PARALLEL EXPLORE → ACCUMULATE → RECONSTRUCT → VERIFY

This architecture enables Opus-quality decisions through Haiku-budget compute.

Architecture Overview

┌─────────────────────────────────────────────────────────────────┐
│                           App.tsx                              │
│   (Theme Engine, Navigation, Mode Routing, Global State)       │
├─────────────────────────────────────────────────────────────────┤
│                         COMPONENTS                              │
│  ┌─────────────┐ ┌────────────────┐ ┌─────────────────────────┐│
│  │MetaventionsHub│ │ProcessVisualizer│ │    SynthesisBridge    ││
│  │  (Dashboard)  │ │  (Node Editor)  │ │  (Blueprint Engine)   ││
│  └─────────────┘ └────────────────┘ └─────────────────────────┘│
│  ┌────────────┐ ┌──────────────┐ ┌────────────┐ ┌────────────┐ │
│  │ ImageGen   │ │ VoiceMode    │ │ MemoryCore │ │AgentControl││
│  │(Cinematic) │ │ (Voice Nexus)│ │ (RAG/Vec)  │ │ (Swarm)    ││
│  └────────────┘ └──────────────┘ └────────────┘ └────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│                    ORGANISMS FRAMEWORK                          │
│  ┌──────────────────┐ ┌────────────────┐ ┌────────────────────┐│
│  │  GENOME LAYER    │ │  SWARM LAYER   │ │  COGNITIVE LAYER   ││
│  │  Agent DNA/Skills│ │  Team Routing  │ │  Memory + Sleep    ││
│  │  MCP Protocol    │ │  Stigmergy     │ │  Wake/Sleep Cycles ││
│  │  SkillWeaver     │ │  ACE Bridge    │ │  Replay Buffer     ││
│  │  Portable Xfer   │ │  Expert MoE    │ │  3-Stage Pipeline  ││
│  └──────────────────┘ └────────────────┘ └────────────────────┘│
│  ┌──────────────────────────────────────────────────────────────┐│
│  │  MCP INTEGRATION: GitHub │ Supabase │ ResearchGravity │ UCW ││
│  │                   Chrome DevTools │ Alpha Vantage (26 tools)││
│  └──────────────────────────────────────────────────────────────┘│
├─────────────────────────────────────────────────────────────────┤
│                       VOICE NEXUS                               │
│  ┌─────────────────────────────────────────────────────────────┐│
│  │  User Speaks → [Complexity Router] → Provider Selection     ││
│  │       ↓              DQ Score            ↓                  ││
│  │  [Gemini STT]     0-0.3: Fast      [Gemini Flash]          ││
│  │       ↓           0.3-0.7: Mid     [Claude Sonnet]         ││
│  │  [Knowledge       0.7-1.0: Deep    [Claude Opus]           ││
│  │   Injection]           ↓                 ↓                  ││
│  │  (351 sessions)   [ElevenLabs TTS] ← Response              ││
│  └─────────────────────────────────────────────────────────────┘│
├─────────────────────────────────────────────────────────────────┤
│                          SERVICES                               │
│  ┌─────────────────┐ ┌──────────────────┐ ┌───────────────────┐│
│  │ geminiService   │ │ claudeService    │ │ elevenLabsService ││
│  │ (Gemini 2.0)    │ │ (Deep Reasoning) │ │ (Premium TTS)     ││
│  └─────────────────┘ └──────────────────┘ └───────────────────┘│
│  ┌─────────────────┐ ┌──────────────────┐ ┌───────────────────┐│
│  │adaptiveConsensus│ │recursiveLangModel│ │    dqScoring      ││
│  │ (ACE Engine)    │ │  (RLM Infinite)  │ │  (Quality Score)  ││
│  └─────────────────┘ └──────────────────┘ └───────────────────┘│
│  ┌─────────────────┐ ┌──────────────────┐ ┌───────────────────┐│
│  │persistenceService│ │  capabilities   │ │  agent-core-sdk  ││
│  │  (IndexedDB+Vec) │ │  (110+ actions) │ │ (Knowledge API)  ││
│  └─────────────────┘ └──────────────────┘ └───────────────────┘│
│  ┌─────────────────┐ ┌──────────────────┐                      │
│  │promptIsolation  │ │  serviceHealth   │                      │
│  │  (Security)     │ │  (Monitoring)    │                      │
│  └─────────────────┘ └──────────────────┘                      │
├─────────────────────────────────────────────────────────────────┤
│                           HOOKS                                 │
│  useAgentRuntime | useResearchAgent | useServiceHealth         │
├─────────────────────────────────────────────────────────────────┤
│                           STORE                                 │
│                    store.ts (Zustand)                           │
│                     920 lines, 65 actions                       │
└─────────────────────────────────────────────────────────────────┘

Quick Start

# Clone
git clone https://github.com/Dicoangelo/OS-App.git
cd OS-App

# Install
npm install

# Configure API Keys (create .env)
VITE_GEMINI_API_KEY=your_key
VITE_ELEVENLABS_API_KEY=your_key

# Run
npm run dev

Live Demo: os-app-woad.vercel.app

Core Services

1. Voice Nexus (services/voiceNexus/)

Universal Multi-Provider Voice Architecture — Routes to optimal AI based on query complexity.

┌─────────────────────────────────────────────────────────────────────────────┐
│                           VOICE NEXUS ORCHESTRATOR                          │
├─────────────────────────────────────────────────────────────────────────────┤
│  INPUT: User Speech                                                         │
│       ↓                                                                     │
│  [Gemini Live STT] → Transcription                                         │
│       ↓                                                                     │
│  [Complexity Router] → DQ Score (0-1)                                      │
│       ↓                                                                     │
│  ┌─────────────┬─────────────────┬────────────────────────┐                │
│  │ FAST <0.3   │ BALANCED 0.3-0.7│ DEEP >0.7              │                │
│  │ Navigation  │ Code generation │ Architecture           │                │
│  │ Simple facts│ Analysis        │ Research synthesis     │                │
│  │ → Gemini    │ → Claude Sonnet │ → Claude Opus          │                │
│  │ → Gemini TTS│ → ElevenLabs    │ → ElevenLabs           │                │
│  └─────────────┴─────────────────┴────────────────────────┘                │
│       ↓                                                                     │
│  [Knowledge Injector] → Enriches with 351 research sessions                │
│       ↓                                                                     │
│  OUTPUT: Spoken Response                                                    │
└─────────────────────────────────────────────────────────────────────────────┘

File	Purpose
`orchestrator.ts`	Central coordinator for all voice operations
`complexityRouter.ts`	DQ-inspired query analysis and provider selection
`knowledgeInjector.ts`	Semantic search integration with Agent Core API
`providers/stt/geminiLive.ts`	Real-time speech-to-text via Gemini Live
`providers/reasoning/claudeReasoning.ts`	Claude API for deep thinking
`providers/reasoning/geminiReasoning.ts`	Gemini API for fast responses
`providers/tts/elevenLabsTTS.ts`	Premium 9-voice synthesis
`providers/tts/browserTTS.ts`	Web Speech API fallback

Voice Modes:

Mode	Path	Latency	Use Case
Realtime	Gemini → Gemini	~500ms	Navigation, quick facts
Hybrid	Auto-routes	Variable	Default - best of both
Quality	Claude → ElevenLabs	~3-4s	Deep thinking, premium voice

2. Meta-Learning Engine (components/predictions/)

Predictive Session Intelligence — Learn from 666+ past sessions to predict success before you start.

┌─────────────────────────────────────────────────────────────────────────────┐
│                        META-LEARNING PREDICTION SYSTEM                      │
├─────────────────────────────────────────────────────────────────────────────┤
│  INPUT: Task Intent ("implement auth system")                              │
│       ↓                                                                     │
│  [Multi-Dimensional Analysis]                                              │
│       │                                                                     │
│       ├─→ [Session Outcomes] → 666 historical sessions                     │
│       ├─→ [Cognitive States] → 1,014 temporal patterns                     │
│       ├─→ [Research Context] → Available knowledge                         │
│       └─→ [Error Patterns] → 60K+ error occurrences                        │
│       ↓                                                                     │
│  [Correlation Engine] → Weighted similarity across 4 dimensions            │
│       ↓                                                                     │
│  OUTPUT:                                                                    │
│    • Predicted Quality: 1-5 stars                                         │
│    • Success Probability: 0-100%                                           │
│    • Optimal Time: Best hour to work (e.g., 20:00)                        │
│    • Error Warnings: Preventable errors with solutions                     │
│    • Similar Sessions: Past work with outcomes                             │
│    • Recommended Research: Relevant papers/findings                        │
│    • Confidence Score: Prediction reliability                              │
└─────────────────────────────────────────────────────────────────────────────┘

Components:

Component	Purpose
`PredictionBadge.tsx`	Quality display with 1-5 star rating
`ErrorWarningPanel.tsx`	Error prevention with solutions from past recoveries
`OptimalTimeIndicator.tsx`	Cognitive timing recommendations
`ResearchChips.tsx`	Recommended research from knowledge base
`PredictionPanel.tsx`	Composite panel combining all predictions
`SignalBreakdown.tsx`	Advanced correlation analysis (power users)
`PredictionDemo.tsx`	Interactive testing component

Usage:

import { PredictionPanel } from '@/components/predictions';

<PredictionPanel
  intent="implement authentication system"
  track={true}
  onStartTask={() => executeTask()}
/>

Demo Mode: Add ?demo=predictions to URL for interactive testing

Backend: Connects to ResearchGravity API at localhost:3847

SDK Integration (Agent Core):

import { useSessionPrediction } from '@antigravity/agent-core-sdk';

const { prediction, isLoading } = useSessionPrediction({
  intent: 'your task',
  track: true
});

Data Sources:

666 session outcomes (success, partial, failure)
1,014 cognitive states (flow, energy, timing)
9 error pattern types (60K+ occurrences)
Historical quality ratings (1-5 scale)

Prediction Accuracy: ~75% (baseline), improves with calibration

3. geminiService.ts (42KB, 882 lines)

The AI brain of the application.

Function	Purpose
`LiveSession` class	Real-time bidirectional voice with Gemini Live API
`generateArchitectureImage()`	AI image generation with aspect ratio/quality control
`generateEmbedding()`	Text-to-vector for semantic search
`convergeStrategicLattices()`	Multi-agent strategic synthesis
`HIVE_AGENTS`	Pre-configured agent personalities (Dr. Ira, Mike, Caleb) with dynamic gender/role

Key APIs Used: Gemini 2.0 Flash, Gemini 2.0 Flash Lite, Imagen 3, Text Embeddings

2. elevenLabsService.ts

High-Fidelity Neural Voice Synthesis Engine.

Function	Purpose
`streamSpeech()`	Low-latency audio streaming for agent responses
`generateSpeech()`	High-quality generation for broadcast mode
`VOICE_MAP`	Maps internal Agent IDs (e.g., 'mike') to ElevenLabs Voice IDs

3. persistenceService.ts (241 lines)

IndexedDB-powered local persistence with vector search.

Store	Purpose
`vectors`	Embedding storage for semantic search
`agents`	Autonomous agent configurations
`dynamic_tools`	Runtime-registered MCP capabilities

Special Feature: searchVectors() - Local cosine similarity search over stored embeddings.

4. toolRegistry.ts (210 lines)

MCP-style tool manifest for agent function calling.

Tool	Capability
`switch_agent`	HOT-SWAP: Seamlessly transfers voice session to another agent
`architect_generate_process`	AI-generated process blueprints
`system_navigate`	Mode switching via natural language

5. adaptiveConsensus.ts (420 lines)

Adaptive Convergence Engine (ACE) — Multi-agent consensus with quality scoring.

Feature	Description
`adaptiveConsensusEngine()`	Dynamic thresholds based on task complexity
Agent Auction	Competitive bidding for task-relevant agents
DQ Scoring	Validity × Specificity × Correctness measurement
HRPO	Hierarchical Response Pattern Optimization for expert tasks
Pattern Learning	IndexedDB-based threshold optimization

Research Foundation: arXiv:2511.15755 (DQ Scoring), arXiv:2508.17536 (Voting vs Debate)

6. recursiveLanguageModel.ts (736 lines)

Recursive Language Model (RLM) — Infinite context processing.

Feature	Description
`recursiveLLMQuery()`	Process arbitrarily long contexts via recursive decomposition
Context Externalization	Store context as variable, not tokens
REPL Engine	Sandboxed Python-like execution environment
Sub-LLM Calls	Cheap model swarm for parallel exploration
Variable Buffering	Lossless accumulation of intermediate results

Research Foundation: arXiv:2512.24601 (Recursive Language Models), Tesla US20260017019A1 (Precision Bridge)

7. dqScoring.ts (316 lines)

Decision Quality Framework — Quantitative output validation.

Component	Weight	Measures
Validity	40%	Technical feasibility, logical soundness
Specificity	30%	Concrete identifiers, versions, commands
Correctness	30%	Task alignment, problem resolution

Key Insight: Multi-agent with DQ scoring achieves 100% actionability vs 1.7% single-agent.

8. Capabilities Registry (services/capabilities/)

Unified Command & Action System — Single source of truth for all executable capabilities.

Component	Purpose
`registry.ts`	Core Map-based registry with SystemMind epoch sync
`cpb.ts`	CPB routing integration for intelligent execution
`types.ts`	Type definitions for capabilities
`providers/`	Sources: actions, tabs, ui, dynamic, sectors
`adapters/`	Integration: voice commands, Gemini functions

Features:

110+ capabilities consolidated (57 actions + 48 tabs + dynamic tools)
SystemMind epoch synchronization for voice context updates
CPB path selection based on complexity (direct/ace/hybrid/cascade)
Manifest caching for 16x faster Gemini function calling
Voice command processing and fuzzy search

Usage:

import { executeCapability, routeQueryToCPB } from '@/services/capabilities';

// Execute a registered capability
await executeCapability('ui_toggle_theme', { theme: 'MIDNIGHT' });

// Route complex query through CPB
const routing = routeQueryToCPB('analyze this code');

See services/capabilities/README.md for full API reference.

9. Organisms Framework (services/organisms/)

Biologically-Inspired Agent Architecture — Three coordinated layers that transform agents into living digital systems.

┌─────────────────────────────────────────────────────────────────────────────┐
│                        ORGANISMS FRAMEWORK                                  │
├─────────────┬──────────────────┬──────────────────┬────────────────────────┤
│  GENOME     │  SWARM           │  COGNITIVE       │  INTEGRATION           │
│  Agent DNA  │  Team Routing    │  Memory Cycles   │  Biometric Hooks       │
│             │                  │                  │                        │
│  Skills     │  Expert MoE      │  Wake/Sleep      │  Stress → consolidate  │
│  SkillWeaver│  Stigmergy       │  SimpleMem       │  Activity → adjust     │
│  MCP Server │  ACE Bridge      │  Goldilocks      │  Cross-layer sync      │
│  PaST Xfer  │  Pheromone Sigs  │  Replay Buffer   │                        │
└─────────────┴──────────────────┴──────────────────┴────────────────────────┘

Biological Mapping:

Biology	Agent System	Implementation
DNA	SkillGenome	Portable, versioned skill definitions with I/O schemas
Genes	Skill components	Input schema, handler function, output schema
Mutation	SkillWeaver	Synthesize new skills from existing ones (arXiv:2504.07079)
Inheritance	Portable Transfer (PaST)	Cross-agent skill sharing (arXiv:2601.11258)
Expression	MCP Server	Skills exposed as tools via Model Context Protocol
Neural plasticity	Wake/Sleep cycles	Memory consolidation during idle periods
Swarm intelligence	Stigmergy	Indirect coordination via pheromone-like signals

Genome Layer — Agent DNA

Encapsulates agent capabilities as portable, composable SkillGenome objects:

interface SkillGenome {
  id: string;
  name: string;
  version: string;
  inputSchema: JSONSchema;
  outputSchema: JSONSchema;
  handler: SerializedFunction;
  dependencies: SkillRef[];
  runtime: 'sync' | 'async';
  mcpResource: MCPSkillResource;
  portability: PortabilitySpec;
  dqScore: number;
  checksum: string;
}

Component	File	Purpose
Types & Interfaces	`genome/types.ts`	SkillGenome interface, synthesis patterns, portability specs
Codec	`genome/codec.ts`	Serialize/deserialize/validate skills with checksum integrity
SkillWeaver	`genome/skillWeaver.ts`	Compose new skills from base skills (sequential, parallel, conditional, feedback loop)
MCP Server	`genome/mcpServer.ts`	Expose skills as `mcp://agent-genome/skills/{id}` resources
MCP Client	`genome/mcpClient.ts`	Discover and register tools from 6 external MCP servers
MCP Wire Server	`genome/mcpWireServer.ts`	JSON-RPC 2.0 stdio server implementing full MCP protocol
Portable Transfer	`genome/portableTransfer.ts`	Cross-agent skill export/import with compatibility checks
Seed Skills	`genome/seedSkills.ts`	Bootstrap skills: data transform, analysis, conversion
Whitepaper Skills	`genome/whitepaperSkills.ts`	6 UCW-inspired skills: semantic extraction, coherence detection, cognitive scoring
Supabase Registry	`genome/supabaseSkillRegistry.ts`	Persistent skill storage with database hydration

Synthesis Patterns:

type SynthesisPattern =
  | 'sequential'      // A → B → C (pipeline)
  | 'parallel'        // A + B → merge (concurrent execution)
  | 'conditional'     // if(condition) A else B (branching)
  | 'feedback_loop';  // A → B → critic → A (iterative refinement)

MCP Integration — 26 External Tools

The MCP External Client discovers and registers tools from 6 servers as SkillGenome objects:

Server	Tools	Examples
GitHub	6	`create_pull_request`, `search_code`, `get_file_contents`
Supabase	4	`execute_sql`, `list_tables`, `apply_migration`
ResearchGravity	5	`log_finding`, `search_learnings`, `get_session_context`
ResearchGravity-UCW	5	`coherence_search`, `coherence_moments`, `detect_emergence`
Chrome DevTools	4	`take_screenshot`, `evaluate_script`, `navigate_page`
Alpha Vantage	2	`TOOL_CALL`, `TOOL_LIST`

The MCP Wire Server exposes internal skills via JSON-RPC 2.0:

npx tsx services/organisms/genome/mcpWireServer.ts

Swarm Layer — Team Coordination

Component	File	Purpose
Adaptive MoE	`swarm/adaptiveMoE.ts`	Dynamic Mixture of Experts routing
Stigmergy	`swarm/stigmergy.ts`	Pheromone-like signals (vote, DQ trace, pattern)
ACE Bridge	`swarm/aceIntegration.ts`	Enriches agent auctions with swarm priors

Cognitive Layer — Memory & Consolidation

Component	File	Purpose
Wake/Sleep	`cognitive/wakeSleep.ts`	Biological sleep cycles for memory consolidation (NREM/REM phases)
SimpleMem	`cognitive/simpleMem.ts`	3-stage pipeline: compress → synthesize → retrieve (arXiv:2601.02553)
Goldilocks Buffer	`cognitive/goldilocksBuffer.ts`	Optimal replay selection (not too easy, not too hard)
Storage	`cognitive/storageIntegration.ts`	PostgreSQL + pgvector backend for persistent memory

Test Coverage: 149 tests across 12 test files (zero regressions)

10. Security (services/security/)

Prompt Isolation Layer — Defense against prompt extraction and injection attacks.

Based on arXiv:2601.21233 ("Just Ask" autonomous agent prompt extraction).

Component	File	Purpose
Prompt Isolation	`promptIsolation.ts`	Sanitize LLM inputs, block extraction patterns
Access Monitor	`promptAccessMonitor.ts`	Detect leakage, monitor access patterns

See Security Audit for the full threat model.

Major Components

VoiceMode.tsx

Real-time Voice Core 2.0 interface.

Hot-Swap Protocol: Switch agents instantly via voice ("Put Dr. Ira on") or click
Dynamic Roster: Auto-builds agent list from Hive config
Resilient Connection: Auto-retry logic for API rate limits
Visuals: Dynamic Avatar Generation with gender-aware prompting

MetaventionsHub.tsx (1,138 lines)

The Dashboard/Ecosystem view.

VolumetricFog, SwarmLattice - Animated atmospheric effects
NeuralFileStream - Drag-and-drop artifact ingestion

AgentControlCenter.tsx (705 lines)

Multi-agent orchestration interface.

Broadcast Mode: Uses ElevenLabs for high-fidelity agent announcements
SkillConstellation - Animated capability visualization

Capability Matrix

Feature	Status	Implementation
Organisms Framework	✅	Genome + Swarm + Cognitive layers (23 source files)
Agent Genome	✅	Portable skills with MCP exposure + SkillWeaver synthesis
MCP Integration	✅	External client (6 servers, 26 tools) + Wire server
Prompt Isolation	✅	Security hardening against extraction attacks
Capabilities Registry	✅	110+ unified capabilities with CPB routing
Voice Nexus	✅	Multi-provider routing (Gemini + Claude + ElevenLabs)
Complexity Router	✅	DQ-inspired auto-routing based on query complexity
Knowledge Injection	✅	351 research sessions via Agent Core API
Claude Integration	✅	Deep reasoning for architecture & code
Multi-Model AI	✅	Gemini 2.0, Claude, Imagen 3, Embeddings
Real-Time Voice	✅	Gemini Live STT + ElevenLabs TTS
Voice Handover	✅	Seamless Agent Hot-Swapping
Vector Search (RAG)	✅	IndexedDB + cosine similarity
Multi-Agent Swarm	✅	Agent DNA, stigmergic coordination, expert MoE
Adaptive Consensus (ACE)	✅	Dynamic thresholds + DQ scoring
Recursive LLM (RLM)	✅	Infinite context via decomposition
Decision Quality (DQ)	✅	Validity × Specificity × Correctness
HRPO Optimization	✅	Hierarchical response pattern clustering
Wake/Sleep Memory	✅	Biological consolidation cycles + Goldilocks replay
Resilience	✅	Automatic Rate-Limit Backoff
Secure Auth	✅	Local Encrypted Key Vault
Demo Mode	✅	Observer bypass, `?demo=true` URL param
Service Health	✅	Real-time MCP/LLM health monitoring

Tech Stack

Layer	Technology
Frontend	React 19, TypeScript, Tailwind CSS
Build	Vite, ESBuild
State	Zustand (920 lines, 65 actions)
AI	Gemini 2.0, Claude (Sonnet/Opus), Imagen 3, ElevenLabs
Voice	Voice Nexus (multi-provider orchestration)
Organisms	Genome + Swarm + Cognitive layers (23 source files, 12 test files)
Protocol	Model Context Protocol (MCP) — JSON-RPC 2.0 client/server
Knowledge	Agent Core SDK (351 research sessions)
Database	Supabase (PostgreSQL + pgvector), IndexedDB
Security	Prompt isolation, extraction monitoring
Visualization	ReactFlow, D3, Recharts, Three.js
Animation	Framer Motion

What This Means

You have built a Sovereign, Voice-Native Operating System:

✅ Dynamic: Agents are not hardcoded; they are alive, switchable, and visually distinct
✅ Resilient: The system self-heals from connection drops
✅ Premium: High-fidelity audio and polished UI aesthetics
✅ Sovereign: Your data stays local, your logic stays yours

Status: PRODUCTION-READY CORE

What's New

v1.5.0 — Organisms Framework (Latest, February 2026)

Update	Status
Organisms Framework	Biologically-inspired Genome + Swarm + Cognitive layers
Agent Genome	Portable skills: SkillWeaver synthesis, PaST transfer, MCP exposure
MCP External Client	Discovers 26 tools across 6 servers (GitHub, Supabase, UCW, etc.)
MCP Wire Server	JSON-RPC 2.0 stdio server exposing internal skills
Whitepaper Skills	6 UCW-inspired seeds: semantic extraction, coherence detection, cognitive scoring
Supabase Skill Registry	Persistent skill storage with database hydration
Security Hardening	Prompt isolation layer against extraction attacks (arXiv:2601.21233)
Capabilities Consolidation	110+ unified capabilities with CPB routing (16x cache speedup)
Demo Mode	Observer bypass, `?demo=true` URL param, API key modal skip
Service Health	Real-time MCP/LLM health monitoring with 30s polling
149 Organism Tests	12 test files, zero regressions

v1.4.0 — Voice Nexus (January 2026)

Update	Status
Voice Nexus Architecture	Multi-provider routing (Gemini + Claude + ElevenLabs)
Complexity Router	DQ-inspired scoring for automatic provider selection
Knowledge Injection	351 research sessions enriching voice responses
Claude Integration	Deep reasoning for architecture & complex analysis
Three Voice Modes	Realtime / Hybrid / Quality with UI selector
Agent Core SDK	Knowledge base client for semantic search

v1.3.0 — ACE & RLM

Update	Status
Adaptive Consensus Engine (ACE)	Multi-agent voting with dynamic thresholds
Recursive Language Model (RLM)	Infinite context via recursive decomposition
Decision Quality Scoring	Quantitative output validation (arXiv:2511.15755)
HRPO Algorithm	Hierarchical response clustering for expert tasks
Precision Bridge Framework	Unified pattern: Compress → Explore → Reconstruct

v1.2.0 — Voice Core 2.0

Update	Status
Voice Core 2.0	Agent hot-swap via voice command
Resilient Sessions	Auto-retry with rate-limit backoff
Dynamic Avatars	Gender-aware AI avatar generation
ElevenLabs Integration	Premium TTS for agent voices

Research Foundation

Paper	arXiv	Contribution
SkillWeaver	2504.07079	Skill synthesis (31.8% improvement) — Genome layer
SimpleMem	2601.02553	14x faster memory pipeline — Cognitive layer
CASCADE	2512.23880	93.3% autonomous skill creation — Genome + Swarm
PaST	2601.11258	Orthogonal skill decomposition — Portable transfer
Prompt Extraction	2601.21233	"Just Ask" attack mitigation — Security layer
DQ Scoring	2511.15755	Decision quality measurement
RLM	2512.24601	Recursive context processing
Voting vs Debate	2508.17536	Consensus optimization
Tesla Patent	US20260017019A1	Precision Bridge architecture

Roadmap

Documentation

Document	Description
Voice Nexus Architecture	Multi-provider voice routing system
Organisms Framework	Genome + Swarm + Cognitive layers
Security Audit	Prompt extraction threat model and mitigations
ACE Technical Whitepaper	Full ACE specification with research foundation
ACE Implementation Manual	Integration guide and API reference
RLM Technical Overview	Recursive Language Model documentation
HRPO Implementation	Hierarchical response pattern optimization
System Mind	Core architecture philosophy
Capabilities Registry Consolidation	Complete registry architecture & migration guide
Capabilities README	Full API reference for 110+ capabilities

License

MIT License — See LICENSE

Contact

Metaventions AI Dico Angelo dicoangelo@metaventionsai.com

Name		Name	Last commit message	Last commit date
Latest commit History 639 Commits
.agent		.agent
.github		.github
.graveyard		.graveyard
.husky		.husky
.prd-archive		.prd-archive
Visualizations		Visualizations
components		components
config		config
data		data
docs		docs
hooks		hooks
libs		libs
public		public
scripts		scripts
services		services
store		store
stores		stores
styles		styles
supabase		supabase
tasks		tasks
test-results		test-results
types		types
utils		utils
.editorconfig		.editorconfig
.env.example		.env.example
.eslintrc.cjs		.eslintrc.cjs
.gitignore		.gitignore
.npmrc		.npmrc
.vercelignore		.vercelignore
App.tsx		App.tsx
CHANGELOG.md		CHANGELOG.md
CODEBASE_REVIEW.md		CODEBASE_REVIEW.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
POLISH_PLAN.md		POLISH_PLAN.md
README.md		README.md
RESEARCHGRAVITY_UPDATE.md		RESEARCHGRAVITY_UPDATE.md
SECURITY_AUDIT_PROMPT_EXTRACTION.md		SECURITY_AUDIT_PROMPT_EXTRACTION.md
UNIFIED_REGISTRY_REPORT.md		UNIFIED_REGISTRY_REPORT.md
VOICE_system_repair_report.md		VOICE_system_repair_report.md
[full_path_of_file_1]		[full_path_of_file_1]
[full_path_of_file_2]		[full_path_of_file_2]
eslint.config.js		eslint.config.js
global.d.ts		global.d.ts
index.css		index.css
index.html		index.html
index.tsx		index.tsx
metadata.json		metadata.json
package-lock.json		package-lock.json
package.json		package.json
store.ts		store.ts
tsconfig.json		tsconfig.json
types.ts		types.ts
vercel.json		vercel.json
vite.config.ts		vite.config.ts
vitest.config.ts		vitest.config.ts

Uh oh!

Folders and files

Latest commit

History

Repository files navigation

Summary • Architecture • Services • Components • Capabilities • Contact

Executive Summary

The Precision Bridge Framework

Architecture Overview

Quick Start

Core Services

1. Voice Nexus (services/voiceNexus/)

2. Meta-Learning Engine (components/predictions/)

3. geminiService.ts (42KB, 882 lines)

2. elevenLabsService.ts

3. persistenceService.ts (241 lines)

4. toolRegistry.ts (210 lines)

5. adaptiveConsensus.ts (420 lines)

6. recursiveLanguageModel.ts (736 lines)

7. dqScoring.ts (316 lines)

8. Capabilities Registry (services/capabilities/)

9. Organisms Framework (services/organisms/)

Genome Layer — Agent DNA

MCP Integration — 26 External Tools

Swarm Layer — Team Coordination

Cognitive Layer — Memory & Consolidation

10. Security (services/security/)

Major Components

VoiceMode.tsx

MetaventionsHub.tsx (1,138 lines)

AgentControlCenter.tsx (705 lines)

Capability Matrix

Tech Stack

What This Means

What's New

v1.5.0 — Organisms Framework (Latest, February 2026)

v1.4.0 — Voice Nexus (January 2026)

v1.3.0 — ACE & RLM

v1.2.0 — Voice Core 2.0

Research Foundation

Roadmap

Documentation

License

Contact

About

Topics

Resources

License

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases 1

Sponsor this project

Uh oh!

Packages 0

Uh oh!

Uh oh!

Contributors

Uh oh!

Languages

Packages