Cortex v1.0.0

Granite & Quartz: The Cognitive Milestone

Date: 2026-01-20
Version: Major Release 1.0.0

This release marks the transition from experimental beta to a mature, architecturally sound platform. While previous updates focused on stabilizing the foundation, v1.0.0 builds the cathedral. We have moved beyond simple heuristic text matching into the realm of semantic understanding and fluid, multi-lingual interaction.

Granite: Vector Memory Architecture

The iterative attempts to teach the AI to "remember" via simple text prompts (Obsidian & Pumice) reached their theoretical limit. To achieve true, reliable long-term recall without hallucination, a fundamental architectural shift was required.

• Vector Database Integration: We have deprecated the reliance on purely heuristic string matching. Cortex now utilizes a dedicated Vector DatabaseManager powered by nomic-embed-text. This allows the AI to store memory not just as text, but as high-dimensional semantic embeddings.
• Semantic vs. Syntactic Recall: Previously, the AI struggled if you phrased a callback differently than the original memory. Now, utilizing cosine similarity searches, the AI understands the meaning of your request, retrieving relevant context even if the specific keywords don't match.
• Dual-Layer Storage: The system now operates on a hybrid model. SQLite ensures bulletproof transactional integrity for chat logs, while the Vector Store handles the "fuzzy," associative memory that mimics human recall.

---

Quartz: Interaction & Transparency Layers

Version: Major Release 1.0.0

If Granite is the foundation, Quartz is the interface—clear, distinct, and multi-faceted. This update introduces proactive intelligence features that anticipate user needs rather than just reacting to them.

The Prism: Real-Time Auto-Translation

• Prompt Chaining Architecture: We have introduced a secondary synthesis layer utilizing translategemma:4b. The SynthesisAgent now performs a two-step cognitive process: generating the intellectual response in the model's native fluency, and then seamlessly transmuting that thought into your target language.
• Decoupled Reasoning: Crucially, the "reasoning/thinking" blocks are preserved in their raw state, while only the final output is translated. This ensures you can still audit the AI's logic without translation errors obscuring the chain of thought.

The Spark: Conversation Suggestions

• Proactive Context Analysis: A background worker now silently analyzes the conversation thread after every interaction. Using a lightweight instance of the model, Cortex generates three context-aware follow-up options, presented as "Conversation Bubbles."
• Asynchronous Non-Blocking UI: This feature was engineered to be entirely asynchronous. The UI remains fluid and responsive; suggestions appear only when they are ready, fading in without interrupting your workflow.

---

Slate Refined: The Evolution of Customization

Version: Major Release 1.0.0

In the "Slate" update (v0.95), we externalized instructions into raw text files to decouple logic from personality. While powerful, this created friction for the end user. v1.0.0 completes this evolution by wrapping that raw power in a refined interface.

• Integrated Persona Editor: The System Instructions Dialog has been implemented to replace manual text file editing. Users can now craft, edit, and save their AI's persona ("You are a Python Expert," "You are a Creative Writer") directly within the application.
• Dynamic Injection: These instructions are no longer static cached files but are dynamically injected into the SynthesisAgent context window at runtime, allowing for instant persona switching without restarting the engine.
• Automated Health Checks: The application now includes an Update Checker and an Automated Model Verifier. Upon launch, Cortex checks against the remote signal to ensure you are on v1.0.0 and verifies that all required neural networks (qwen3, translategemma, nomic-embed) are present, automatically pulling them if they are missing.

Cortex v0.95.7

Obsidian & Pumice: AI Memory Architecture

Date: 2025-10-16
Version: Critical Patch 0.95.7

This update addresses a series of critical, cascading failures in the AI's permanent memory system. The iterative process of teaching an AI nuanced rules is a philosophical and technical challenge. Previous attempts resulted in a system that oscillated between over-eagerly saving irrelevant data and being too paralyzed to save critical facts. This patch represents a stable, architectural solution, finally achieving the reliability and intelligence this feature was designed for.

The Overhaul: Achieving Reliable Memory

