ITSNOTAILABS

This AI security zeroes in on advanced, agent-based systems, with a strong focus on verifiable sovereignty. The package, created for researchers, security architects, and developers of persistent AI, is fully open, downloadable, and reproducible. doi.org/10.5281/zenodo… (Latin subtitle: *De Clavibus Quantum-Inspiratis, Filiis Umbrarum, Testimoniis Computationis, et Memoria Sovereigna*) Public DOI delivers in-depth research and a working demo, not just theory. It’s all about protecting the internal cognition of persistent, multi-part AI systems like NEUROSWARM and MAESI, going beyond standard data-at-rest or in-transit encryption. Key ideas include Quantum-Inspired Keying—short-lived, context-aware, state-specific keys that don’t need quantum hardware but make cognitive pathways nearly impossible to replay or reconstruct. routing, memory fragments, and relationships between components. Public schema uses hashes + encrypted ciphertext + receipts. Sovereign Vaults: Governed memory structures with policy-gated, abstracted access (e.g., return commitments/hashes instead of raw data). Computational Receipts: Verifiable proof objects that log work (e.g., transfers, reads) while hiding private pathways. Includes chaining for ledgers. Private-Core / Public-Proof Separation: Keep sensitive cognition hidden while allowing verifiable public evidence. The central thesis: Sovereign AI systems must prove work occurred without surrendering the private pathway that produced it — “secrecy as structure, not darkness.”Files Included (full package)Full research paper (PDF ~728 KB) + Markdown version. Architecture diagrams (shadow wire, sovereign vault, receipt chain, private-core/public-proof). JSON schemas (for receipts, shadow-wire envelopes, vault events). Example objects (receipts, envelopes, ledgers, CSV ledger). Reference Python demo (phantom_crypto_demo.py): Runnable code demonstrating shadow wire transfers, vault writes/reads, receipt chaining using standard crypto primitives (AES-GCM, HKDF, SHA-256). Includes executed Jupyter notebook. Metadata, citation files (.bib), LICENSE, manifest, reproducibility notes. The demo code is public-safe reference implementation only — explicitly noted as not for production use without expert review

Update on github.com/itsnotailabs/M… Adds an in-boundary way to turn raw strings into vectors so MatDaemon's ranking surface works on text directly, without an external embedding model. •matdaemon/text.py — hashing_embed()and text_similarity_top_k() using the signed hashing trick (feature hashing). Pure NumPy, deterministic across processes. •Two new tools (auto-exposed on both MCP stdio and the HTTP tool API via TOOL_HANDLERS): ◦matdaemon_embed_text — strings → deterministic float vectors ◦matdaemon_text_similarity_top_k— embed + cosine top-k in one call •SDK exports: hashing_embed, text_similarity_top_k •Registered in platform.MCP_TOOLS; documented in docs/CLOUD.md. Why similarity_top_k ranks pre-computedembedding vectors, but callers had no way inside MatDaemon's safety boundary to produce those vectors from text they needed an external embedding model, which pushes past the "no network, no model download" surface. This closes that gap for lexical workloads (dedup, fuzzy record linking, short-text retrieval). Neural embeddings still flow through similarity_top_k for semantic matching — the ranking math is identical. Correctness note The vectorizer deliberately uses blake2b, not Python's builtin hash(), which is salted per process (PYTHONHASHSEED) and would yield different vectors on every run — breaking any cached-embedding or cross-service workflow. A dedicated test spawns two interpreters with different PYTHONHASHSEED values and asserts identical output.

got it to be multi modal voice agents. Here it is writing files.

low latency voice interactions with AI that actually works so does the AI. Live API will be available for extremal uses as well. can keep up with clear conversations even when looking at browsers after i had so many issues with voice agents (Sorry about the sound mic quality)

