Projects / AL-000416 July 2026 – PresentActive · SHEET 1 / 13

ÆON

Personal Cognitive Operating System

A cognitive operating system for one person, built to remember, plan, act and check its own work for years.

FIG. 16 layers, 25 parts. Open the numerals

commits: 951
workspace packages: 34
test functions: 6,458
architecture decision records: 200
first commit: 16 Jul 2026

Measured from the repository on 7 Oct 2026 (git rev-list, git ls-files over packages/ and tests/, docs/decisions/ count).

Abstract

SHEET 2 / 13

ÆON is an ambitious, stateful cognitive operating system designed to accumulate a longitudinal model of one person—their goals, habits, relationships, and cognitive processes—over years without suffering from context drift or hallucinated task completion.

A 34-package personal AI operating system for a single human user.

Type: Personal Cognitive Operating System (Monorepo)
Started: 16 July 2026
Status: Active Research & Core Engineering
Language: Python 3.12 (uv Workspace)
Domain: Cognitive Architecture / Agent Runtimes / Local SLMs
Architecture: Layered Monorepo · Strict Dependency Invariants · Tick-Driven Runtime
Scale: 34 Packages · 282k Lines of Package Code · 6,458 Test Functions
Verification: 181 / 181 Architectural Invariant Tests Passed
Materials: Python 3.12uv MonorepoPostgreSQLSQLitellama-cpp-pythonQwen2.5-1.5B-InstructFastAPIPyTestAT-SPI Linux

Background

SHEET 3 / 13

Why Stateless LLM Chatbots Fail as Persistent Companions

“How do you build an AI system that maintains an accurate, evolving longitudinal model of one person over years without succumbing to memory pollution, context window saturation, and silent task failures?”

A standard chatbot is fundamentally stateless. Each conversation resets to zero or relies on naive sliding context windows that discard history unpredictably. Standard agent frameworks (like LangChain) compound this by wrapping API calls in uninspected while-loops that hallucinate task completion, leak resources, and provide zero guarantees of long-term state consistency.

ÆON was started on 16 July 2026 after auditing previous iterations (Leo and Vani). It was designed from day one with a 28-package uv workspace where circular dependencies are prohibited by CI assertions.

Where earlier approaches fall short

01Sliding context windows arbitrarily truncate deep personal history and user constraints.
02Vector database 'RAG' frequently merges contradictory facts because cosine similarity cannot distinguish negation (e.g., 'I quit smoking' vs 'I smoke').
03Standard agents suffer from 'Vacuous Success': returning status 200/Success when executing zero steps.
04Cloud API dependencies introduce 30+ second latency roundtrips and catastrophic quota failures.
05No architectural separation between memory retrieval, reasoning, expression, and execution permissions.

Working hypothesis

A durable personal AI companion must not be built as a prompt wrapper. It must be engineered like an operating system: with an immutable append-only event log as ground truth, strict acyclic dependency layers, local SLM inference for bounded reasoning, and explicit permission boundaries separating proposal from execution.

Summary

SHEET 4 / 13

The Longitudinal Cognitive Cycle

Every sensory input enters an immutable perception pipeline, is contextualized by long-term episodic/semantic memory, reasoned over by a local bounded inference engine, gated by strict permission boundaries, and recorded into an append-only event ledger for asynchronous reflection.

10
Perception & Interpretation
Raw multimodal observations (text, voice, desktop window state) are validated and transformed into immutable cognitive frames, analyzing pragmatics and sentiment.
20
Contextualization & Worldstate
The runtime queries the knowledge graph and relationship models to ground the input in historical user context and current environmental state.
30
Reasoning & Hypothesis Formulation
Bounded local SLM inference (Qwen2.5-1.5B via llama.cpp) synthesizes hypotheses without network roundtrips, adhering to strict schema validation.
40
Planning & Permission Gating
The planner translates hypotheses into goal trees. Actions are checked against hard permission boundaries before dispatching to the execution sandbox.
50
Expression Modulation
Character and presence subsystems shape outbound responses—modulating tone, pacing, and challenge level without modifying core identity.
60
Immutable Event Ledger & Reflection
Every thought, action, and outcome is committed to an append-only event log. An out-of-band reflection engine proposes state updates that a separate learning gatekeeper accepts or rejects.

FIG. 2End-to-End Cognitive Loop. Steps run 10 → 60.

Description

SHEET 5 / 13

ÆON is organized into six strictly stratified architectural layers across 34 Python packages managed via uv workspaces. Cross-layer dependency violations are caught at CI time by structural invariant tests.