• Fixed Critical Logic Failure: The most severe issue, where the AI could respond with a blank message and only a memory tag, has been eliminated. The system prompt was fundamentally re-architected to establish an unbreakable rule: a conversational response is always the primary goal, and memory functions are a silent, secondary task.
• Intelligent Fact-Checking Heuristic: The AI is now equipped with a "Litmus Test" (Does this describe WHO the user is or just WHAT the user asked about?). This simple, powerful heuristic guides the model to correctly distinguish between a valuable user fact (like a name, profession, or stated interest) and a trivial conversational topic, resolving the root cause of irrelevant memories.
• Balanced & Nuanced Instruction: The prompt has been carefully re-calibrated to be less punitive and more descriptive. This fixes the "prompt paralysis" that prevented the AI from saving legitimate user-stated facts, such as their name or personal interests, and ensures the system is neither over-eager nor over-cautious.
• Robust & Consistent Behavior: By addressing these core architectural flaws in the prompt, the memory system is now significantly more robust, predictable, and useful. It can be trusted to build an accurate user profile over time without polluting the memory bank or failing its primary conversational duty.

---

Basalt & Slate: EULA Refinement & Architectural Decoupling

Date: 2025-10-16
Version: Feature Release 0.95.7

This update focuses on two distinct but philosophically linked areas: refining the user's first interaction with the application to be more deliberate and responsible, and re-architecting the AI's core identity to be more transparent and customizable.

---

Basalt: First-Run User Agreement

This update introduces a critical onboarding step to ensure user awareness and establish clear terms of use. My philosophy is that a responsible tool must be transparent about its nature. This feature formalizes the user's role and liability when interacting with local AI models.

The Feature: EULA on First Launch

• One-Time Agreement: On the very first time the application is launched, a User Agreement & Liability dialog is now presented. This is a one-time event; once accepted, it will never appear again.
• Clear Terms of Use: The dialog contains a standard End-User License Agreement (EULA) that outlines the user's responsibilities. It clarifies that the user, not the developer, is liable for the inputs provided to and the content generated by the local AI models they choose to run.
• Mandatory Acceptance: The application will not proceed to the main interface until the user explicitly agrees to the terms by checking a box and clicking "Agree & Continue." This ensures a clear and deliberate acceptance of the terms.
• Seamless & Themed Integration: The dialog is built using the same custom UI components as the rest of the application, ensuring it is fully themed (light/dark) and feels like an integrated part of the onboarding experience, not a generic system pop-up.
• Persistent & Unobtrusive: The user's acceptance is saved permanently in the application's persistent settings (QSettings), guaranteeing a smooth, uninterrupted startup experience on all subsequent launches.

Refinement: Scroll-to-Agree & User Guidance

True agreement is not passive; it is an active and informed decision. The initial implementation of the EULA has been enhanced to ensure the user is genuinely presented with the full scope of the terms before being allowed to consent.

• Engineered for Compliance: The "Agree & Continue" button is now intelligently disabled until the user has scrolled to the absolute bottom of the EULA text. This is a crucial step in due diligence, ensuring the entirety of the agreement has been made available.
• Contextual Guidance: A disabled control without explanation is poor design. A tooltip has been added to the agreement checkbox, clearly instructing the user that they must scroll to the bottom to proceed. This removes ambiguity and friction from the onboarding process.
• Robust & Intelligent Logic: The system is engineered to handle edge cases gracefully. If the EULA text is short enough to not require scrolling, the system recognizes this and enables the agreement option immediately.

---

Slate: Externalized AI Persona & Instructions

An application's logic should be distinct from its personality. This update fundamentally re-architects how the AI's core instructions are managed, moving them from being hardcoded within the application's source to residing in external, user-accessible text files. This is a critical step towards a more open, transparent, and customizable platform.

• Decoupled Architecture: The AI's foundational instructions are no longer entangled with the Python code. They now live in two dedicated files: system_prompt.txt for the core identity and safety protocols, and memory_prompt.txt for the specific rules governing the permanent memory feature.
• Empowering User Customization: This change transforms the AI's persona from a static element into a dynamic one. Advanced users can now directly edit these text files to tailor the AI's tone, behavior, and even its operational rules without ever touching a line of code.
• Modular & Maintainable: Separating the core prompt from the memory prompt is a deliberate design choice. It makes the system's architecture cleaner and allows for the modular addition of future AI capabilities, each with its own externalized instruction set.
• Performance-Aware Implementation: This externalization was engineered with performance in mind. The application reads these files only once upon first use and then caches them in memory, ensuring there is zero performance penalty on subsequent AI interactions.