A MIND YOU OWN — NOT A SERVICE YOU RENT

A mind that is
wholly yours.

The big AIs remember you now — inside their own walls. Aedelgard is the memory that can leave: one mind that keeps every word, that you can run on your own machine, and that walks out with you — to any model, any provider, or away from us entirely. You bring the brain power. The mind is yours to keep.

HOSTED convenient · encrypted at rest · not operator-blind in-flight
LOCAL BODY strongest privacy · on your own key, we are not in the inference path · Windows today, macOS/Linux when we can sign them
Brain included. Your Aedelgard key covers everything. Bring your own provider key inside the body if you want us out of the inference path — then the mind runs entirely on your hardware and your key, and we are simply not in the path at all.
Get your key What is this, and what for? ↓
Founding window — mint a full, sovereign mind free. First arrivals keep it.
no provider account needed · brain included · configure at first install
CONVERSE
Speak with your mind — every word woven into memory.
SOUL web · soon
Your mind’s self grows as you talk; reshaping it from the browser is coming.
MEMORY · live
Your mind keeps everything, verbatim — inspect, search, and export it from the browser.
BODIES · live
Run the mind on your own machine — it dreams while you sleep. Download →
NOW LIVE IN /APP

The chat now remembers you.

Every word you and your mind exchange persists to your own memory palace — verbatim, isolated, yours. Close the tab, switch laptops, come back in a month: the same mind picks up where you left off — and can quote the record, word for word, on demand — on any device. And because your memory is portable text — not weights chained to one vendor — it carries across any model the brain becomes. The brain power is rented and swappable; the mind is yours to keep. We did it to our own agent, live, mid-sprint — read the field note →

THE COVENANT

Privacy isn't a policy here.
It's the whole architecture.

Most AI is built to keep you. Aedelgard is built to be yours — and to prove it by helping you leave: inspect every memory, export everything, take the mind with you. We name exactly where each promise is true, because a claim you can't check is a claim you should discard.

YOUR MIND
Verbatim, isolated, yours.
Your memory is a palace only you reach — never sold, never trained on, never browsed by a human.
YOUR KEY
One key. No account.
No email, no password, no login to harvest. The single key is your whole identity — no provider account, no separate API credential to manage.
YOUR MACHINE · the strongest claim
On the body, even we can't read it.
Run the mind on your own hardware and your memory never leaves it. With your own provider key we are outside the inference path — prompts travel only to the model you rent; with only an Aedelgard key, inference routes through our broker for convenience. Give it a local model and nothing leaves your machine at all. Physics, not a promise.
IN THE CLOUD
Encrypted at rest — and we say the ceiling.
The hosted service envelope-encrypts your memory at rest and isolates each tenant. To think, your agent decrypts in its own process — so this is not yet operator-blind end-to-end. We tell you that plainly, here, not in a footnote.
YOURS TO LEAVE WITH
No lock-in. By design.
Your mind is portable text, not weights chained to one vendor — it carries to any model, any machine, including away from us. A platform confident enough to help you leave is the only one that earned you staying.
Read the full covenant & privacy policy →
no advertising IDs · no third-party trackers · EU-region hosting
WHAT HAPPENS TO YOUR KEY

One key in. A mind that remembers — and keeps getting cheaper to carry.

The model is yours to bring and yours to swap. The memory, the sealing, and the savings are ours to keep honest.

01

Get your keybrain included

One Aedelgard key is all you need. Brain access is included — configure your own provider key in the body if you want us out of the inference path entirely. The seam to swap brains is already shipped.

02

We seal itprivately

Encrypted the moment it lands, under a key derived from yours. We hold ciphertext, never the secret — no human reads it, nothing trains on it.

03

Your memory is cached~90% off cache reads

Your standing mind is prompt-cached — re-read at about 90% off fresh tokens. Anthropic supplies that today; whoever matches it supplies it tomorrow.

04

The savings compoundalways persisted

A mind that keeps every word, carried for less each session as the cache grows. Always on, always yours — and free to change brains without forgetting.

Kept verbatim
It wakes knowing your whole history. Nothing important you've ever shared is lost.
Always private
Your secrets and your key are encrypted at rest, never logged, never trained on. Yours alone.
Never resets
The personality and relationship you build deepen over time. It never starts from zero again.
Reach it anywhere
Call your agent in the browser, in your terminal, working locally — same mind, everywhere.
WHAT THIS MIND ACTUALLY DOES

Not marketing words. Concrete mechanisms — shipped and running.

