Aether vs building it yourself
For most teams the real alternative to Aether isn't another product — it's a Postgres instance with pgvector, an embedding API key, and a weekend. We respect that option. Here's what it actually costs to keep working.
01The short version
“Just use pgvector” is never just pgvector. To give an agent memory that survives between sessions you assemble a store with pgvector, an embedding API (a metered bill), an extraction pipeline you write and babysit, object storage (a third bill), and the cron jobs, retries, and dead-letter tables that page you on a Friday.
That's three metered bills plus glue code you maintain forever — and the glue is the part that pages you. Aether's position is simpler: memory with the database included. Document storage, semantic search, and embeddings in one platform, one bill, on our own Rust engine.
02When building it yourself is the right call
Sometimes it is. You're a deep Postgres shop — your team dreams in SQL, runs Postgres in production with backups and observability, and will want to join memories against your own tables anyway. Adding pgvector is a small step for you.
Or you have a hard data-residency constraint that keeps agent data off any third-party service — build inside your VPC. Or your memory needs are trivial (a preferences table with a dozen keys, no semantic recall), in which case a plain table is the right tool.
03Side by side
| Aether | DIY (pgvector + glue) | |
|---|---|---|
| Storage | Included | Your managed Postgres bill |
| Embeddings | Included | Your embedding API bill (metered per token, scales with traffic) |
| Documents | Included | Your object storage bill |
| Extraction pipeline | Included | Engineering time to build, then ongoing time to maintain |
| Versioning, decay, scoping, threading | Included | Engineering time, per feature |
| Price behavior | Flat-rate plans, no per-API-call metering | Three metered bills that move when usage moves |
04Memory across sessions, in code
The test that matters: your agent learns something today and recalls it next week, in a different session, without you re-feeding context. Scope memory to a stable id; recall() returns the most relevant memories ranked by score.
from aether import Memory
# Scope memory to a stable user or agent id.
memory = Memory("user-42")
# Today: your agent learns something.
memory.remember("Freezes production deploys after 2pm on Fridays")
# Next week, a fresh session — it remembers, ranked by relevance.
for hit in memory.recall("when can I schedule a deploy?"):
print(hit.score, hit.text)The same surface ships in Python, TypeScript, Go, and .NET at full parity. See the quickstarts for your language.
05Which one fits
The features you'll hand-roll
- Embedding versioning — the day you switch models, every stored vector is stale; you need a re-embed backfill and a dual-read window.
- Recency and decay logic — cosine similarity doesn't know yesterday's fact should outrank last quarter's. You write and re-tune the time-decay math.
- Entity scoping — on day one it's a WHERE clause; by the time you have customers it's an isolation guarantee your security review probes.
- Session threading — recall has to work within a thread and across them, two different queries.
What you give up with Aether
- It's a managed service — your agent's memories live in Aether, not your Postgres, so you can't JOIN them against your application tables.
- You adopt our retrieval decisions — recency ranking, fact extraction, decay are opinionated defaults. If your edge is a bespoke ranking algorithm, you'll want the raw materials.
- Embeddings are managed for you — the point for most teams; bring-your-own-embeddings exists as an escape hatch if you've tuned a model you trust.
06Frequently asked questions
Isn't pgvector basically free?
The extension is. The stack around it isn't: an embedding API bill, object storage, and the extraction pipeline plus versioning, decay, scoping, and threading you build and maintain. The biggest line item — the engineer who owns the pipeline — never shows up on an invoice.
Can I still use my own Postgres with Aether?
Aether is memory with the database included, so you don't operate a vector store yourself. If joining memories against your own tables is essential, that's a genuine reason to stay on pgvector — we'll say so.
What do I actually save?
The three metered bills collapse into one flat-rate plan, and the extraction pipeline, embedding versioning, recency tuning, entity scoping, and session threading ship as the product instead of as your backlog.
Does the same code work across languages?
Yes — the same memory surface ships in Python, TypeScript, Go, and .NET at full parity. DIY glue code, by contrast, gets rewritten once per language your services run in.
Your agents need memory. Not three bills.
First-party SDKs for four languages, sub-millisecond recall, one flat rate. Start free — no credit card required.