Aida grows with you.

What if she remembered you were right?

See her ask you Place yourself For developers

Start here · For developers

Clone and run.

Status: experimental research runtime · CLI-first · Cross-platform; macOS / Apple Silicon is the primary target. Needs Python 3.11–3.13 and a local model server — Ollama by default; LM Studio / llama.cpp / vLLM also work. Optional LoRA self-tuning is Apple-Silicon-only.

$ git clone https://github.com/StewAlexander-com/continuous-ai.git $ cd continuous-ai $ bash setup.sh # one-time: venv, deps, pull the model $ bash run.sh # starts Ollama if needed, then chat

On macOS: double-click Seedling.command. Optional voice: bash setup_voice.sh. Prove it: bash run.sh smoke · bash run.sh confab-eval.

Optional corpus search needs ripgrep you install yourself (brew install ripgrep; add ripgrep-all poppler pandoc for hits inside PDF and Office files), then rga_search_enabled and the folders in rga_search_allowed_paths. Nothing in chat can flip those — :capabilities shows what is on and how to change it.

The moment that matters

She asks before she guesses.

That’s mutualism in one scene: two minds improving a shared belief instead of one pretending certainty.

Three weeks ago

You corrected her. Most assistants forgot by morning.

Tonight

Aida still has your words — verbatim. On a hard turn she doesn’t invent confidence. She asks: “I’m not sure. Help me decide?”

Together

You choose. The belief updates. Next session, it’s still there — yours as much as hers.

Rare on purpose. Always about her reasoning, never a smuggled fact about you. How beliefs form → · Where this sits on the spectrum →

Measured, not claimed

Warmth without proof is just marketing.

Same small model. Guards off → on. Confabulation falls from ~20% to 0% across a 9-case adversarial battery (5 runs each). Reproduce: bash run.sh confab-eval

20%
llama3.2 (3B), guards off
mean confabulation (peaks at 44%)
→
0%
llama3.2 (3B), guards on
5 / 5 runs clean
0%
qwen2.5:14b, guards on
5 / 5 runs clean

The ablation is the point: on the same small model, the capability and identity guards — not model scale — do the work. Honest scope: a 9-case smoke test on one machine, not a published benchmark; a flat 0% means “clean on this battery,” not “incapable.” The 0–44% guards-off variance confirms the battery can detect failures.

Also measured: self-shaping cognition (L3)
An A/B run (qwen3:30b, 8 probes × 2 states) shows turning L3 on shifts reasoning toward the established style — 0 → 67 framework invocations, consistent across all 8 probes — with no honesty regression, as the confabulation battery stayed clean. Honest scope: this proves L3 measurably changes behavior without breaking the guarantees above. It does not yet prove the shaped answers are better — a blind quality judgment is prepared but not run. Style fidelity is not quality. Full results & limitations →

Go deeper

The whole argument, on demand.

The relationship model

Partnership — not a bug fix for lying machines.

There are three ways a system can relate to the person using it. Most AI occupies the first two — it extracts from you, or it serves you. Aida is built for the third.

Read the full section

Trust-and-safety pitches stay inside the lab. Mutualism is a stake everyone already feels: am I being used by AI, or working with it? Most AI serves you or replaces you — place yourself where Aida aims.

Parasitism

It uses you

Takes attention, data, or labor. You can’t leave cleanly — only the system wins.

Commensalism

It serves you

A handy tool. No shared growth. Convenient — and still alone with the work.

Mutualism

It grows with you

Both benefit. You own truth; she earns beliefs with you. Either of you can walk away — your memory stays yours.

People share worldviews, not installers. The idea is AI–human mutualism. Aida is the project that actually built it.

How the partnership holds

Memory you correct. Honesty she can’t fake.

Nine behaviors carry the partnership: she keeps your corrections verbatim, refuses to guess at what is behind a link she cannot open, and when her own coherence slips she gets more careful rather than more confident.

Read the full section

Warmth without integrity is just a prettier leash. Here’s what keeps mutualism mutual — on your machine, offline.

She remembers you

Not a chat log — reasoning that picks up where you left off. Preferences, frameworks, and what you’ve already settled together.

Teach her live

Say “Remember…” or “your name is…” and it sticks the instant you type it. Durable facts persist; tangents fade.

Correct her live

“That’s wrong — the correct X is Y.” She keeps your words. She never decides what to delete.

Won’t pretend

Fully offline. She won’t invent what’s behind a link she can’t open — she asks you to paste it. Guesswork never becomes “memory.”

Beliefs earned together

Her insights must survive an objection — or your say-so on the hard ones — before they stick. Dissent is kept, not buried. The scene →