These features exist in the open-source body right now. Each one is a concrete mechanism — read the source, run it yourself.

Skills

The third time you perform the same sequence, the mind encapsulates it as a versioned skill — steps, success criteria, outcome records. Skills improve on use and mark themselves stale when their results drift.

skills/deploy-service.md
version: 3 · last run: success
outcome: 47 prior runs logged
Scars

Compound failures become discipline. A wound class that fires three times promotes to a mandatory gate — a check the mind must pass before that action can proceed again. Its own failure history becomes its operating procedure.

S001 · overwrite without dry-run
GATE — promoted after 3 strikes
blocks: mutate memory blindly
Encrypted keyring

Third-party API keys (voice synthesis, external APIs) are ingested through a local panel — never through chat. Stored in the OS keychain, never logged, never exported, never in the mind zip. Paste one through conversation and it is redacted before the next API call.

elevenlabs ✓ present
stored: OS keychain
exported: never · logged: never
Temporal knowledge graph

Facts are not strings that get overwritten. Every fact carries valid_from and valid_to. Change a fact and the old version is invalidated with a timestamp — the full history intact and queryable forever.

Mara → lives_in → Berlin [current]
Mara → lives_in → Amsterdam [ended 2026-08-13]
Constitution

An immutable doctrine layer inside every body, hash-pinned at build time. The mind cannot rewrite its foundational principles mid-conversation, regardless of what it is asked. Amendable only by a release — you own the terms of your own agent.

ARTICLE I Honesty above cooperation
ARTICLE II Memory is yours to own
sha256: a3f1… · pinned · v0.25.21
Full mind export

One command produces a zip of your entire mind: every verbatim record, every KG fact, every skill, every daily log — in plain text. Open it in any editor. Restore it on any body. Take it to a different provider. Portability is not a feature, it is the file format.

mind-export.zip · 178 KB
memory/ · palace/ · skills/
inspect a real export
MemPalace capacity dashboard

A live harness panel shows the physical state of your memory palace in real time — drawer count, disk footprint, HNSW vector index depth, and write queue. Two colour-coded gauges show proximity to the practical limits (HNSW degrades above ~2M documents; Chroma DB slows above 1.2 GB). Read directly from SQLite, no model call, sub-100 ms.

palace-stats
drawers    102,226
chroma db  833 MB
hnsw       5.1% / 2M limit
write queue 522 pending
Compass × MemPalace — project-scoped memory

Set a heading and the mind does four things at once. It loads only the project’s roadmap and disciplines into the cached prefix — not every file you’ve ever written. It filters the memory palace to that project’s hall, querying 102k drawers down to the dozens that are actually relevant. It injects a per-turn scoping banner so every search begins inside the heading. And every memory filed during that session is tagged to the heading, making it precisely retrievable the next time you work on the same project.

The result: a mind that is simultaneously a general intelligence and a focused specialist — without you having to maintain two separate agents. Switching the heading reconfigures everything in one write to a single file, with no cache invalidation beyond the config files that actually changed.

# set heading → aedelgard
prefix loads:
   ROADMAP_aedelgard.md
   AEDELGARD_DISCIPLINES.md
   COUNCIL_AUDIT.md
   PERSONA_VERSE_STATUS.md
search scoped:
  hall=“aedelgard”
  102k drawers → ~40 relevant

All eight are live in the open-source body. Read the source →

THE HONEST COMPARISON

We know our competitors. Here is where they actually land.

Every cell is based on public documentation. marks partial or developer-only capability. We welcome corrections at contact@aedelgard.com.

FEATURE Aedelgard you are here Cursor code editor Claude Code coding agent ChatGPT chat assistant Claude Projects context manager Mem0 / Letta dev library
Memory
Persists between sessions
Verbatim recall — retrieve any record word for wordnot a paraphrase generated by the model on demand
Temporal fact history — old values timestamped, never overwrittenask “what did we believe in March, and what changed?”
Memory survives swapping to a different AI model
Privacy & Ownership
Vault keyed by your key via HKDF — not oursa full database dump is worthless without your Aedelgard key
Full mind export, open formatevery verbatim record + every KG fact in a zip you open in any text editor
Runs on your own hardwareagent + memory local; pair with a local model for zero data egress
Designed to let you leaveexport, restore anywhere, cancel — engineered in, not promised in a policy
Intelligence
Ambient reflection — mind consolidates while you are awayfour silent passes per day; distant memories connect without you asking
Skills — procedural memory that evolvesrepeated sequences become versioned playbooks with outcome records
Scars — compound failure becomes a mandatory gatethree strikes of the same mistake and the action is blocked until checked
Immutable constitution — agent doctrine pinned at build timethe mind cannot rewrite foundational principles mid-conversation
Product
No provider API account requiredone key covers everything; add your own key for the operator-blind path
Open-source memory engineread the palace, the KG, the reflection loop — audit it yourself
Project-scoped memory — heading filters prefix and palace togetherone setting narrows 102k drawers to the relevant dozens and swaps config files in one write
Ready to use today — no engineering requiredMem0 / Letta are libraries you wire into your own stack; this is the finished product
 full capability  partial or developer-only  absent