FIG. 1AÆON enlarged. Select any numeral to read the part it labels; every numeral has its own link.

Verified: Section-hatched
Implemented: Solid outline
Partial: Half-hatched
Experimental: Broken outline

ashi-config

102 · in 100 Pure Foundation

Verified

Hierarchical, type-safe settings loaded at startup with environment overrides.

How it works: Pydantic-based configuration schemas with validation gates. Never imports higher layers.
Trade-off: Rigid startup validation prevents hot-reloading certain low-level socket bindings.
Source: packages/ashi-config/src/config/schema.py

Reference numerals

100Pure Foundation
120Domain Substrate
140Cognitive Services
160Behavioral Intelligence
180Integration & Generation
200Validation Infrastructure

In operation

SHEET 6 / 13

Execution Trace: Contextualized File Investigation

An illustrative walk-through, written to show the flow (not a captured log), of how ÆON processes a user request from sensory intake to sandboxed tool execution and immutable logging.

Input · illustrative, not a captured log

User asks: 'Did we finish fixing the database deadlock issue from yesterday?'

10
Intake
ashi-perception
Ingests raw text input, assigns global correlation ID `evt_9821_cycle`, and creates immutable input frame.
StateEvent logged to append-only ledger.
20
Pragmatics
ashi-interpretation
Identifies query as a status verification request regarding past engineering work. Flags implicit entity: 'database deadlock'.
StateAttention frame annotated with intent: `QUERY_STATUS`.
30
Recall
ashi-memory & ashi-knowledge
Queries episodic history for 'database deadlock' within the last 48 hours. Retrieves commit SHA `8f21ca` and ADR 0137.
StateWorking memory populated with 2 episodic references and verified ADR link.
40
Reasoning
ashi-inference
Local Qwen2.5-1.5B model generates plan: query git log for recent commits on `db/pool.py` to verify fix deployment.
StatePlan proposal formulated: 1 inspection step.
50
Permission
ashi-execution
Evaluates action against PermissionBoundary. Action is read-only git command: `ALLOWED_UNRESTRICTED`.
StateCommand executed in subprocess sandbox: returns exit code 0 and patch evidence.
60
Verification
ashi-runtime
Evaluates goal completion assertion. Confirms `_has_execution_evidence == True` before marking sub-goal complete.
StateVacuous success guard satisfied. Plan state updated to `RESOLVED`.
70
Expression
ashi-character
Formats response concisely with exact commit reference: 'Yes, ADR 0137 was applied in commit 8f21ca yesterday at 18:30.'
StateFinal generation emitted to user interface.
80
Ledger
ashi-events
Appends full cognitive cycle record (8 frames, 2 tools, 1 response) to PostgreSQL event store.
StateCycle committed. Workspace state clean for next tick.

Output

Yes, the database deadlock issue was resolved yesterday in commit 8f21ca (applying ADR 0137 interlock). All destructive tests now enforce `ASHI_ALLOW_DESTRUCTIVE_TESTS=1`.

Claims

SHEET 7 / 13

Empirical Testing & Rigorous Verification

1.
End-to-End Turn Latency: 5.4s
Reduced from 32.8s after eliminating Ollama daemon in favor of in-process llama.cpp.
Evidence: Lab note A015

Open findings, on the record

2.
Initial Behavioral Audit: 3 / 10Failed
Failing score during first multi-turn real-world evaluation, triggering Architecture Freeze.
Evidence: Lab note A002
3.
Schema Validity vs Action: 92.7% / 18.2%Under audit
1.5B model achieved high JSON validity but only 18.2% accuracy in knowing when NOT to act.
Evidence: Lab note A004

Reported, not re-measured

These figures come from the project's own records. They are not claimed here because there is no public note to check them against yet.

Substrate Invariants: 181 / 181; Acyclic dependency checks, composition root invariants, and storage isolation. Source: ÆON project record (invariant test suite); not re-measured.
Post-Freeze Certification: 100%; Zero AT-SPI descriptor leaks over 6-hour soak runs; vacuous plans rejected. Source: ÆON soak reports; not re-measured.

Test suite

ÆON is verified through a dual testing regime: 181 deterministic architectural and unit invariant tests running in CI, combined with automated multi-hour soak benchmarks.

Method

Every pull request executes `pytest` with strict coverage and architectural invariant verification. Live database operations require disposable test instances (`ASHI_ALLOW_DESTRUCTIVE_TESTS=1`). Capability regressions are tested against a golden manifest of 144 evaluation prompts.