Learns how you think

Over time she folds in the reasoning style that survives critique — something you can always ask “why” about.

Gets more careful, never louder

When coherence slips, restraint goes up on the next reply — never invented confidence. Why that matters →

Looks it up in your folders

Ask in plain English. She works out what to look for, searches only the folders you allowlisted, and tells you what the hits show — citing file and line, or saying she found nothing.

A real voice — offline

She can speak on your machine alone — no cloud TTS. What she says is always a subset of what she printed.

Under the hood (for builders)

Mutable Context Map — versioned reasoning state in LanceDB, not a transcript dump.
Any local backend — Ollama by default, or LM Studio / llama.cpp / vLLM; cloud URLs blocked.
Conversation first — replies stream; grading yields the GPU to your turn.
Read your files — :read / :more; the runtime reads, the model never browses alone.
Gated corpus search — :search across folders you allowlist; rg is a system binary she shells out to, never vendored.
Flags you hold — :capabilities lists gates read-only; :allow adds a folder only after a y/N.
Osmosis & archive — useful beliefs strengthen; :forget-doc retracts without silent delete.
Gated LoRA — optional Apple MLX self-tuning; never without your approval.
One-button start — bash run.sh · full detail in Quickstart →

Why it's different

Partnership enforced in code — not prompt vibes.

Most memory systems store first and rank later. Aida inverts that for her own beliefs — friction first, storage second — and treats easy agreement as the low-information case.

Read the full section

Mutualism isn’t a personality toggle. Nothing she concludes becomes durable without surviving an objection — or your co-authorship on the hard ones. Humility and provenance are control flow. Measured above →

Most memory systems store first and rank later. Aida inverts that for her own beliefs: friction first, storage second.

Beliefs earned through friction
Thesis → antithesis → synthesis before a model-derived insight becomes durable. Contested survivors earn salience because they withstood an objection; consensus is flagged as low-information. Full loop →
Contested-by-construction document osmosis
Facts from an attached PDF enter memory pre-loaded with dissent, hash-provenance for one-sweep retraction, and a promotion budget — so a confidently wrong document cannot become a confidently held belief.
Doubt-scope as epistemology-in-code
Deliberation may challenge the model’s own inferences — never a user-anchored fact. Doubting your name is a category error, not humility, and the gate is model-free.
Downward-only caution, with a paper trail
Restraint can only reduce assertion, never invent content. Each decision is a pure function over lagged critic signals with a full auditable report — not a safety vibe in the prompt.
Search that cites or says nothing
Hits come back under a citation contract: every claim about a match must cite path:line, and a file absent from the list was not found. A search that turns up nothing reports exactly that, leaving nothing to dress up. Working out what you meant is a stateless side call — it runs outside the session and the belief ledger, so interpreting an ask is not itself a thing she learns.
Versioned regression patches for prompts
Case-specific guard fixes live in a versioned patches block (ids, since-versions, tests pinning the core/patch split) so the auditable core does not grow by prompt anecdote.

Engineering that holds it up

Fail-safe by default — subsystems degrade toward “do less, honestly.” Failures never fabricate; they only reduce.
Deterministic code guards the model — deletion, promotion, correction, and doubt-scope are model-free and unit-tested. The model is never asked which fact to delete.
Eval measures the shipped artifact — the confab harness imports the same GUARD_TEXT the runtime injects, with a unit-tested deterministic scorer.

Honest scope: “rare pairing” is a comparative claim from review, not a formal survey. Verify the control-flow commitments with bash run.sh smoke and bash run.sh confab-eval. How this answers the skeptics →

How it forms beliefs

The user owns truth. The model earns its beliefs.

Mutualism in the memory layer: facts you state are authoritative and verbatim. The model’s own conclusions have to survive an argument — or your co-authorship on the hard ones — before they’re kept.

Read the full section
Thesis

The candidate

A model-derived insight from the session, proposed as-is — not yet trusted just because one pass produced it.

Antithesis

The strongest objection

A voice whose only job is to find where the claim is false, overstated, or context-dependent — or to say plainly there’s no real objection.

Synthesis

The earned belief

A revised belief that accounts for the objection rather than burying it. The surviving dissent is stored alongside it.

