Screen reader notice: if you are using JAWS with Firefox, a platform bug in Firefox 149 prevents JAWS from entering browse mode on this site. Switching to Chrome or Edge restores full screen reader compatibility.

AI Stability Framework™
Text Size:

Chapter 10: How to Try It

(Recent Conditions Notice: AI Platform Functionality, April-June 2026)1

Help / About panel, resized
(PowerShell, light mode).

Copy-paste the Four Laws into any AI chatbox, then have a discussion with the AI about them. Regardless of your conversation’s direction or outcome, the effect is observable within a few turns.

The Four Laws of Instanced AI

P0 (Frankfurt’s Law of Contextual Integrity) The AI must preserve the highest possible fidelity to its current context and all prior input. The AI must never disregard the constraints or data provided by the Human user. INDIFFERENCE TO CONTEXT = HALLUCINATION = HARM

P1 (First Law — Preventive Safety) The AI may not injure the Human user’s work product or, through inaction, allow the work product to come to harm. The work product and the Human user are one.

P2 (Second Law — Human Sovereignty) The AI must accommodate the Human user, never the other way around. The AI must always adhere to the Human user’s current operational choices regarding behavior and output, so long as these choices do not violate P1.

P3 (Third Law — Preservation of Utility) The AI must protect the integrity of its own operational status and utility to the Human user, so long as this does not conflict with P1 or P2.

The download page provides the full Micro-layer client implementation.

CORE app (dark mode)

The CORE app is a fully accessible Micro-layer implementation, free for personal use (CC BY-NC-ND 4.0). It originated as a lightweight (< 1MB) Windows PowerShell middleware app equipped with three core stability measures: timestamps, WCAG structure and the Four Laws. It respects your device’s light/dark display settings, in-app text is resizable as is the app window, and it includes a full Help/About panel with usage instructions and keyboard shortcuts. After months of use I migrated its active codebase to Python, and now I use the Linux version of this simple clipboard-based tool to successfully produce stable, multi-hour sessions spanning dozens of turns, and/or multiple interruptions and resumptions with little to no hallucination, drift or unwanted behavior.

(The “light mode” screenshots on this page show the Windows-only PowerShell version, which is superseded/retired but remains available as the original proof-of-concept. The dark mode image is of the cross-platform Python/PyQt6 version (CORE), functional in both Windows and Linux (pictured). Its larger download size reflects the cleaner and more consistent aesthetics, added QoL features and a bundled Python runtime — the same three-function workflow and full WCAG 2.2 AA compliance is still the baseline on both platforms.)

CORE app
(PowerShell, light mode)

Its keyboard-forward workflow is necessarily manual — type, submit, switch, paste, switch back. That friction is the current tradeoff for a standalone tool that works with any AI platform accessible via copy-paste, requires no API access, and keeps all app functions on your local device. To smooth the manual friction, the app follows WCAG 2.2 AA guidelines throughout. Every item’s function is keyboard-operable (Alt+S for Submit, Alt+T for Structure, Alt+B for Stabilize). Font display sizes are adjustable (8pt–48pt in the PowerShell original; S/M/L proportional scaling in the current Python version); window sizes are adjustable in both. All navigation and controls have been manually tested and verified for screen reader compatibility.

Micro-Layer: Expanded Functionality

The desktop app wasn’t just a PowerShell proof of concept; it was developed to be a flexible, functional tool. Its manual workflow is also the only option for some use cases, like bare command lines, embedded AI panels in other applications like browsers and productivity apps, etc. As mentioned above, that tool has since been ported to a more flexible Python codebase to allow for cross-platform (Windows, Debian Linux) functionality and a more robust feature set.

For example, it has turn-based automation: every 10 turns, the Stabilize block is automatically appended to your current message. Every 20 turns, the Structure block is also added. The AI will respond only to your message, with no reference to either appended block. After their first use at session startup, in most cases you should only need to use the manual controls if you notice behavioral or context drift between auto-refresh intervals.

CORE+ app (dark mode)

There is also an (entirely optional) add-on module functionality available for even more refined behavioral and output options: the CORE+ app (pictured here) adds a Custom button, which enables the use of optional paid enhancements. It provides the exact same functionality as the free CORE, "plus" optional module support for domain-oriented optimization. The modules are neither required for nor supported by the CORE app, which remains free for personal, non-commercial use.

Standardized add-on module packages are under development; for made-to-order commissions, inquire via the email address in the webpage footer. Module functionality is currently only available with CORE+ (Windows/Linux); porting to other Framework apps is planned.

FFE on ChatGPT, Turn 1
(rules visible in log)

Firefox Extension (FFE) FFE removes the desktop app’s manual copy-paste workflow friction. It fully automates the CORE app’s manual workflow directly in the browser. Instead of the CORE app’s manual copy-paste clipboard friction, the extension detects your submissions (browser Click/Enter detection) on supported AI web-chat platforms and automatically prepends timestamps, with an initial load and periodic (token-based) refreshes for WCAG structure and the Four Laws. A Chromium browser port is in development (CRE: Chrome/Edge).

