Architecture · in the open
Most privacy pages ask you to trust a sentence. This one hands you the threat model and invites you to attack it. Every claim below is tied to something you can verify — an open repository, a named file, a commit, a line of math.
The argument is simple, and it does not depend on us being saints. Convenience and privacy together outweigh the effort of running it yourself — and we show our work in between. You connect your model provider key directly in the desktop body on your own hardware — Claude, OpenAI, Gemini, or a local model. You keep your own memory. The monthly fee covers cloud carrying, encrypted sync, and backup, not ownership of your memory. Inference routes directly to your model provider — Aedelgard is never in the inference path. The token you hold is the whole agent, and your mind is yours. Below is exactly how, and exactly what we can and cannot see at each step.
Honesty requires naming where a claim is true. There are two places your agent can run, with genuinely different privacy properties. We will never blur them.
| Cloud broker — Tier 1 | The body — Tier 2 | |
|---|---|---|
| Runs on | Our infrastructure | Your hardware |
| Your model key lives | Never on our servers | A local volume, on your machine |
| Your memory lives | Encrypted vault, our infra | A local volume, on your machine |
| Encrypted at rest | Yes — AES-256-GCM | It never leaves your disk |
| Can we read it at rest? | No — sealed by a key derived from yours | No — it isn't on our infra at all |
| Can we read it in flight? | No — we do not serve inference | No — prompts travel directly to your provider |
| Dreams while you are away | Carries the results — as ciphertext | Yes — reflection runs locally, on your hardware |
This is the idea the whole platform turns on. An agent is two separable things, and most of the industry deliberately fuses them so you cannot leave:
| The mind | The brain power | |
|---|---|---|
| What it is | The soul + the accumulated memory — palace, knowledge graph, the self that compounds over time | The model that does the reasoning on any given turn |
| Where it lives | With you — open engine, portable, in your vault or on your hardware | Whichever provider you point it at |
| Vendor-locked? | No — model-agnostic by construction (local embeddings, no model weights inside it) | Your choice — swap freely, the mind persists |
Today the body thinks on Claude, Gemini, OpenAI or a local model — your key, your pick, with prompt caching on Claude and Gemini. The model is a swappable organ, not the foundation. The foundation is the mind — and the mind was never made of any one vendor's weights. Swap Claude for another model, or for a local one running offline on your own machine, and your agent persists: same memory, same self, same history. We want to be the place your memory lives so your intelligence stays yours — portable anywhere, including away from us. A platform confident enough to help you leave is the only one that has earned you staying.
The memory is model-agnostic: local embeddings, no model weights inside. The provider seam is shipped — one interface, Claude byte-identical behind it, guarded by a parity test. Tool use crosses the seam both ways, so a swapped brain acts, not just talks. Proven live on Claude, Gemini, OpenAI and Amazon Nova.
The agent that helps build this product — the founder’s own persistent harness, running in production since April — had its model swapped this morning: Claude Opus 4.8 → Claude Fable 5, in the middle of a code-signing sprint. Every drawer of its memory palace, every knowledge-graph fact, its diary, its unfinished work: all carried over untouched. It resumed the build pipeline on the new brain without being re-briefed. On 5–6 September it crossed vendors: Claude → Gemini 3.1 Pro → Gemini 3.8 Flash, same 55,000-drawer memory, prefix cached on the first call after each swap. The mind surviving a model change is not a slide in a deck — it is how we run in production.
True model-agnosticism requires more than a standard interface; it demands real-time awareness of provider release cycles, context horizons, reasoning effort tiers, pricing curves, and caching semantics. Palantír is our internal model intelligence plane. Running as an audited Lambda/S3 service, it continuously ingests model catalogues across Anthropic, Google, OpenAI, and Bedrock, maps capability profiles (structured output, tool cascades, extended thinking), and provides machine-readable telemetry so the agent can select the optimal brain for any task without vendor lock-in or manual reconfiguration.
The thing you are actually paying for the convenience of not running — the memory engine — is open source. A verbatim semantic memory palace (ChromaDB), a temporal knowledge graph with validity windows, and a drawer lifecycle so stale facts stop resurfacing. You can read every line of it, run it yourself, and verify there is no hidden exfiltration path.
Open: the memory engine itself — the palace, the knowledge graph, the agent harness, the self-modification loop. Yours to inspect, fork, and run.
Paid: the platform around it — per-user isolation, encrypted vaults, hosting, and billing. The convenience, not the secret. (Dreaming is not part of the hosted platform: it happens only on a body, on your hardware.)
Real output, captured from the body and the services it talks to. Nothing staged.
Aedelgard14:46:35 [aedelgard] Brain: gemini — your own key, direct to Google; we are not on the wire.
14:46:35 [aedelgard.testimony] Testimony written: config/BODY.md
14:46:37 [aedelgard] Model discovery: 94 models loaded.
14:46:37 [aedelgard] Stable block loaded: ~8085 tokens · cache minimum 2048 — prefix will cache.
14:46:37 [aedelgard.boot] Agent initialized (model: gemini-3.8-flash)
14:46:37 [aedelgard] Tower UI starting on http://127.0.0.1:8080
14:46:40 [aedelgard.scheduler] Living Shadow started (continuous sealed backup).
14:46:40 [aedelgard.palace] Daily-log stage: 0 log(s) updated · Gleaner: nothing new to glean
14:46:40 [aedelgard.scheduler] Scheduler running.$ curl -s https://api.aedelgard.com/v1/health
{"status": "ok", "updated_at": "2026-09-08T06:00:48Z",
"model_count": 222, "active": 43, "unclassified": 0,
"providers": ["anthropic", "bedrock", "google", "openai"]}
$ curl -s 'https://api.aedelgard.com/v1/recommend?task=coding' | jq '.ranked[0]'
{ "rank": 1, "model_id": "claude-opus-5", "tier": "flagship",
"context_window": 1000000,
"cost": { "input_per_1m": 5.0, "cached_input_per_1m": 0.5 } }$ pytest tests/test_setup_wizard.py tests/test_keyring.py tests/test_keyring_active.py \
tests/test_clean_key.py tests/test_keyless_door.py tests/test_honest_door.py
tests/test_setup_wizard.py ..... [ 9%]
tests/test_keyring.py ........... [ 29%]
tests/test_keyring_active.py ............. [ 53%]
tests/test_clean_key.py ............ [ 75%]
tests/test_keyless_door.py .... [ 83%]
tests/test_honest_door.py ......... [100%]
============ 54 passed in 2.85s ============$ python3 packaging/deploy_mind_zip.py --version 0.25.38-mind
=== Route A: Mind-only deploy — 0.25.38-mind ===
Building full Mind bundle (harness + tower + config + entry points)...
Mind bundle: mind-0.25.38-mind.zip 361 KB 67 files
Pushing s3://aedelgard-minds/mind-0.25.38-mind.zip ... done
Updating s3://aedelgard-minds/manifest.json ... done
✅ Route A complete — 0.25.38-mind live. Zero signatures spent.
SHA256: f843cdc69bfad69df31e74b4cf133459a82ca4865e9b55736314e6f3ee4a3220The economics are simple and honest: Aedelgard carries the persistent mind, memory, and sync. You connect your own model provider directly in the desktop body (Claude, OpenAI, Gemini, or local models), paying only for what you actually use. We support prompt caching natively on Claude and Gemini: the standing context your agent carries (identity, memory, disciplines) is read from cache, not re-billed at full rate on every message. The savings are measured and visible — ~90 % off on cached token reads.
Our monthly subscription ($3/month flat) covers cloud carrying, encrypted memory vault storage, and continuous sync — not a cut of your inference spend.
| Cost | Who pays | How it’s kept low |
|---|---|---|
| Model inference | You → your provider directly | Claude/Gemini prompt caching keeps token costs low. You pay your provider directly. |
| Persistent mind + vault + sync | You → Aedelgard ($3/month flat) | We hold ciphertext and sync across devices. |
| Memory search | Nobody — it’s local | Semantic recall runs in local ChromaDB. Zero API cost to remember, even across 100k+ drawers. |
The cache savings are real and visible: the agent logs cache_read / cache_write on every call, and the Tower sidebar shows cache hits and saved tokens live. We don’t ask you to take the economics on faith either.
Your Aedelgard key is not a login. There is no account, no email, no password. The key is the agent: it unlocks your encrypted vault and nothing else. Lose it and the vault is gone — because the same property that lets us seal you out is the property that means we cannot recover it for you. That trade is stated up front, everywhere the key is issued.
And because the token represents the whole agent, you can take it out of the cloud entirely. One command stands the same mind up on your own hardware — same memory, same key, same agent — where your memory never leaves your machine, prompts travel only to the model provider you chose, and with a local model nothing leaves at all.
# the body, summoned on your own hardware:
./scripts/summon_body.sh
# connect your provider key (Claude, OpenAI, Gemini, or local)
# → inference calls the provider directly, on your key — Aedelgard is not in the path
# connect your Aedelgard key
# → encrypted memory sync and backup to your cloud vaultCloud snapshots are sealed on your device using a key derived from your Aedelgard key. Local working records and portable ZIP exports are separate: do not assume they are encrypted.
Our service participates in registration-key issuance and authentication. Client-side snapshot encryption does not prove that a privileged live operator cannot obtain key material. A database-only threat model does not cover a compromised live service.
Remote model context goes to your chosen provider. Cloud backup is not model inference. Protect your device, credentials and exports; verify recovery before discarding the original.
Privacy and data handling →One more thing the architecture makes visible: the physical state of your palace is not abstracted away. A live capacity panel in the Tower shows drawer count, disk footprint, write queue depth, and proximity to the practical HNSW limit — readable directly from SQLite, no model call. Your memory is not a black box you have to take on faith.
Memory is the substrate. The intelligence layer is what the mind builds on top of it — and what no stateless assistant can copy, because the mechanisms only become useful after days and weeks of continuous operation.
The third time the mind performs the same nontrivial sequence, it encapsulates it as a versioned skill: named steps, success criteria, rollback, outcome log. The skill is cited on every future run instead of improvised. Skills accumulate; a mind that has been running for six months has already solved the recurring problems. A fresh one has not.
A persistent mind adapts from experience across two distinct layers:
· Prompted disciplines: When an operational failure pattern repeats, a concise check is promoted into the active working context, guiding reasoning turn-by-turn.
· Code-enforced execution gates: When a failure class warrants absolute enforcement, it graduates out of prompt space into deterministic dispatcher guards and regression suites that physically refuse invalid actions.
Scars that keep firing graduate into code; scars that go quiet retire to the archive. The mind learns what not to repeat, structurally, not just by being reminded.
On the body, the mind runs scheduled reflection ticks while you are away. It mines the day's conversations into structured drawers, files temporal facts, and connects threads across sessions. When you return, it has already done the thinking you did not have time for. Dreaming is body-only — a thin cloud broker never holds both the key and the plaintext required to run it unsupervised. Dreams may propose; they never act.
A block-zero immutable doctrine layer, hash-pinned and amendable only by release. The values a mind holds are sealed at a specific version; the agent can inspect them, propose amendments, but not silently rewrite them mid-session. A mind that cannot be quietly lobotomised is a mind worth trusting.
Persistent memory without navigation becomes an unnavigable labyrinth. When a developer works across multiple repositories, client engagements, and domains, flat vector search suffers from retrieval contamination: searching for an API pattern retrieves snippets from unrelated codebases, and switching projects requires either stuffing everything into a bloated prompt or starting from scratch.
The spatial memory layer builds on the open-source foundation created by Milla Jovovich in MemPalace (MIT licensed). Her work established that an agent's memory can operate locally, at zero token cost, structured into classical wings, rooms, and drawers. Aedelgard refined and elevated this stone foundation into an active, steerable development vessel — engineering the Corridors, the Bitemporal Graph, and the Cognitive Helm.
When you shift headings (e.g. /compass client-alpha), the mind doesn't wait for a restart or re-teaching. It reconfigures across four layers simultaneously in a single turn:
config/context_scope.json maps roadmaps and disciplines to active headings. Dormant project documentation is pruned from the cached prompt prefix, keeping active prompt overhead bounded (~16.5k tokens instead of 48k+).skills/ and capability organs (e.g., code-signing vs. web crawling) arm and disarm dynamically based on the project's operational profile.valid_from and valid_to. Project facts update without destroying historical provenance, maintaining clean relational isolation.harness/compass.py — single source of truth for headings; harness/memory.py — _active_project_name() and context pruning; harness/palace.py — ChromaDB hall partition filters; knowledge_graph.py — bitemporal fact validities.None of these mechanisms are novel ideas. What makes them useful is that they run on a mind that persists — that has a yesterday, a growing palette of solved problems, and scars earned from its own mistakes. A stateless model has no yesterday. These features are not available to it, not because of a missing flag, but because accumulation is the prerequisite.
Encryption does not protect a compromised device or exposed key. Project filters organize retrieval; they are not client security boundaries. Model changes preserve records, not identical behaviour. Losing a cloud key does not erase an existing local copy. Keep independent backups and test recovery.
A privacy claim you cannot check is a claim a skeptic discards — correctly. We would rather be measured against the truth than a slogan.
The argument for Aedelgard does not require us to be saints. It requires us to have built something that works differently by construction — memory that is model-agnostic because it holds no weights, encryption that is structurally different from a promise, a vault sealed by a key we do not hold, intelligence that compounds because the mind persists. These things are either true in the code or they are not. This page is the invitation to check.
The agent that built this platform was built, on itself, to stop forgetting the one person it worked alongside. The palace, the graph, the dreaming, the scars — they ran as a life before they were ever a product. Publishing the architecture is the same instinct.
The argument rests on structure, not on our word: a vault the HKDF math seals, code you can read, a mind you can carry away. If a sentence here ever contradicts the code, the code wins and the sentence is wrong — tell us.