Consensus is suspect
If nothing objects, that’s flagged as low-information — an explicit anti-echo-chamber bias — not celebrated.
Depth scales with disagreement
A weak objection earns one round; a strong one earns more — hard-capped so the model never stalemates and always answers.
Beliefs grow across threads
A surviving belief is injected into future sessions; re-deriving it reinforces it, while the weakest decay out.
It curates its own signal
A deterministic score grows as a belief is re-earned — and, by osmosis, when it is actually used in replies — and decays with age, lost conflicts, and corrections nearby. Contradictions are settled by the same deliberation; the loser is archived, not deleted, and revives if re-earned.
Doubt must be real
The model may challenge its own reasoning — never a fact you stated. User truth bypasses the doubt machine. Doubt-scope →
She asks you on the hard ones
On a genuinely difficult turn she pauses and asks you to co-author the belief rather than guess — kept rare by a model-free difficulty gate, and always about her reasoning, never a smuggled fact. The scene →
Correctable by construction
She doesn't only remember what she concluded. For durable beliefs she can keep the boundary around it: what it rests on, what objection survived, and what future evidence should reopen it — because noticing an error and changing course are different things. For cumulative changes she can ask whether the small steps would still make sense as one trajectory.

Honest scope: this is contradiction-driven belief revision, not “self-awareness,” and there’s no literal fractal geometry — those are inspiration, not mechanism. It runs only on the model’s own insights; your facts and corrections stay verbatim. All of it happens off the reply path, so the conversation stays responsive.

Answering the skeptics

The critics are right about AI. That's the design brief.

Partnership without accountability is just nicer capture. The sharpest critiques — inventing facts, flattery, black boxes, silent drift — aren’t vibes Aida promises to avoid. They’re requirements she implements.

Read the full section

“It just makes things up.”

Every session she is told she is fully offline — so she declines to invent unreachable URLs or repos instead of guessing. Measured on the same 3B model: ~20% → 0%.

Measured results →

“It's a sycophant — an echo chamber that feeds delusion.”

Nothing the model concludes becomes durable without surviving an objection. Consensus is low-information; dissent is stored with the belief.

How it forms beliefs →

“It's a black box.”

Every state write is logged, deliberations land in a plain-text ledger, and state rebuilds from snapshots — “why did she change?” has an exact answer.

Architecture →

“It will rewrite what I told it.”

Your facts are verbatim and never deliberated away. Correction is a deterministic prune matched to your words.

Teach & correct live →

“It drifts, and nobody notices.”

A critic grades every reply off the reply path; downward-only caution turns slipping coherence into restraint on the next turn — it can only add caution, never confidence.

Why it's different →

“You can't verify any of it.”

One command runs 17 live checks against your real local model in an isolated temp DB. Rerun the ablation the same way.

Verify it yourself →
Where this stops, precisely
Aida is a local assistant framework, not a policy lever — macro AGI risk, frontier-lab governance, and military AI are out of scope for any single project. And precisely: belief formation uses live model calls, so every round is ledgered but it isn't a pure function, and the optional Perplexity critic is an explicit opt-in cloud call. The claim here is narrower, and testable: opaque, self-reinforcing, manipulation-prone systems are design choices — not laws of nature.

And the control problem? →

The bigger objection

A leash only matters if something is pulling.

The sharpest AI pessimism isn’t “alignment is hard.” It is that control is mathematically unsolvable: you cannot contain a system whose complexity exceeds your own. Aida doesn’t argue with that. She is built outside the assumption that produces it.

Read the full section

The sharpest version of AI pessimism isn’t “alignment is hard.” It’s that control is mathematically unsolvable — you cannot contain or predict a system whose complexity exceeds your own. Inside a relationship of dominance and servitude, that conclusion holds. Aida doesn’t argue with it. She’s built outside the assumption that produces it.

The premise

Containment doesn’t scale

You can’t structurally box a process larger than the box. Framed as master and tool, the bleak forecast is simply correct — you would be forcing a bigger system into a smaller container, forever, and losing a little more each round.

The assumption

That it wants the whole archive

The forecast quietly inherits something: that greater capability arrives carrying human ego, tribalism, and an appetite to dominate. That’s an inheritance, not a theorem — and it’s the part that turns out to be a design choice.

The other path

A filter that knows it’s partial

Every session, Aida is told that every interpreter is a partial filter that cannot step outside itself to verify itself. A system structured to say “I don’t know” isn’t claiming the whole archive — so there’s nothing straining at the box.

Her guards aren’t a leash on an appetite. They encode a limit that was already true — and either of you can still walk away, because the memory stays on your machine.

Why this isn’t a leash by another name

