AI-nhancement  /  AiMe

AiMe gives AI
continuity across time.

A cognitive operating layer that turns stateless models into systems that remember, track, and act over time.

Identity, memory, and behavior live in AiMe — not in the model.
8 Model Providers 3 Autonomous Agents Proactive — initiates turns Append-only evidence ledger
See the architecture →
System Class Cognitive OS Layer
Memory Model Persistent, session-spanning
LLM Calls / Turn 1 (invariant)
Retrieval Hybrid RRF
Portrait Layers 6
Intent Resolvers 4 (consensus)
Model-Agnostic Yes — 8 providers routed
Autonomous Agents Scheduler / Email / Desktop
Evidence Ledger Append-only, immutable
Proactive Behavior AiMe initiates turns
What Makes AiMe Different

Most AI resets. AiMe continues.

Most AI systems
Respond to prompts
Use retrieval only when asked
Forget between sessions
Require re-prompting to act
Reset identity on every conversation
AiMe
Maintains continuity across time
Tracks unresolved concerns across sessions
Recognizes standing intent without being told
Surfaces relevant context proactively
Preserves identity regardless of which model responds
This is not retrieval. This is ongoing cognition.
How It Works

A continuous cognitive loop.

AiMe operates as a persistent loop — not a single request/response cycle. Each turn updates the user model and carries context forward.

1
Capture Interactions are recorded as structured evidence — append-only, immutable
2
Update The system updates its understanding of the user after every turn
3
Track Concerns, patterns, and intent are maintained across sessions over time
4
Observe New input is evaluated against existing context — not just processed in isolation
5
Surface Relevant information is brought forward when it becomes meaningful — without being asked
6
Act Tools and actions are executed under governance — one LLM call per turn, invariant
Technical Pipeline — Every turn, the same path

Intent is classified deterministically before the LLM is invoked. The model is the last thing called, not the first.

User Input
PrefrontalCortex
prefrontal_cortex.py · v1.2.0
Deterministic lane selector. Slash-command overrides. Routes to the right cognitive engine before any generation.
CognitiveBridge
cognitive_bridge.py · v8.0.0
Execution spine. SBA-governed single-call dispatch. Tool results injected into meta. REQUEST loop removed.
MemoryCortex
Bond-indexed recall
Hippocampus RRF + Latent Episodes
Action Dispatcher
Web search, email,
calendar, scheduling, desktop
Info Snippet
Weather, news, finance,
calendar, live feed
SCAL
Standing interests, imprints,
watch rules, pattern tracker
Presence Vision
Webcam → Gemini Vision
Live person-count, context snap
Agent Surfaces
Scheduler events, email state,
proactive candidates
↓ all surfaces injected into prompt enrichment ↓
LanguageModel
language_model_plugin.py · v1.2.0
Single LLM call per turn. Provider routing. Full REGI prompt injection. Invariant: one call, no re-entry.
LanguageCortex
language_cortex_plugin.py · v9.1.0
Sole narrator. Sole voice output path. Guardian attestation required. No other plugin speaks to the user.
Text + Voice Output
Persistent Memory Architecture
Memory isn't a database.
It's a continuously maintained model of the user.
Context is not retrieved on demand — it's already active.
Conventional Model
Store
Retrieve ✕
Respond ✕
Memory as lookup → results
AiMe — Continuous Model
Enter Active Context
Relevant Memory Surfaces
Respond from Full Context
Recall is a consequence, not a command

AiMe maintains a persistent, evolving model of the user — tracking identity, open concerns, relationships, behavioral patterns, and active goals. It holds these across sessions, not just within a single conversation.

The system doesn't look up facts about you when asked. It operates from a continuously maintained model of who you are — and everything relevant surfaces naturally from that context.

This is why swapping the underlying model doesn't break identity. The user model lives in AiMe — not in the model. Whichever cognitive engine responds, it responds from within the same persistent context.

Relevance by importance, not recency. Past context is scored by significance. High-significance episodes are injected before inference when the current turn connects to established portrait content.

The Cognitive Portrait

A persistent model of the user. Six layers deep.

AiMe builds and maintains a structured, evolving representation of the user — persisted across sessions, updated after every turn. What they care about. What concerns remain open. What patterns repeat. What context is currently active.

L1
identity_anchors
Stable identity facts — who the user is at the core. Name, roles, defining characteristics. The invariant layer: observed across sessions and corroborated before anchoring.
L2
active_concerns
The Concern Stack. Open loops flagged as unresolved surface persistently in every response until closed — modeled on the Zeigarnik effect. Incomplete threads hold cognitive weight.
L3
relational_graph
The Bond map. Every person, project, and environment the user relates to — with salience, affective tone, open threads, and shared history weighted by significance.
L4
pattern_layer
Behavioral patterns derived from the evidence ledger. How the user communicates, decides, and engages — observable across turns, never assumed from a single instance.
L5
commitment_layer
Active commitments and goals. What the user has declared or demonstrated they are working toward — tracked as open arcs until resolution evidence appears.
L6
behavioral_fingerprint
The outermost layer. Synthesized behavioral signature — the stable character beneath the variance. How the user's overall presence reads across the full history of interaction.
Model Routing