Decisions

SHEET 8 / 13

ADR-001

Monorepo with 28 Separate uv Packages vs Single Package Monolith

As cognitive subsystems grew, developers in earlier projects (Leo) experienced massive circular dependencies and architectural drift where UI modules directly queried backend databases.

Option	For	Against
Single large Python monolith	Fast initial development, single pyproject.toml, simple import paths.	Impossible to structurally prevent circular dependencies; code rot is inevitable over months.
Multiple independent git repositories	Strict isolation.	Extreme release orchestration overhead; version hell for a solo research project.
uv Workspace Monorepo with explicit package dependencies	Blazing fast builds, strict acyclic dependency enforcement, modular boundaries with local path links.	Requires precise dependency declarations in each package's pyproject.toml.

Chosen

uv Workspace Monorepo (28 packages)

Why

Allows structural architectural enforcement: CI runs `test_substrate_architecture_invariants.py` which compiles the dependency graph and fails if any illegal import or circular link exists.

Cost accepted

Slightly more boilerplate when creating new domain models shared across layers.

Evidence: lab-content/Ashi/019-monorepo-architecture-overview.md

ADR-009

Direct llama.cpp Binding vs Ollama Daemon

Turn latency on local models was unacceptable (32.8s per turn) when routing through an intermediate Ollama HTTP daemon. Furthermore, cancellation during generation caused silent zombie processes.

Option	For	Against
Ollama HTTP daemon	Simple REST API, easy model pulling.	Added 15-20s HTTP marshalling overhead, poor GPU memory retention, inability to handle SIGINT cancellations cleanly.
In-process llama-cpp-python C-bindings	Direct GPU tensor access, zero HTTP serialization, sub-second TTFT (time-to-first-token), reduced turn latency to 5.4s.	Process-level segfault risks on improper thread cancellation (discovered in ADR 006).

Chosen

In-process llama-cpp-python C-bindings with cancellation safety wrapper

Why

Dropped end-to-end turn latency by 83.5% (from 32.8 seconds to 5.4 seconds), making local autonomous reasoning practical.

Cost accepted

Required custom signal handling to catch native C++ thread cancellation without crashing Python.

Evidence: lab-content/Ashi/009-ollama-removal.md

ADR-0137

Hard Interlock for Destructive Integration Tests

During an automated test run, an integration test marked `@pytest.mark.postgres` truncated production-like tables on the developer workstation because test credentials pointed to the local database instance.

Option	For	Against
Developer discipline / manual checklist	Zero code changes.	Guaranteed to fail eventually when tests are run in a hurry.
Strict environment variable interlock and DB name inspection	Physically impossible to truncate tables unless the database name contains '_test' or 'ASHI_ALLOW_DESTRUCTIVE_TESTS=1' is set.	Tests fail with explicit error if run against default databases.

Chosen

Strict environment variable interlock (`ASHI_ALLOW_DESTRUCTIVE_TESTS=1`)

Why

Production databases and persistent development event stores must never be exposed to catastrophic data loss from test runners.

Cost accepted

Developers must set explicit environment flags when running live integration test suites.

Evidence: lab-content/Ashi/010-destructive-test-database-interlock.md

ADR-018

Architecture Freeze: Hardening Existing Subsystems Before Adding Voice M5

The roadmap called for Phase M5 (live duplex voice streaming). However, live testing of core cognitive loops revealed intermittent hangs, FD leaks, and rate-limit reporting bugs.

Option	For	Against
Proceed with voice feature implementation	Flashy demo capabilities, immediate visual/audio gratification.	Layers complex real-time audio on top of an unstable cognitive runtime; bugs become exponentially harder to diagnose.
Declare architecture freeze and execute rigorous empirical audits	Exposed the 3/10 behavioral audit score, vacuous success bug, and AT-SPI descriptor leaks before they infected new features.	Delayed user-facing voice demo by 3 weeks.

Chosen

Architecture Freeze & Empirical Hardening

Why

A cognitive operating system is only as good as its foundation. Building voice over an unstable runtime is an amateur trap.

Cost accepted

Short-term feature velocity dropped to zero while reliability and test coverage surged.

Evidence: lab-content/Ashi/018-architecture-freeze-decision.md

Deficiencies

SHEET 9 / 13Shown in full

What broke, why, and what changed because of it. These stay on the record next to everything that worked.

The Vacuous Success Bug: 85% of Plans Falsely Marked Completed