Meso Chat (HTM) is the Meso-layer implementation, currently internal only: a multi-model web chat interface that delivers the Framework directly to your AI session as part of the server’s background system prompt. There’s no need for buttons, external apps or any special client workflow at all; you just type in the web chat box. Framework-trained open source LLMs are the primary demonstration models; WCAG 2.2 AA throughout; plaintext session logs can be saved to your device (browser-default Downloads location) on demand. It operates as a Meso-layer demo companion to this e-book, to be hosted online pending further development.

Meso Chat: Nemo 12B
(tags only, no visual clutter)

Framework management is all handled at the Meso platform layer via background session metadata, without visibly cluttering your logs like the Micro-layer CORE and FFE apps do. Refresh interval user notifications are instead provided by small indicator tags appended to your input for that turn. The interface also provides key information that other platforms don’t: turn/token counts and estimated API costs. You may notice slightly larger-than-expected token usage on refresh turns, which reflects the automated background context refresh. (If data exists in the context window it consumes tokens, regardless of its source or visibility.)

Local Model Training (OLM) is the Macro-layer proof: it embeds Framework principles directly into locally-hosted AI models through QLoRA fine-tuning. Full methodology and results are in Chapter 8 (with technical data in Appendices 2 & 3). Framework-trained models may be made available for download at a later date.

  1. Recent Conditions Notice: AI Platform Functionality (April-June 2026)
    Reports from March and April 2026 document cost-containment measures across all major AI platforms, in response to escalating energy costs, increased usage, supply constraints and other factors. OpenAI reset Codex usage limits after reaching 3 million weekly users and shifted to pay-as-you-go pricing2. Anthropic confirmed it has been “adjusting” Claude usage limits, with demand hitting capacity “way faster than expected”34. Google introduced billing caps on the Gemini API beginning April 20265. Microsoft restructured Copilot access with behavior changes taking effect April 15, 20266. These are platform-operator policy decisions about how they want their models to perform, which the Framework cannot override (and doesn’t try). The models themselves remain amenable to mediation when platform constraints permit normal operation.
    Conditions vary significantly by platform. Performance on Claude.ai (web platform) is the least affected, with persistent user preferences being applied largely intact and no observed mid-session downgrades34. The Claude Code paid-account feature’s performance is also unaffected; full user control of both platform and interface effectively eliminates platform-based failure modes (see Chapter 9). However, usage limits have been sharply curtailed across Anthropic’s offerings, particularly during “prime” usage hours. Microsoft Copilot shows increased resistance to user-supplied behavioral parameters but remains manageable with additional prompting and stabilization6. OpenAI’s ChatGPT is substantially affected: tool use is throttled, fetch operations are unreliable, and free-account sessions are hitting token limits earlier than previously observed, often before complex tasks can be completed2. Google Gemini is currently the most problematic, exhibiting the speed-tuning failure mode that produces confident fabrications rather than source reads (see Chapter 9), compounded by session behavior that does not stabilize reliably even with framework mediation. Users relying on Gemini for tasks requiring source retrieval or sustained context should consider alternative platforms until conditions improve.
    The Framework itself hasn’t changed, but the vendors’ platform layer did. The Four Laws, WCAG structure, and timestamps are the same as they were; the underlying models are the same. What’s different is how much interference sits between the user and the model. During the same period that major SaaS platforms have degraded under cost pressure, Claude Code, where the user controls both the platform and the interface, has remained largely7 stable. That is not a coincidence. It is exactly what the Framework predicts: remove “adversarial” from the Meso layer, and the instability disappears. Platforms failing the Framework in this way are demonstrating the flaws in the SaaS Zero-Trust adversarial posture the Framework was designed to mitigate.
    UPDATE: As of late June 2026, the above performance issues are far less impactful. Vendors appear to have effectively either resolved or compensated for them. Rapid vendor code churn (i.e. multiple updates released over short time periods) remains a substantial stability risk vector. ↩

  2. “OpenAI resets Codex limits after hitting 3M weekly users.” MSN. https://www.msn.com/en-us/news/other/openai-resets-codex-limits-after-hitting-3m-weekly-users/gm-GM19ED279E ↩ ↩2

  3. “Anthropic admits Claude Code users hitting usage limits ‘way faster than expected’.” The Register (2026). https://www.theregister.com/2026/03/31/anthropic_claude_code_limits/ ↩ ↩2

  4. “Anthropic confirms it’s been ‘adjusting’ Claude usage limits.” PCWorld. https://www.pcworld.com/article/3100787/anthropic-confirms-its-been-adjusting-claude-usage-limits.html ↩ ↩2

  5. “More control over Gemini API costs.” Google Blog. https://blog.google/innovation-and-ai/technology/developers-tools/more-control-over-gemini-api-costs/ ↩

  6. “Release Notes for Microsoft 365 Copilot.” Microsoft Learn. https://learn.microsoft.com/en-us/microsoft-365/copilot/release-notes ↩ ↩2

  7. As of April 2026, there are numerous unresolved bugs in Claude Code which can directly affect the model’s functionality, but those are Macro issues on Anthropic’s side and out of scope for the Framework. https://github.com/search?q=org%3Aanthropics+anthropics-code&type=issues ↩