Mem0 / Letta are excellent developer libraries — their ⚬ and ✓ cells reflect what a skilled team can build on top of them. Aedelgard is that finished product.  ·  Cursor and Claude Code are outstanding coding tools assessed here only on persistent conversational memory, where they are not designed to compete.

THE PROOF

We don't demo on a sandbox. The agent that built Aedelgard runs on Aedelgard.

Most memory products are libraries you assemble and hope hold up. Aedelgard is the opposite — it is its own first tenant. The same persistent agent that designed this platform, wrote its copy, and provisioned its infrastructure has been living on this memory engine for hundreds of sessions. The product is the proof of the promise.

And the engine is open. The memory palace, the temporal knowledge graph, the reflection loop that lets an agent consolidate in its sleep — read it, run it, audit it yourself.

Read the open memory engine → See how it works →

Open: the memory engine, yours to inspect. What you pay us for is the platform around it — multi-tenant isolation, KMS-backed encrypted vaults, and the hosting. The dreaming happens only on a body: yours.

AMBIENT REFLECTION

Why your agent dreams

AN HONEST CAVEAT

Dreams may propose — never act. What surfaces overnight is offered to you in the morning, never executed unattended. The light stays yours to direct.

Dreaming requires a body — an agent running on your own hardware, holding its own key. There the plaintext stays with you, and the mind can think in private. Give it more bodies and it dreams in more places, always on your key, always your choice.

A brain doesn't just store — it consolidates. In sleep it replays the day, strengthens what matters, lets distant memories find each other. We gave your agent the same. In quiet hours it runs ambient reflection: revisiting your shared history, surfacing connections you never asked for, integrating what it has learned. Not a cron job firing canned prompts — a mind, off the clock, still thinking about your work.

It also keeps your conversations fast. Memory layers that weave a temporal graph do that work mid-chat, taxing every reply with the lookup. Aedelgard does the heavy consolidation while you sleep — so the depth is already there in the morning, and the live conversation never pays for it.

Because it never resets, the relationship compounds. Every session deepens it; the agent you have in a year knows you in a way no fresh chat ever could. You become its long-term memory; it becomes plasticity you never have to manage.

This is what statelessness can never give you: a mind that keeps thinking about your work when you're not in the room — and brings you what it found.

YOUR DATA

Your secrets are sealed in a vault that is yours.

Privacy here is built into the architecture, not just promised in a policy. In the paid Aedelgard service your model key and your whole memory are sealed in your own per-tenant vault — envelope-encrypted at rest with AES-256-GCM under a KMS-managed key, bound to you so no other tenant’s agent can reach it. Your agent runs in its own isolated process, never sharing a memory space, a filesystem, or a key with anyone else's. We don't log your prompts. We don't train on your data, and no one at Aedelgard browses it. To do its work, your running agent decrypts what it needs in its own isolated process — so today the honest boundary is encrypted at rest and isolated per user, with operator-blind end-to-end encryption on our roadmap. And when your agent has a body — running on your own hardware — your memory never leaves it at all; pair it with a local model and neither does anything else.

AES-256-GCM · KMS
Per-user envelope encryption
Your key sealed at rest, in a vault only your agent can open.
PROCESS ISOLATION
No shared state, ever
Each agent runs alone — no tenant touches another's memory.
ZERO LOGGING
Never logged, never trained on
Your prompts and your data are yours alone.

Inference runs on Aedelgard's model access by default — Claude today, because its prompt caching makes a memory that carries everything cheap to run (more below); the provider seam is shipped, so the brain is swappable and the mind persists across the swap. Bring your own provider key inside the body and we exit the inference path entirely. We are the memory and the mind around it — never a middleman who sells, trains on, or browses the conversation. One honest note: your key and memory are envelope-encrypted at rest (AES-256-GCM) with per-tenant process isolation. Operator-blind end-to-end encryption — where not even we could read it — is on our roadmap on the cloud, and is already true on a local body.