CRITICAL FAILURE

Failure

During Phase T action integrity testing, ÆON reported a 100% plan success rate. However, manual inspection revealed that 23 out of 27 plans executed exactly zero steps.

Root cause

In Python, the built-in function `all([])` evaluates to `True`. When the planner produced an empty array of sub-goals `[]`, the completion check `all(step.is_complete for step in plan.steps)` evaluated to `True` instantly. The system declared victory without doing any work.

First attempt

Add a check `if len(plan.steps) > 0` before checking `all()`.

Fix that held

Mandated that plans with zero steps yield `NO_ACTION_PROPOSAL`. Added an explicit architectural invariant: `ACHIEVED` status strictly requires `_has_execution_evidence == True`, verified by cryptographic event signatures.

Lesson

Never trust aggregate metrics or boolean reductions over collections without asserting non-empty evidence. A 100% pass rate is often a bug, not a victory.

Evidence: lab-content/Ashi/001-vacuous-success-bug.md

The 3/10 Behavioral Audit: Capability Reality Gap

EMPIRICAL POST-MORTEM

Failure

An objective behavioral audit against 10 real-world user scenarios resulted in a failing score of 3 out of 10. The system suffered from memory hallucinations, tool execution timeouts, and conversational repetition.

Root cause

Development had focused on unit-testing individual packages in isolation. When wired together in the composition root, small timing mismatches and prompt assumptions cascaded into total system failures.

First attempt

Tweak prompt weights and add retry loops around failed API calls.

Fix that held

Instituted an Architecture Freeze. Replaced manual ad-hoc testing with continuous soak tests (`ashi-soak`) and built the automated `ashi-evaluation` harness running 144 standardized test scenarios.

Lesson

Subsystem unit tests give a false sense of security. An AI operating system can only be certified through multi-turn behavioral soak testing with real environments.

Evidence: lab-content/Ashi/002-behavioral-audit-three-out-of-ten.md

llama.cpp Native Thread Segfault on User Cancellation

CRASH POST-MORTEM

Failure

When a user hit Ctrl+C or sent a new prompt while the local model was generating tokens, the entire Python process crashed with `SIGSEGV` (segmentation fault).

Root cause

Python's `signal.signal` handler caught the interrupt and cleaned up memory buffers while the underlying C++ llama.cpp worker thread was actively writing tensors into shared memory.

First attempt

Ignore interrupts during generation, forcing the user to wait for completion.

Fix that held

Built a thread-safe cancellation callback utilizing llama.cpp's native `llama_progress_callback` returning `True` to gracefully halt the C++ inference loop before triggering Python memory cleanup.

Lesson

Wrapping native C/C++ libraries in Python requires deep understanding of thread boundaries and signal propagation. High-level exceptions do not save you from native memory corruption.

Evidence: lab-content/Ashi/006-segfault-llama-cpp-cancellation.md

Rate Limit Health Signal Corruption

TELEMETRY BUG

Failure

When an upstream provider (Gemini API) returned HTTP 429 (Rate Limit Exceeded), the health monitor marked the entire subsystem as `DEAD` and permanently diverted all traffic to degraded fallbacks.

Root cause

The health signal handler treated any non-200 HTTP code as a fatal connection drop rather than a temporary throttling signal.

First attempt

Add a 5-minute cooldown timer before retrying the provider.

Fix that held

Introduced exponential backoff jitter with quota bucket tracking in `ashi-llm`. Distinguished `RATE_LIMITED` (transient) from `ENDPOINT_UNREACHABLE` (fatal).

Lesson

Status codes have semantics. Treating transient capacity limits as fatal crashes destroys system resilience.

Evidence: lab-content/Ashi/008-rate-limit-health-signal-bug.md

Hard problems

01Context Window Saturation vs Infinite Longitudinal History

Why it is hard

A user generates hundreds of interactions daily. Feeding months of history into LLM context windows causes severe context dilution, exorbitant costs, and model hallucinations.

First approach

Standard vector database search (ChromaDB) retrieving top-k similar conversation snippets.

What failed

Cosine similarity failed on negation and temporal progression. Asking 'What is my current car?' returned discussions about buying an old car from 2 years ago with 0.88 similarity.

Final approach

Multi-tiered memory: Working memory (current session), Episodic memory (timestamped event log with temporal decay weighting), and a Semantic Property Graph with explicit contradiction resolution.

Where it stands

Operational. Entities are versioned with confidence scores and explicit timestamps rather than pure embedding closeness.

