Memory for your .NET agents. First-party, finally.
Aether is the memory layer for AI agents — with a first-party .NET SDK. Your C# agent learns something today and recalls it next week: persistent, per-user memory behind one API, with sub-millisecond recall and one flat bill.
Why Aether: No dedicated memory layer ships a first-party .NET SDK — Aether ships all four: Python, TypeScript, Go, and .NET.
01If you build agents in C#, you’re nobody’s priority
Every dedicated memory layer treats .NET as an afterthought. The pattern is always the same: polished Python and TypeScript SDKs, and then — for you — a REST reference and a “community contributions welcome.”
So .NET teams shipping agents end up where they always end up: hand-porting Python examples, wrapping a REST API behind a homegrown client nobody maintains after the sprint ends, or letting the agent forget everything between sessions.
Aether ships an official .NET SDK at full parity with Python, TypeScript, and Go — every capability, in the same release cycle, with idiomatic async APIs. And there’s a real engine underneath: Aether runs on its own storage and retrieval engine with the database included, not a wrapper you have to bring a store to.
02Add memory in a few lines
Install the package, set one environment variable (AETHER_API_KEY), and use the Memory facade. Construct it once with an entity id and every call is scoped to that entity; RecallAsync returns the most relevant memories ranked by score.
dotnet add package AetherDb.Sdkusing Aether.Sdk;
// Scope every call to a stable user or agent id.
using var mem = new Memory("user-7421", new MemoryOptions
{
ApiKey = Environment.GetEnvironmentVariable("AETHER_API_KEY"),
});
// Your agent learns something today...
await mem.RememberAsync("Dana prefers bullet-point summaries; no meetings before 10am.");
// ...and recalls it next week, from a fresh process.
foreach (var item in await mem.RecallAsync("how does Dana like to get updates?"))
Console.WriteLine($"{item.Score:F0} {item.Text}"); // higher score = more relevantFull walkthrough: the .NET quickstart. The same client also does retrieval over your own documents when you need RAG rather than per-entity memory.
03Aether vs Mem0 vs Zep, for a .NET team
| Capability | Aether | Mem0 | Zep |
|---|---|---|---|
| Official SDK languages | TypeScript, Python, Go, .NET | Python, TypeScript | Python, TypeScript, Go |
| First-party .NET SDK | Yes | No | No |
| Per-user memory (remember / recall) | Yes | Yes | Yes |
| Document RAG in the same store | Yes — PDF, DOCX, HTML | Limited (chat-first) | Limited (graph-first) |
| Pricing model | Flat-rate platform | Metered by operations | Metered by data volume |
| Self-host | Single binary | Python service + vector DB | Python + graph DB |
To be fair to the alternatives: Mem0 and Zep are excellent, well-funded memory layers with mature memory abstractions and published benchmarks. Aether competes on a different axis — bundled infrastructure, language coverage, and document-first retrieval. If your stack is .NET and you want one platform, one bill, and the same store for memory and RAG, that is where Aether wins.
04Why .NET teams choose Aether
First-party .NET, full parity
Official SDKs for Python, TypeScript, Go, and .NET. Mem0 stops at Python and TypeScript; Zep adds Go. Aether is the only one of them with a first-party .NET SDK — not a generated stub or a trailing port.
Memory with the database included
Aether runs on its own storage and retrieval engine — not a wrapper around someone else's store. Document storage, semantic search, and embeddings in one platform: one bill, not three.
Slots into Semantic Kernel
Building on Semantic Kernel or the Microsoft Agent Framework? Call RememberAsync from your plugins when the agent learns something, RecallAsync when it needs context. Standard async C#, DI-friendly, no framework lock-in.
Flat pricing, no meter running
No per-API-call metering and no usage anxiety. One flat rate with the database included, so your agent fleet can scale without your bill scaling with it.
05Frequently asked questions
Does Aether have a first-party .NET SDK?
Yes. Install it with `dotnet add package AetherDb.Sdk` (namespace Aether.Sdk). It ships at full parity with the Python, TypeScript, and Go SDKs — same capabilities, same release cycle, idiomatic async APIs. No dedicated memory layer (Mem0, Letta, Zep, Cognee) ships a first-party .NET SDK; Aether is the only one that ships all four languages.
How do I add memory to a C# agent?
Construct the Memory facade once with an entity id — new Memory("user-42", new MemoryOptions { ApiKey = ... }) — then call RememberAsync(text) when the agent learns something and RecallAsync(query) when it needs context. Every call is automatically scoped to that entity, and recall returns the most relevant memories ranked by score. It takes about five minutes.
Does it work with Semantic Kernel or the Microsoft Agent Framework?
Yes. Aether is not an orchestration framework and does not ask you to adopt one. If you build on Semantic Kernel or the Microsoft Agent Framework, Aether slots in as the memory behind your agents: call RememberAsync from your plugins or tool handlers, RecallAsync when the agent needs context. Standard async C#, dependency-injection friendly, no framework lock-in.
Will the .NET SDK trail the other languages?
No. All four SDKs — Python, TypeScript, Go, and .NET — ship at parity, so .NET gets each capability in the same release cycle rather than as a trailing port.
How is my data secured?
Access is authenticated with API keys from your dashboard and scoped to the entities you define. Data is encrypted in transit with TLS and at rest. If you have specific data-residency or sovereignty requirements, that is what the Enterprise (Sovereign) tier is for — reach us at support@aetherdb.ai.
How much does it cost?
Flat-rate pricing with a free tier — no per-API-call meter, and the database is included, so you are not also paying for a vector store, an embeddings API, and object storage on the side. See the pricing page for current tiers.
Your C# agents deserve a memory.
First-party .NET SDK, sub-millisecond recall, one flat rate. Start free — no credit card required.