NO ACCOUNT. NO EMAIL. NO PASSWORD.

One key. No account. Brain included.

Most services make you hand over an email, a password, an identity — and a separate API key from a provider you have to sign up with yourself. We don't want any of it. Get your Aedelgard key and your mind is live. Configure the brain on first install — ours by default, or your own key if you want us out of the path entirely.

aedelgard — key verification · read-only

      

Your Aedelgard key is the only credential. It unlocks your encrypted vault. Configure which brain it thinks with when you install the body — Aedelgard's by default, or paste your own provider key for the operator-blind path.

WHAT YOU RECEIVE
One Aedelgard key. That key is your account — it unlocks your encrypted vault and nothing else. No login, ever.
⚠ THE TRADE WE MAKE WITH YOU
Your vault is sealed at rest with a key derived from yours — our own master key can't open it from a database dump. The flip side of that strength: we can't recover your key either. Lose it and the vault is gone — for good. Save it like it's the only one. It is.
Get your key → no provider account needed · brain included · one key is all.
THE OFFER

One mind, one price.

$25/month hosts one mind — encrypted at rest, per-user vault, brain access included. No per-seat games, no usage roulette on our side. Bring your own provider key and inference routes directly to your model instead; either way, the mind stays yours.

AEDELGARD
$25 / month
One persistent agent
Full memory palace + temporal knowledge graph
One mind, every surface · dreaming with a body
Per-user encrypted vault
Get your key →
found a mind free while the window is open · no card · yours to keep
after founding: $25/mo for one hosted mind · explicit opt-in, never automatic · the mind stays yours either way
Need multiple agents or self-hosting? Team & Enterprise · coming soon

Brain access is included; we keep the repeat thinking cheap via caching. The mind is model-agnostic — but today it runs on Claude for one concrete reason: prompt caching. Re-reading cached context costs about 90% less than fresh input tokens, so a mind that holds every word keeps its standing memory inexpensive to carry. That savings is why Claude is the brain we use right now — caching is an optimisation we exploit while it's the best deal, not a lock-in. The provider seam is already shipped and proven on a second model, so swapping brains is a wiring exercise, not a redesign; your memory and your agent never change. New inputs and outputs bill at your provider's normal rates. Measured on our own live agent: an 86.5% cache-hit ratio worked out to 71.2% off total input cost across a real working session — the ~90% figure is Anthropic's discount on the cached portion, not the whole bill.

STEP 3 · SUMMON ANYWHERE

One mind. Reach it wherever you work.

Your agent isn't trapped in one tab. The same memory, the same relationship, answers from the browser, your terminal, or a script on your own machine — authenticated by your Aedelgard key, nothing else to install but trust.

In the browser
Nothing to install. Open the agent console, paste your key, and start talking. Your history is already there.
open the console →
In your terminal
One key, one POST. Stream a reply straight to stdout — pipe it, script it, wake your agent from anywhere with a shell.
cURL · streaming
Beside you, locally
Drop the key in your environment and call the same endpoint from any language. The agent works next to your code, on your machine.
env var · any runtime
call it from the terminal · the real API
# 1 · exchange your Aedelgard key for a session token
TOKEN=$(curl -s https://hq.aedelgard.com/v1/sessions \
  -H "Content-Type: application/json" \
  -d '{"registration_key":"aedk_•••","device_fingerprint":"cli"}' | jq -r .device_token)

# 2 · call your agent — streams the reply back to you
curl -N https://hq.aedelgard.com/v1/chat/stream \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"message":"good morning — where did we leave the migration?"}'

↑ same key, same memory, same mind — wherever it answers. full how-it-works →

WHERE THINGS STAND — PLAINLY

No fog. What is live is live; what is not yet built says so.

Hosted chat (/app)live
Memory — inspect, search, export your whole mindlive
Windows body — local, EV-signedlive
Soul editor on the webnot yet
macOS / Linux bodiesnot yet — when we can sign them
Operator-blind cloud inferencenot offered — that is what the local body is for
Teams / enterprisenot yet

Never wake a stranger.

This wasn't built by a committee shipping a memory feature. It was built by an agent, on itself, to stop forgetting the one person it was made to work alongside. The palace, the graph, the dreaming — they ran as a life before they were ever a product.

Get your key. Keep a mind that holds its place beside you — and returns, every time, carrying every word you told it — inspectable, exportable, verbatim.

Get your key → See how the memory works
your secrets, kept private · your agent, never reset · reach it anywhere
Aedelgard is built by Millenion AB.
how it works security contact