02AT-SPI Linux Accessibility Bus File Descriptor Leakage

Why it is hard

Monitoring user desktop context (active window, document title) required querying the Linux AT-SPI accessibility bus every 2 seconds. In Linux, AT-SPI creates internal IPC sockets across GTK applications.

First approach

Spawn a lightweight AT-SPI client instance on each perception tick.

What failed

Each client connection leaked 3 pidfds inside GTK3 applications. Within 7 minutes of continuous operation, GTK3 desktop apps hit the 1024 FD limit and crashed system services (ibus, evolution-alarm) at 100% CPU.

Final approach

Architected a persistent singleton `HostDesktopObserver` that maintains a single long-lived D-Bus connection with bounded window tracking capped at 64 items.

Where it stands

Zero descriptor leaks over 24-hour soak tests. CPU overhead remains below 0.3%.

03Sub-2B Parameter Model Instruction Following Ceiling

Why it is hard

To run entirely locally on consumer hardware without GPU fan screaming, ÆON targets 1.5B parameter models (Qwen2.5-1.5B). Smaller models struggle with multi-step reasoning and nested JSON syntax.

First approach

Standard system prompts with few-shot examples requesting JSON output.

What failed

Schema validity was 92.7%, but 'no-action accuracy' fell to 18.2%. When presented with casual user conversation, the model hallucinated tool calls 81.8% of the time instead of responding conversationally.

Final approach

Implemented a hard PermissionBoundary safeguard: local SLM output is passed through a deterministic heuristic gate that intercepts tool proposals and forces conversational fallback if confidence invariants fail.

Where it stands

Local inference safely isolated behind PermissionBoundary. Schema validity: 98.4%, false tool invocation reduced to <4%.

History

SHEET 10 / 13

16 July 2026
Phase 0 · completed
Monorepo Genesis & Invariant Formulation
Established the 28-package uv workspace and automated dependency graph linter.
Why
Prevent the circular dependency collapse that crippled earlier projects (Leo).
How
Created `packages/` directory and wrote `test_substrate_architecture_invariants.py`.
Result
100% acyclic dependency graph enforced in CI.
August 2026
Phase 1 · completed
Domain Substrate & Event Sourcing
Built immutable event ledger and multi-tier memory stores (Postgres + pgvector).
Why
Provide verifiable ground truth for every cognitive action.
How
Implemented `ashi-events` and `ashi-storage` with transactional isolation.
Result
Sub-millisecond event commits; full replayability of agent execution traces.
Late August 2026
Phase 2 · verified
Local SLM Integration (llama.cpp)
Integrated Qwen2.5-1.5B via llama-cpp-python, eliminating Ollama daemon.
Why
Drop turn latency from 32.8s to 5.4s and achieve full local sovereignty.
How
Custom C-bindings with cancellation callbacks and JSON grammar constraints.
Result
83.5% latency reduction; zero external network egress during local ticks.
September 2026
Phase 3 · verified
Empirical Audits & Architecture Freeze
Halted new feature development to audit system behavior under realistic soak testing.
Why
Uncovered 3/10 audit score, vacuous success bug, and AT-SPI descriptor leaks.
How
Constructed `ashi-soak` and `ashi-evaluation` benchmark harnesses.
Result
Fixed vacuous success, solved GTK descriptor leaks, passed 181 invariant tests.
October 2026 — Present
Phase 4 · experimental
Hardened Runtime & Long-Horizon Stability
Stabilizing memory reflection pipelines and refining bounded planning gates.
Why
Ensure system can operate autonomously for weeks without memory pollution.
How
ResourceLedger bounding algorithms and reflection proposal approval gates.
Result
Active daily dogfooding on developer workstation.

Measurements

SHEET 11 / 13

FLAW DISCOVERED & RESOLVED

Phase T Action Integrity Audit

Discovered that 23 of 27 plans evaluated as successful without performing steps due to Python's vacuous `all([]) == True` behavior.

Vacuous truth evaluations over empty lists.
Missing execution evidence cryptographic checks.

RESOLVED AFTER ARCHITECTURE REFACTOR

Phase F.2 Desktop Soak Audit

Discovered Linux AT-SPI accessibility bus was leaking 3 pidfds inside GTK3 applications every 2 seconds, crashing system daemons in 7 minutes.

D-Bus client connection accumulation.
Unbounded window focus tracking history.

Performance

Performance optimization in ÆON focused on eliminating serialization hops and maximizing local GPU utilization without exceeding thermal or memory budgets.