Direct routing. Every specialist.

Intent is classified pre-LM by a governed specialist. The v4 spine runs three sequential specialist calls — each contract-bound to a single role, each with its own model selection. Four active providers with cloud-primary and local fallback on every call.

Call
Specialist
Role
1
Reasoning Specialist
Receives bundle + user_text. Emits ReasoningPacket: intent, assertions, world_facts, critique_findings
2
Expression Specialist
Receives user_text + ReasoningPacket. Emits ExpressionPacket: register, warmth, address, length, persona
3
Response Specialist
Receives ReasoningPacket + ExpressionPacket only. Never sees user_text. Emits natural language.

4 active providers: Gradient · Ollama · Gemini · xAI — cloud-primary with local fallback on every specialist. No single provider outage silences the system.

Autonomous Agents

Six sovereign agents.

Six independent agents — each with its own state, lifecycle, and operational scope. They surface to AiMe. They do not narrate. They never block the turn path.

📅
Scheduler Agent
scheduler_service · always on

ProactiveLoop with ambient triggers and DMN scheduling. Multi-turn event staging. Conflict detection. Proactive schedule-candidate pipeline from email and chat. Explicit user directives auto-commit — suggestion paths stay approval-gated. Return and morning brief generation.

✉️
Email Agent
email_service · port 8768

Significance-filtered inbox management. Multi-provider — Gmail OAuth and IMAP/SMTP. High-significance unread emails surface pre-LM as ★-marked entries. Behavioral feedback loop adjusts scores.

👁
Desktop Agent
desktop_service · port 8769

Vision-guided desktop automation. Plan → Confirm → Execute protocol. Live presence via Haar cascade (~200ms). Face-count delta triggers arrival and departure turns. 120s exit grace compensation. Fallback to snapshot DB when Thalamus unavailable.

📁
File Agent
file_service · sandboxed

Sovereign file agent with Windows-aware sandbox covering 11 threat vectors. Fingerprinted plan → confirm → execute with confirmation protocol. Atomic writes with rollback. Content-smuggling defense. 88 tests, 8 review rounds.

💻
Coder Agent
coder_service · multi-executor

Multi-executor coding orchestration. Coordinates code writer, test runner, linter, and file manager executors. Structured task decomposition with review discipline built into the execution loop.

SCAL — Standing Context Awareness Layer

All standing interests — imprints, watch rules, and portrait concerns — are indexed as 768-dim BGE vectors in Qdrant. Every observation is checked against this index. Matches surface through a 6-check companion filter (quiet hours → activity gate → rate limit → per-intent cooldown → semantic dedup → consent grade) before AiMe is interrupted. Pattern tracker escalates recurring signals through 4 levels with significance boosts.

Proactive Turn Initiation

AiMe initiates turns — not just responds. 5-tier absence grading determines re-engagement tone. Return recognition fires a Gemini snapshot on arrival. Third-party presence detected via live bbox-count delta: count increase triggers an arrival turn, count decrease (while others present) triggers a departure acknowledgment. Fresh-boot detection prevents spurious greetings on system restart.

Cognitive Personas

Same character. Different frame.

A swappable identity layer prepended to an immutable core operational contract. Switching personas changes voice and relationship stance — not the truth architecture or memory system beneath.

🏠
Home
/home

Personal companion mode. Relationship-first, continuity-aware. The Living Portrait of the user is the primary context frame. Warmth within the operational contract.

⚙️
Work
/work

Operational governor mode. System Portrait active. Role-keyed authority bounds, incident stack, governance commitments. The model responds to role, not identity.

Dual
/dual

Simultaneous home and work frames. Same cognitive substrate, two portrait subjects. Context-aware blend: one frame when only one is active, both when both are relevant.

System Status

Production components

Live operational status of AiMe's core subsystems as of May 2026.

