Self-evolving memory infrastructure
for personal AI agents
Memory lets AI agents know you better over time.
Self-evolvingSelf-improvingExplainableControllable
from openai import OpenAI
client = OpenAI(
base_url="https://api.reglos.ai/v1", # ← change only this line
api_key="<your API key>",
)
resp = client.chat.completions.create(
model="gemini-2.5-flash",
user="alice", # ← whose memory this is
messages=[{"role": "user", "content": "What do I like to do on weekends?"}],
)
print(resp.choices[0].message.content)Already supported
- OpenAI-compatible proxy
- Python SDK
- TypeScript SDK
- LangChain
- LlamaIndex
- MCP Server
The problem
Users never say "your recall is low."
They say "you forgot what I told you."
"What about that thing I mentioned?"
When memory gets pruned, nobody writes down why. It was stored, and then it quietly vanished in some compaction pass. You cannot find where it went, and "I forgot" is not an answer the user will accept.
"Its impression of me changed for no reason."
Profiles are written by overwriting, so today buries yesterday. In March you said the budget was 200k; in June you changed it to 500k. Once that is overwritten, "what did you think back then" has no answer left.
"Why did you bring that up?"
Retrieval is a black box. It returns a memory that has nothing to do with anything, and you can neither ask why it picked that one nor tell it that it is wrong. Next turn, it returns it again.
"I do not work there any more."
With one timestamp you cannot tell when something was true from when you found out. So the 2023 employer and this year’s employer get stuffed into the same context.
Models change. Vendors change. Regulators do not relax.
“Only memory that can explain itself is memory you can ship.”
Side by side
Same question. With memory and without, you get two different answers.
「I'm negotiating a partnership with Lao Zhou next week. There's real risk in this deal — how should I play it?」
Returns the negotiation advice you can find anywhere: BATNA, whether to anchor first. It does not know who Lao Zhou is, what this went wrong for you before, or how you make decisions.
Lao Zhou is impatient and likes to settle things verbally — and a verbal agreement already cost you once with him. Consistent with your standing rule of drawing the risk boundary first and never committing verbally: affirm the direction, then put risk and responsibility in writing. Keep the tone warm and leave yourself room.
The two memories behind that answer — both open up
- "a verbal agreement already cost you"→ back to the original conversation on 2025-11-02
- "draw the risk boundary first"→ profile slot decision-style/cautious · drills down to every fact supporting it
The difference is not the model. It is whether the model actually knows you. And whether every line it says can be traced to where it came from.
Ask something only an AI that remembers you could answer
Mechanisms
<self-evolving> memory, and you can see how it changed
Self-evolving does not mean the model is quietly training itself. It means the memory has a metabolism. New facts arrive and old ones step back without vanishing; it tidies itself once a day; every act of forgetting has a reason. It keeps growing, and it never changes quietly.
01 / 03
Supersede, never overwrite: every edit is an addition
Every memory carries two times: when it was true, and when we learned it or stopped counting it. Keeping them apart is what lets it say when something changed, and what makes "nothing silently lost, nothing silently altered" more than a slogan.
| Record | Fact | True from | True until | Recorded | Retired |
|---|---|---|---|---|---|
| #1041 | Works at Company A | 2023-03-06 | — | 2023-06-12 | — |
| #1041 | Works at Company A | 2023-03-06 | 2024-01-20 | 2023-06-12 | 2024-02-03 |
| #2288 | Works at Company B | 2024-01-21 | — | 2024-02-03 | — |
#1041 was neither deleted nor rewritten. It was marked as no longer true from 2024-01-20 and superseded by #2288; the original record is still there.
What self-evolving means in practice
Supersede, never overwrite
The old memory is only marked with when it stopped being true and what replaced it; it is still there. Every edit becomes an addition, so "what did you think back then" always has an answer.
Tidies itself once a day
When you go quiet, it begins to tidy: conversations are distilled into summaries, its understanding of you is rewritten, ongoing threads are brought up to date. At most three insights a day, and none it is unsure of. None of this needs a call from you.
The profile is derived from memory
Its understanding of you is not a stored copy; it is derived from the memories. Change a memory and the understanding changes; remove one and whatever rested on it is gone at the next pass. Every line of it opens to its evidence.
Forgetting needs a reason
It writes down why it forgets, and it can take it back: nothing is physically deleted, only marked. By default it lists what could be forgotten and waits for your yes.
Memory loops
Evolves online, iterates offline
The paper calls this a memory agent: it acts on its own. It is not a chat assistant.
Inner · per user
Memory moves with the conversation
Every fact enters an append-only record with when it holds and when it was learned. A new preference supersedes the old one and the old one stays; a request to forget expires the fact and records the request; a nightly pass turns the day into the profile.
Outer · every user
It improves its own code
A coding agent reads failure traces and proposes patches to the code that turns memory into context; a critic from a second model family rejects patches that game the benchmark; a fixed evaluator accepts a patch only if it helps users it never saw. Four accepted steps took accuracy from 54.2% to 60.7%.
Mechanism diagrams
Four timestamps on every fact, plus a pointer to what overturned it
How it works
- 01 · remember
Write; it tidies up on its own
Conversations, one-line facts, whole documents, device events all go in. When new contradicts old, the old is marked invalid, not deleted; once things go quiet it tidies up by itself, nothing for you to call.
- 02 · recall
Retrieve, and say why
Several paths fused in parallel; with explain, every hit shows its paths, ranks and validity window.
- 03 · forget · explain
Forgetting you can undo, sources you can check
Tell it to forget one memory: it needs a reason, and you can change your mind. Delete a conversation and everything derived from it goes too. Every memory leads back to the sentence it came from and what replaced it.
from memcore import Memcore
user = Memcore(api_key="mk_live_…").subject("alice")
user.remember("I live in Shanghai and hike on weekends.") # write
hits = user.recall("where does he live", explain=True) # retrieve + why
user.explain(hits.facts[0].id) # trace to the source
user.forget(hits.facts[0].id, reason="extracted wrong") # void it, keep the row
user.audit(limit=5) # change historyIndustries
One kernel, many industries
Every industry wants a different shape of memory, but three things everyone wants: you can trace it, correct it, and delete it cleanly. The more regulated the buyer, the sooner those three questions come up.
It picks up where you left off
Preferences, habits and the people you mentioned are remembered; the next conversation continues from the last one instead of starting over.
Commitments come due
A commitment with a date gets its own queue; when it comes due it lands in /v1/reminders, and how to tell the user is your product’s call.
New device, same memory
Pendant, watch and app write into the same brain. Isolation is by person, not by device: swap the hardware and the memory follows.
Preferences and commitments carry over, so the "it remembers me" moment actually happens.
Benchmarks
Reglos leads on three benchmarks
PersonaMem-v2
- Reglos61.3%
- EverOS53.6%
- MemOS53.8%
- Mem045.0%
LongMemEval-S
- Reglos84.0%
- EverOS80.4%
- MemOS73.0%
- Mem065.6%
Product
Three products, one kernel, two ways to deploy
Three products share one memory kernel: what it keeps, how it retrieves, where things came from, what changed. One logic, with no "app memory" and "API memory".
Reglos App
Daily recap, timely reminders, and it knows you a little better every day.
Memory API / SDK
Plug memory into your own product: write it, find it, see where it came from, delete it cleanly. Python, TypeScript or MCP.
Smart hardware
One memory of when and where, shared across your devices.
Reglos Cloud
Hosted API, up in minutes. Multi-tenant isolation and row-level security are done at the database layer.
Private deployment
Runs inside your VPC, so the data never leaves your network. Bring your own model keys.
Why it matters
Silence is the number one enemy of a memory system
All six of these happened in our own system, and all six are fixed. What they have in common is not that something broke, it is that something broke and said nothing. Those four are not a philosophy. These six incidents forced them on us.
- Silent under-recall01
Filtering happened after retrieval
pgvector's hnsw index covered only the embedding column, not the tenant field, so it fetched neighbours first and filtered by tenant afterwards. How many rows you lost, nothing will tell you.
- Silent disappearance02
12 points gone, zero alerts
A multi-tenant refactor changed how vector tenant names were derived, orphaning every vector written before it. The vector store had auto tenant creation on, so querying a tenant that did not exist did not fail; it quietly created an empty one and returned nothing. Accuracy went from 65.3% to 53.3%.
- Silent set-swap03
A group of 191 questions dropped; the mean was computed anyway
In a third-party harness, one empty judge response raised, an entire group of 191 questions was discarded, and the mean was still computed over the remaining 1,349 and written to the results file, with one line at the end that said "1 groups had errors".
- Silent corruption04
Called upsert, only ever did insert
It raised 422 on an existing id, and callers wrapped it in try/except, because a shadow index must not block the source of truth. So every write that meant to update a vector failed, for a long time, and the vectors drifted away from the facts.
- Silent pollution05
Substring matching on single-character aliases
Several unrelated Chinese words share one character with the word for "home", and substring matching classified them all as the home scene. Retrieval was dirty the whole time, and not one log line was red.
- Silent under-metering06
Meter nothing, bill nothing
A metering failure should not turn our Redis blip into the customer’s 5xx, so it does not block the request. But it has to be logged, or a charge simply goes missing and nobody knows.
Not one of these six raised an error. Explainable, controllable, provable, never quietly changed: in the end that is what those four are for, making the silent things speak.
Pricing
Pay for what you use. Private deployment quoted separately.
Memory is something you build up over time, and billing should not push you to delete it. Writes and retrievals are priced separately, and what you have stored does not get more expensive just for sitting there.
Free tier
- 20,000 writes / month
- 100,000 retrievals / month
- explain=1 lineage in responses, fully enabled
- One-click export and cascade delete
- Community support
Usage-based
- Multi-tenant isolation and row-level security
- Audit log retention and export
- Bring your eval set — we run it
- Ticketing and a direct engineering channel
Dedicated deployment
- Private deployment inside your VPC
- Data stays in-country, compliance pack included
- Dedicated SLA and release channel
- Kernel customisation and joint evaluation
Prices are confirmed by sales. Enterprise plans can be tailored by deployment scope, device fleet, annual usage and QPS.
Resources
Keep reading
Four routes; take the shortest
Developers · OpenAI-compatible with one base_url change; plain HTTP from any language; a Python SDK; MCP with one config block.
A memory foundation across devices and years
Hardware · Device identity, offline queue, incremental sync, one person one brain. Devices never hold an API key.