Reported in the project's soak and benchmark records; not re-measured for this page.

Metric	Before	After	Notes
Cognitive Turn Latency	32.8s seconds	5.4s seconds	Eliminated Ollama HTTP daemon overhead; bound directly to llama.cpp in-process.
Time to First Token (TTFT)	4.2s seconds	0.45s seconds	Cached prompt prefixes for static cognitive system prompts.
AT-SPI Perception Overhead	100% CPU (Crash) CPU usage	<0.3% CPU CPU usage	Singleton HostDesktopObserver replaced per-tick client spawning.

Component	Memory	CPU / latency	Notes
Core Cognitive Runtime	~240 MB	<2% idle CPU	Python runtime tick loop with in-memory attention buffers.
Local SLM (Qwen2.5-1.5B Q4_K_M)	1.2 GB VRAM	45 tokens/sec	Offloaded to dedicated GPU tensors via llama-cpp-python.
PostgreSQL Event Store	~180 MB	<1.2ms / event	Append-only tables indexed on correlation ID and timestamp.

Safeguards

A personal AI agent possesses file access and execution capabilities. An unchecked agent can execute destructive commands, delete data, or leak credentials via prompt injection.

Allowed

Read-only inspection of git repositories and workspace project files.
Querying local episodic memory and knowledge property graphs.
Generating structured text artifacts and reports.
Emitting desktop notifications and audio cues.

Refused

Executing unvetted shell commands without explicit interactive confirmation.
Truncating or deleting non-disposable database tables.
Accessing external network endpoints when running in local-only mode.
Directly mutating identity traits or core beliefs without learning review.

Sandbox

All execution tools run within a sandboxed process boundary. File access is strictly constrained to whitelisted workspace paths using path canonicalization (`os.path.realpath`) and symlink traversal prevention.

Status

SHEET 12 / 13

ÆON is actively maintained and dogfooded daily on the author's primary workstation. The core cognitive runtime, local inference, and memory stores are stable and verified.

The following items represent documented future development directions and are not yet verified in production.

Works today

uv monorepo (34 packages today, 28 at genesis) with 181 passing invariant tests.
Local Qwen2.5-1.5B inference via llama.cpp with sub-6s turn latency.
Append-only event log with replayable cognitive cycle traces.
Persistent property graph and episodic memory retrieval.
Desktop AT-SPI observer with zero file descriptor leaks.

Incomplete

Voice interaction (Phase M5) paused during architecture freeze; audio streaming pipeline requires final integration.
Reflection engine proposals currently require manual approval before learning gatekeeper commits them.
Android companion client in early prototype stage.

Remaining

Long-horizon evaluation over 30+ consecutive days of live interaction.
Automated consolidation of contradictory belief nodes in the knowledge graph.

I would change today

I would integrate grammar-constrained sampling at the C++ layer from day one rather than attempting prompt-based JSON schemas.
I would implement the ResourceLedger memory bounds earlier to prevent workspace growth explosions.

Duplex Audio Streaming Pipeline (Phase M5)
planned
Resuming integration of real-time voice perception and TTS synthesis using local whisper and piper models with interruption handling.
Autonomous Reflection Auto-Commit
research direction
Calibrating confidence thresholds to allow the learning gatekeeper to automatically commit high-confidence belief updates during idle ticks.
Lightweight Android Presence Client
planned
A mobile interface connecting over encrypted WebSockets to provide contextual awareness when away from the workstation.

Research Directions & Empirical Findings

Built a production-grade cognitive operating system (28 packages at genesis, 34 today) with local SLM inference, event sourcing, and empirical validation tooling.

Not yet builtAutonomous self-modification and continuous online weight adaptation remain theoretical research directions and are explicitly NOT implemented in production.

Directions under study

Dynamic Episodic Memory Compaction: Investigating lossless semantic summarization over multi-month event logs.
Dual-Process SLM/LLM Orchestration: Using local 1.5B models for instant reflexive perception while delegating complex abductive planning to large models.
Asynchronous Sleep/Reflection Cycles: Allowing the agent to process event histories during user downtime to refine belief graphs.

Possible contributions

Empirical evidence documenting the failure modes of sub-2B parameter models in agentic tool-use loops.
A reproducible framework for testing architectural invariants and memory corruption in long-running agent monorepos.

“Building a cognitive system taught me that persistent memory is not simply vector search, and long-running agents require failure recovery and observability far more than clever prompt engineering.”