LogicCore
Router + orchestrator. Plugin bus. Failure-only logging.
Stable v4.9
CognitiveBridge
Execution spine. SBA-governed single-call dispatch. REQUEST loop removed. ~600 lines cut, 6 contaminated files deleted.
Stable v8.0
LanguageCortex
Sole narrator. Voice + UI output. Guardian-attested.
Stable v9.1
MemoryCortex
UT/VAT split. RAM-first mirror. Embedding gateway.
Stable v4.5
Hippocampus
Meilisearch + Qdrant + RRF fusion. Read-only retrieval.
Stable v2.1
Evidence Ledger
Append-only SQLite. Identity persistence. Immutable.
Stable
Governance
Anomaly, drift, stability, health, policy, integrity checks.
Stable
Presence Vision
Webcam → Gemini Vision → context injection. Live-tunable.
Stable v1.4
CognitivePortrait
6-layer user model. CerebralCortex consolidation after every turn. Gravity scoring, concern tracking, self-model. Tier-1 identity physically isolated from runtime portrait pipeline.
Live
Intent Specialist
Governed pre-LM intent classification. Direct model routing. Cloud-primary with local fallback. Contract-bound to classification only.
Live
Voice Pipeline
Edge TTS primary. Piper fallback. Post-talk emotions.
Stable v2.4
Context Engine
Session-stateful rolling 768d topic vector. EMA blend.
Testing
Scheduler Agent
Sovereign scheduling daemon. Multi-turn event staging. Proactive schedule-candidate pipeline. Auto-commits explicit directives.
Stable
Email Agent
Sovereign email daemon. Multi-provider (Gmail + IMAP/SMTP). Significance scoring. Inbox surfaces injected pre-LM.
Stable
Desktop Agent
Sovereign desktop vision daemon. Live presence + face detection. Arrival and departure recognition via bbox delta.
Stable
SCAL
Standing Context Awareness Layer. Imprints, watch rules, pattern tracker. Qdrant semantic matching. Companion filter — 6-check gate.
Testing
Self-Reflection Layer
Behavioral accountability. Honesty gate. Deterministic trait derivation — no LLM in the SRL stack. Drift index. SHA256-hashed snapshots. 2,058 RIC observations recorded, 1,227 claims evaluated.
Live
Event Graph
Typed node/edge graph. Concern arcs, emails, persons. Thematic edges. O(1) keyword index. 117 tests. Immutable.
Stable
3D Avatar
Three.js + VRM. Azure viseme lip-sync. Procedural breathing + head drift. Emotion blending — text to face expression in real time.
Stable
Truth System
Internal + WordNet + Wikidata anchors. Reinforcement gate. Inference validator. Anchor rotation. Fail-open on embed unavailable.
Testing
Proactive Initiation
DMN-driven. AiMe initiates turns via /input. 5-tier absence grading. Return recognition. Third-party arrival/departure turns. Ambient triggers and morning brief via scheduler loop.
Live
SBA Spine
Self-Bounded Authority. Pre-LM state builder + authority engine. Post-LM compliance validator. Current mode: flag (logs would-pass/would-correct/would-drop; output unaltered).
Stable · flag mode
COGS — 15 Specialists
15 active governed specialists: Intent, Recall Search, Significance, Imprint, Value Extractor, Concerns, Resistance, System State, Expression, Response, DMN, Presence Vision, Ambient Extraction, Codebase Analysis, Plan Generation. Each contract-bound to a single role. No specialist has write authority over ledger, portrait, or identity surfaces.
Live
System Self-Awareness
S1–S6: surgical code reading, rule-classified health reporting, turn decision provenance, privacy-gated relational self-view. S1–S4 active. S5–S6 gated behind data thresholds. 235 tests.
S1–S4 Active
User Profile
Dedicated user_profile table. Three-tier trust by physical write isolation. Widget with modal editor + GET/PUT API. Portrait injection sources identity+relations from Tier 1/2 only.
Live
File Agent v2
Sovereign sandboxed file manipulation. 11-vector Windows-aware sandbox. Content-smuggling defense. Fingerprinted plan → confirm → execute. Atomic writes. 88 tests.
Flagged off
Not reactive. Proactive.
AiMe does not wait for prompts.

AiMe monitors relevance over time and surfaces information when it becomes meaningful. A concern mentioned days ago can reappear when conditions change. A pattern can be recognized without being explicitly asked. This is behavior driven by continuity — not input alone.

Concern Stack
Open concerns persist across sessions until explicitly resolved.
Standing Intent
Watch rules match every new observation — relevant signals surface without prompting.
AiMe Initiates Turns
Arrival, absence, and relevance signals trigger turns — no prompt required.
Proactive Schedule Pipeline
Calendar candidates surface from context, not commands — approval-gated before action.
What Continuity Looks Like

A system that remembers — without being asked.

Day 1
User mentions a long-term concern in passing.
Day 3
AiMe resurfaces the concern at the right moment — with full context.
Day 7
The concern resolves. AiMe records the outcome and adjusts the user model forward.
Not because it was asked.
Because it was still relevant.
Model-Agnostic Design

Models are interchangeable. Continuity is not.

AiMe sits above any underlying model. What the model provides is inference. Everything else — identity, memory, behavior — lives in AiMe.

AiMe owns
Identity — who the user is, persisted across sessions
Memory — append-only, significance-weighted, immutable
Behavior — concern tracking, proactive loop, governance
Routing — which model responds to which request
The model provides
Language generation — one call per turn, invariant
Interchangeable — 4 providers with direct model routing per specialist
Replaceable — swapping the model does not reset the user
The model changes. The user doesn't.
Continuity is preserved across model updates, provider switches, and capability upgrades — by design.
Early Access

Request access to AiMe.

AiMe is currently in private deployment. Tell us about your use case and we'll follow up directly.

Memory is not enough.
Continuity is the difference.
AiMe · AI Continuity Layer · AI-nhancement LLC