/** * Audio helper for converting between Float32Array PCM and raw 16-bit integer PCM. * Useful for Gemini Live API and browser voice streaming. */ export function floatTo16BitPCM(input: Float32Array): ArrayBuffer { const buffer = new ArrayBuffer(input.length * 2); const view = new DataView(buffer); let offset = 0; for (let i = 0; i < input.length; i++, offset += 2) { let s = Math.max(-1, Math.min(1, input[i])); view.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7FFF, true); } return buffer; } export function base64ToArrayBuffer(base64: string): ArrayBuffer { const binaryString = window.atob(base64); const len = binaryString.length; const bytes = new Uint8Array(len); for (let i = 0; i < len; i++) { bytes[i] = binaryString.charCodeAt(i); } return bytes.buffer; } export function arrayBufferToBase64(buffer: ArrayBuffer): string { let binary = ''; const bytes = new Uint8Array(buffer); const len = bytes.byteLength; for (let i = 0; i < len; i++) { binary += String.fromCharCode(bytes[i]); } return window.btoa(binary); } /** * Playback PCM raw chunks (24kHz format from Gemini Live API) * Gapless scheduling to avoid audio glitches during streaming. */ export class PCMPlayer { private audioCtx: AudioContext | null = null; private nextStartTime: number = 0; constructor(private sampleRate: number = 24000) {} public init() { if (!this.audioCtx) { this.audioCtx = new (window.AudioContext || (window as any).webkitAudioContext)({ sampleRate: this.sampleRate, }); this.nextStartTime = this.audioCtx.currentTime; } if (this.audioCtx.state === 'suspended') { this.audioCtx.resume(); } } public playChunk(base64Data: string) { this.init(); if (!this.audioCtx) return; try { const arrayBuf = base64ToArrayBuffer(base64Data); const int16Array = new Int16Array(arrayBuf); const float32Array = new Float32Array(int16Array.length); // Convert 16-bit signed PCM to Float32 for (let i = 0; i < int16Array.length; i++) { float32Array[i] = int16Array[i] / 32768.0; } const audioBuffer = this.audioCtx.createBuffer(1, float32Array.length, this.sampleRate); audioBuffer.getChannelData(0).set(float32Array); const source = this.audioCtx.createBufferSource(); source.buffer = audioBuffer; source.connect(this.audioCtx.destination); // Gapless scheduling const currentTime = this.audioCtx.currentTime; if (this.nextStartTime < currentTime) { this.nextStartTime = currentTime + 0.05; // small safety buffer } source.start(this.nextStartTime); this.nextStartTime += audioBuffer.duration; } catch (err) { console.error('Failed to play raw PCM chunk:', err); } } public stop() { if (this.audioCtx) { this.nextStartTime = this.audioCtx.currentTime; } } public close() { if (this.audioCtx) { this.audioCtx.close(); this.audioCtx = null; } } } /** * Text-to-Speech browser fallback. * Ensures rich audio response even under iframe permission limits or offline/mock mode. */ export function speakTextFallback(text: string, langCode: string = 'en-US') { if (!('speechSynthesis' in window)) return; window.speechSynthesis.cancel(); const cleanText = text.replace(/[*#_`]/g, ''); // strip markdown const utterance = new SpeechSynthesisUtterance(cleanText); utterance.rate = 0.95; // slightly slower for clarity / language learners // Choose a good voice const voices = window.speechSynthesis.getVoices(); let selectedVoice: SpeechSynthesisVoice | null = null; if (langCode.toLowerCase().includes('ja')) { selectedVoice = voices.find(v => v . lang.startsWith('ja') || v . name . includes('Google 日本語') || v. name . includes('Kyoko') ) || null; } else { selectedVoice = voices.find(v => v . lang.startsWith('en') && (v. name .includes('Natural') || ncludes('Google') || h.includes('Samantha')) ) || null; } if (selectedVoice) { utterance.voice = selectedVoice; } window.speechSynthesis.speak(utterance); }

A little longer term plan look ahead. Which is why local models are so important to us. edge models. would be cool to get there by end of next year fully embodied. Apps will release later this year I need to build more community first. Still Eyeing July 28 for all MESIE v1 Compute systems for AI release. this was made by an ai agent executing a flow in my beta by my actual agents testing lol recursive architecture is funny. because this easily could have also been made by my regular agent but was just a byproduct of running a test

Relation to Real Neuroscience The design draws from connectomics — the study of brain networks via structural (white-matter tracts from diffusion imaging) and functional connectivity.

It supports intelligence progression “from passive observation to autonomous reasoning, with connectome and memory (TAURUS).” Simulations generate “human-connectome reports” that flag issues like region saturation (>90% activation in five regions) and suggest homeostatic scaling.

The connectome enables treating spectral data (frequencies, resonance, coherence, band energy) as literal cognition. MESIE processes signals deterministically and mathematically before escalating to higher-level LLM reasoning.

Key Specifications (from public posts) 44 regions — A simplified, biologically-grounded parcellation. 68 tracts — Representing major connection pathways. MNI coordinates — Standard Montreal Neurological Institute space used in neuroimaging for precise 3D positioning and mapping. Functionality — Handles node mapping, lineage tracking, component graphs (via the topology/ module), and 3D visualization/export (via visualization/ and connectome/ folders). It supports cross-domain transfer, cognitive processing (linked to TAURUS memory and NeuroCores), and integration with transformer pipelines.@ItsnotAILabs

NeuroAIX connectome is a custom 3D brain model component within the MESIE (Multi-Element Spectral Intelligence Engine) framework developed by @ItsnotAILabs It integrates spectral signal processing with neuro-inspired architecture for agentic, hybrid math-LLM systems.

mesie/ ├── core/ — MultiElementRecord, SpectralComponent, MatchResult, GenerationConfig ├── io/ — Loading from JSON, CSV, arrays, DataFrames; export ├── processing/ — Normalization, interpolation, band-pass smoothing ├── matching/ — Composite scoring, frequency overlap, amplitude correlation ├── generation/ — PSD, FAS, RotDnn, single-component synthetic generation ├── features/ — Electro-spectral signatures, resonance peaks, coherence, band energy ├── topology/ — Node mapping, lineage tracking, component graph ├── embeddings/ — SpectralVectorizer, resonance-aware vector encoding ├── cognitive/ — TAURUS memory, NeuroCores, cross-domain transfer, experiment engine ├── ai/ — Transformer pipeline, intelligence protocols, training, transfer ├── protocols/ — SpectralDataProtocol, StreamingProtocol, multi-format serialization ├── integration/ — AISystemConnector, PipelineOrchestrator, library bridges ├── helix/ — VectorHelix, HelixConfig, HelixRetriever ├── pretraining/ — Foundation objectives, observation encoder, digital twin, spectral memory ├── connectome/ — 3D NeuroAIX brain (44 regions, 68 tracts, MNI coordinates) ├── internal_api/ — Cross-engine communication bus (9 processing engines) ├── library/ — User spectral corpus loader, MAESI SDK ├── validation/ — 6-level validation pipeline └── visualization/ — Spectral plotting, attention maps, connectome 3D export

The words really do help shape the logic.

Because the backend is doctrine-driven, these words aren’t decorative; they help define the rules of engagement, activation logic, coordination patterns, and even failure modes (like self-destruct as a deliberate last-resort isolation mechanism).

The system does appear to take the names and relationships somewhat literally in how the components are structured and how agents relate to each other. This is common in sophisticated agentic systems: the ontology (the “who does what to whom and how”) is encoded directly into the code, state machines, resource models, and even how the LLM components reason about tasks.

Jutsu (with specific names and costs) map to distinct techniques/modules or coordinated actions the agents can execute.

Chakra threads map to real control/communication/resource links in the swarm mesh.