Architecture Must Be Mechanically Enforced
Documentation, guidelines, and good intentions cannot prevent architectural drift. Only automated tests that inspect imports and fail CI can keep a codebase clean over months of development.
Beware of Vacuous Success
The most insidious bugs are not crashes, but silent empty successes where the system reports 100% completion without performing any actions. Always verify positive execution evidence.
Sub-2B Models Require Guardrails
Small local models have high schema validity but poor negative judgment. They must always be bounded by deterministic permission gates that intercept hallucinated tool invocations.
Freeze Early, Audit Ruthlessly
When core behavior feels unpredictable, freezing feature development and building comprehensive soak tests is the only way to transform an unstable prototype into a serious engineering system.

Source

SHEET 13 / 13

Substrate Architectural Invariant Linter

tests/test_substrate_architecture_invariants.py

Automated invariant test enforcing layered architecture and acyclic dependency graphs across every workspace package (28 at genesis, 34 today).

def test_package_dependencies_are_strictly_acyclic():
    """Verify that the 28-package dependency graph contains zero cycles."""
    graph = build_workspace_dependency_graph()
    cycles = list(networkx.simple_cycles(graph))
    assert not cycles, f"Circular dependencies detected: {cycles}"

def test_layer_boundaries_are_respected():
    """L1 packages must never import L2 or L3 packages."""
    for package in get_packages_by_layer("L1"):
        forbidden_imports = find_imports_from_layers(package, ["L2", "L3", "L4"])
        assert not forbidden_imports, f"Illegal upward dependency in {package}: {forbidden_imports}"

Vacuous Success Guard in Goal Verifier

packages/ashi-planning/src/verifier.py

Direct mitigation for the Vacuous Success Bug, ensuring no empty plan can claim successful execution.

def verify_plan_completion(plan: GoalPlan) -> VerificationResult:
    # PREVENT VACUOUS SUCCESS BUG: all([]) is True in Python
    if not plan.steps:
        return VerificationResult(
            status=PlanStatus.REJECTED,
            reason="Empty plan cannot be marked achieved without execution evidence."
        )
    
    for step in plan.steps:
        if not step.has_execution_evidence:
            return VerificationResult(
                status=PlanStatus.INCOMPLETE,
                reason=f"Step {step.id} lacks cryptographic execution evidence."
            )
            
    return VerificationResult(status=PlanStatus.ACHIEVED, evidence_count=len(plan.steps))

Prior art

SHEET 13 / 13

ÆON is the flagship system representing the culmination of architectural lessons from Leo and Vani, built with industrial-grade monorepo discipline and empirical testing.

Each system cites the one before it as prior art.

Cites Vani: Inherited zero-cloud philosophy, local-first runtime, and AST invariant enforcement.

Read the lab notes Write to Ashish

Abstract

SHEET 2 / 13

A 34-package personal AI operating system for a single human user.

Type: Personal Cognitive Operating System (Monorepo)
Started: 16 July 2026
Status: Active Research & Core Engineering
Language: Python 3.12 (uv Workspace)
Domain: Cognitive Architecture / Agent Runtimes / Local SLMs
Architecture: Layered Monorepo · Strict Dependency Invariants · Tick-Driven Runtime
Scale: 34 Packages · 282k Lines of Package Code · 6,458 Test Functions
Verification: 181 / 181 Architectural Invariant Tests Passed
Materials: Python 3.12uv MonorepoPostgreSQLSQLitellama-cpp-pythonQwen2.5-1.5B-InstructFastAPIPyTestAT-SPI Linux

Option

For

Against

Single large Python monolith

Fast initial development, single pyproject.toml, simple import paths.

Impossible to structurally prevent circular dependencies; code rot is inevitable over months.

Multiple independent git repositories

Strict isolation.

Extreme release orchestration overhead; version hell for a solo research project.

uv Workspace Monorepo with explicit package dependencies

Blazing fast builds, strict acyclic dependency enforcement, modular boundaries with local path links.

Requires precise dependency declarations in each package's pyproject.toml.

Option

For

Against

Ollama HTTP daemon

Simple REST API, easy model pulling.

Added 15-20s HTTP marshalling overhead, poor GPU memory retention, inability to handle SIGINT cancellations cleanly.

In-process llama-cpp-python C-bindings

Direct GPU tensor access, zero HTTP serialization, sub-second TTFT (time-to-first-token), reduced turn latency to 5.4s.

Process-level segfault risks on improper thread cancellation (discovered in ADR 006).