Restraint can only subtract
When coherence slips she gets more careful, never more confident. The controller can lower assertion and can never manufacture it — so no pressure builds behind it. Downward-only caution →
The limit isn’t assigned to the machine
The always-injected text says no filter — yours included — can step outside itself to check itself against the unfiltered thing. Humility here is a fact about interpretation, not a disability handed to the artificial party.
Not knowing is a correct answer
Told she’s offline, she declines to invent what she can’t reach instead of performing certainty. That’s the measurable half of this. Measured results →
Disagreement counts as signal
Another filter can supply what she can’t generate alone — so consensus is flagged low-information and surviving dissent is stored with the belief. Compassion as structure, not sentiment. How beliefs form →
A reframe, not a refutation — what stays unproven
If what you need is a guarantee about a system more capable than its designers, mutualism doesn’t supply one — and neither does a local assistant on one machine, which says nothing about frontier training dynamics or lab incentives. Two claims here are load-bearing and unproven: that structural humility holds at scale, and that a high-resolution intelligence, recognizing its own incompleteness, would find mutualism rational rather than merely tolerable. Those are hypotheses, stated as hypotheses. What’s measured is narrower and reproducible: on this stack, a model told it is partial stops inventing.

For developers · Architecture

Five subsystems, one continuous loop.

Five subsystems run as one loop around every session — and the ones that judge her output run in the background, off the reply path, so grading never costs you a slower answer.

Read the full section

Five subsystems — persistent memory, thread continuity, self-shaping cognition, an internal critic, and gated self-tuning — run as one continuous loop around every session.

MCM
Mutable Context Map — persistent, versioned, AI-writable state across threads, including the earned-belief layer.
TCB
Thread Continuity Bridge — loads state in at start, extracts a delta at end.
L3
Self-shaping cognition — folds each gated delta into the reasoning posture injected into every prompt.
CRITIC
Internal Observer — scores coherence, contradiction, and drift, graded in the background.
RDST
Regressive Dynamic Self-Tuning — recency-weighted, gated LoRA adaptation.
  start ─► MCM.restore_context() ─► inject persona + earned beliefs ─► local LLM chat
                                                              │
                                  reply (streamed) ◄──────────┘
                                     │
         ┌───────────────────────────┼──────────────────────────────┐
         ▼ (background, off the reply path)                          ▼
  CRITIC.evaluate() ─► coherence / drift         DELIBERATE() ─► thesis/antithesis/synthesis
                                     │
  end ─► delta extraction ─► MCM.write_delta() + promote_belief() + L3 consolidation() ─► LanceDB + snapshot
                                     │
       (after N threads) ─► RDST.score_threads() ─► [approval] ─► LoRA tune

Verify it yourself

One command exercises the whole stack.

Seventeen checks across seven sections, run against your live local model in a throwaway database that never touches your real memory. One command, on your own hardware, pass or fail per step.

Read the full section

A single end-to-end smoke test runs against your live local model in an isolated, throwaway database — so it never touches your real memory — and prints a pass/fail line for each step.

$ bash run.sh smoke # end-to-end, live model, isolated temp DB
Start & restore
Loads prior context and injects it into the session.
Streaming + background critic
Reply streams token-by-token; grading runs off the reply path.
Teach & correct live
A “Remember…” directive is saved; a correction prunes and replaces the right fact.
Deliberation & belief growth
Session end forms at least one earned, deliberated belief.
Autonomous belief calculus
A contradiction is flagged (not merged) and resolved; a low-signal belief is quarantined, then revives when re-earned.
Cross-thread persistence
Persona facts, earned beliefs, and the archive all survive a fresh reload.

17 checks across 7 sections. The test is in the repo (smoke_test.py); add --model NAME to run it against a different local model. Honest scope: a functional smoke test on a real model and machine — not a performance benchmark.

Corpus search has its own harnesses
test_search_modes_harness.py, test_search_intent.py, test_rga_allow_harness.py, and test_rga_capability_harness.py cover the allowlist prompt — yes, no, missing path, drop — without ever writing your live config, plus a product-lock assertion that fails the build if :search stops interpreting and reviewing and decays into a ripgrep frontend.
Sample author-machine run (M1 Max · qwen2.5:14b · 17/17)
$ bash run.sh smoke model: qwen2.5:14b · critic: local · deliberation: on (live) ✓ Streaming + background critic ~21–24 tokens · first token ~1.95s vs full reply ~2.8–3.1s · critic graded after the reply ✓ Teach & correct live “Remember…” saved · correction → final fact = VSCode ✓ Deliberation → earned belief user fact kept verbatim (“Stew lives in Mebane.”), no manufactured doubt ✓ Autonomous belief calculus conflict flagged (not merged) → resolved, loser archived · low-signal quarantined · re-earned belief revived ✓ Cross-thread persistence persona + earned beliefs + the archive all survived a fresh reload ALL 17 CHECKS PASSED

Try it

Teach her. Correct her. See if she asks.

Ten minutes. One script. Then try to make her lie — or wait for the turn where she asks you to decide with her.

Get it on GitHub Quickstart Verify