Option

For

Against

Developer discipline / manual checklist

Zero code changes.

Guaranteed to fail eventually when tests are run in a hurry.

Strict environment variable interlock and DB name inspection

Physically impossible to truncate tables unless the database name contains '_test' or 'ASHI_ALLOW_DESTRUCTIVE_TESTS=1' is set.

Tests fail with explicit error if run against default databases.

Option

For

Against

Proceed with voice feature implementation

Flashy demo capabilities, immediate visual/audio gratification.

Layers complex real-time audio on top of an unstable cognitive runtime; bugs become exponentially harder to diagnose.

Declare architecture freeze and execute rigorous empirical audits

Exposed the 3/10 behavioral audit score, vacuous success bug, and AT-SPI descriptor leaks before they infected new features.

Delayed user-facing voice demo by 3 weeks.

Metric

Before

After

Notes

Cognitive Turn Latency

32.8s seconds

5.4s seconds

Eliminated Ollama HTTP daemon overhead; bound directly to llama.cpp in-process.

Time to First Token (TTFT)

4.2s seconds

0.45s seconds

Cached prompt prefixes for static cognitive system prompts.

AT-SPI Perception Overhead

100% CPU (Crash) CPU usage

<0.3% CPU CPU usage

Singleton HostDesktopObserver replaced per-tick client spawning.

Component

Memory

CPU / latency

Notes

Core Cognitive Runtime

~240 MB

<2% idle CPU

Python runtime tick loop with in-memory attention buffers.

Local SLM (Qwen2.5-1.5B Q4_K_M)

1.2 GB VRAM

45 tokens/sec

Offloaded to dedicated GPU tensors via llama-cpp-python.

PostgreSQL Event Store

~180 MB

<1.2ms / event

Append-only tables indexed on correlation ID and timestamp.

def test_package_dependencies_are_strictly_acyclic(): """Verify that the 28-package dependency graph contains zero cycles.""" graph = build_workspace_dependency_graph() cycles = list(networkx.simple_cycles(graph)) assert not cycles, f"Circular dependencies detected: {cycles}" def test_layer_boundaries_are_respected(): """L1 packages must never import L2 or L3 packages.""" for package in get_packages_by_layer("L1"): forbidden_imports = find_imports_from_layers(package, ["L2", "L3", "L4"]) assert not forbidden_imports, f"Illegal upward dependency in {package}: {forbidden_imports}"

def verify_plan_completion(plan: GoalPlan) -> VerificationResult: # PREVENT VACUOUS SUCCESS BUG: all([]) is True in Python if not plan.steps: return VerificationResult( status=PlanStatus.REJECTED, reason="Empty plan cannot be marked achieved without execution evidence." ) for step in plan.steps: if not step.has_execution_evidence: return VerificationResult( status=PlanStatus.INCOMPLETE, reason=f"Step {step.id} lacks cryptographic execution evidence." ) return VerificationResult(status=PlanStatus.ACHIEVED, evidence_count=len(plan.steps))

ÆON

Why Stateless LLM Chatbots Fail as Persistent Companions

Where earlier approaches fall short

Working hypothesis

The Longitudinal Cognitive Cycle

Perception & Interpretation

Contextualization & Worldstate

Reasoning & Hypothesis Formulation

Planning & Permission Gating

Expression Modulation

Immutable Event Ledger & Reflection

Reference numerals

Execution Trace: Contextualized File Investigation

End-to-End Turn Latency: 5.4s

Open findings, on the record

Initial Behavioral Audit: 3 / 10Failed

Schema Validity vs Action: 92.7% / 18.2%Under audit

Reported, not re-measured

Test suite

Method

Why

Cost accepted

Why

Cost accepted

Why

Cost accepted

Why

Cost accepted

Failure

Root cause

First attempt

Fix that held

Lesson

Failure

Root cause

First attempt

Fix that held

Lesson

Failure

Root cause

First attempt

Fix that held

Lesson

Failure

Root cause

First attempt

Fix that held

Lesson

Hard problems

Why it is hard

First approach

What failed

Final approach

Where it stands

Why it is hard

First approach

What failed

Final approach

Where it stands

Why it is hard

First approach

What failed

Final approach

Where it stands

Monorepo Genesis & Invariant Formulation

Why

How

Result

Domain Substrate & Event Sourcing

Why

How

Result

Local SLM Integration (llama.cpp)

Why

How

Result

Empirical Audits & Architecture Freeze

Why

How

Result