Open source memory layer so any AI agent can do what Claude.ai and ChatGPT do

I clicked this thinking “oh, cool, someone finally made a portable version of the Claude.ai* memory system!” Spoiler, no, it’s not it at all, it’s just a “store”/“remember” memory system… as opposed to the Claude.ai memory system, where it doesn’t make the model actively have to write memories on its own, but rather has a model in the background go through your chat history and generate a summary from it.

I’ve found the latter approach to work much, much better than simple “store”/“remember” systems.

So, it just feels misleading to say this can do what Claude.ai’s can do…

(I’ve been looking for a memory system that works the same for a while, so that I can switch away from Claude.ai to something else like LibreChat, but I just haven’t found any. Might be the only thing keeping me on Claude at this point.)

*I say Claude.ai because that’s specifically what has the system; Claude Code doesn’t have this system

I’m certainly on the lookout for something like this and I’m happy to see your account has published software from before the LLM boom as well. I guess I’d like some kind of LLM-use-statement attached to projects: did you use an LLM to generate this, and if so, how much and what stages (design, build, test)? How carefully did you review the output? Do you feel the quality is at least what you could have produced by yourself? That sort of thing.

Not casting aspersions on you personally, I’d really like this from every project, and would do the same myself.

All these agent memory systems seem so simultaneously over and under engineered and like a certain dead end. I cannot imagine any reality in which this does not rot and get out of sync with what the latest model need. For the one time you build a payment provider how many session will be tilted towards thinking about payments because of the "don't use stripe" memory?

Well the project is promising something without providing any details how exactly this is achieved which to me is always a huge red flag.

Digging deeper I can see it is effectively pg_vector plus mcp with two functions: "recall" and "remember".

It is effectively a RAG.

You can make the argument that perhaps the data structure matters but all of these "memory" systems effectively do the same and none of them have so far proven that retrieval is improved compared to baseline vector db search.

A few things seem to work well for me (Codex):

1) An up-to-date detailed functional specification.

2) A codebase structured and organized in multiple projects.

3) Well documented code including good naming conventions; each class, variable or function name should clearly state what its purpose is, no matter how long and silly the name is. These naming conventions are part of a coding guidelines section in Agent.md.

My functional specification acts as the Project.md for the agent.

Then before each agentic code review I create a tree of my project directory and I merged it with the codebase into one single file, and add the timestamp to the file name. This last bit seems to matter to avoid the LLM to refer to older versions and it’s also useful to do quick diffs without sending the agent to git.

So far this simple workflow has been working very well in a fairly large and complex codebase.

Not very efficient tokens wise, but it just works.

By the way I don’t need to merge the entire codebase every time, I may decide to leave projects out because I consider them done and tested or irrelevant to the area I want to be working on.

However I do include them in the printed directory tree so the agent at least knows about them and could request seeing a particular file if it needs to.

It's not clear to me how or why this works, and how it compares to just using md files in my project. For something like this, we really need benchmarks.

I still haven't found useful "memory". It's either an agents.md with a high level summary, which is fairly useless for specific details (eg "editing this element needs to mark this other element as a draft") or something detailed and explaining the nitty gritty, which seems to give too much detail such that it gets ignored, or detail from one functional area contaminates the intended changes in another functional area.

The only approach I've found that works is no memory, and manually choosing the context that matters for a given agent session/prompt.

this is a patch on top of the broken flat-compaction caching algorithm used by coding agents. Why not fix the cache algorithm directly? Union-find is a better impl june.kim/union-find-compaction

Is this only for vibecoders who work alone?

If I am working on a real project with real people, it won’t have the complete memory of the project. I won’t have the complete memory. My memory will be outdated when other PRs are merged. I only care about my tickets.

I am starting to think this is not meant for that kind of work.

LLM Memeory (in general, any implementation) is good in theory.

In practice, as it grows it gets just as messy as not having it.

In the example you have on front page you say “continue working on my project”, but you’re rarely working on just one project, you might want to have 5 or 10 in memory, each one made sense to have at the time.

So now you still have to say, “continue working on the sass project”, sure there’s some context around details, but you pay for it by filling up your llm context , and doing extra mcp calls

>Stash makes your AI remember you. Every session. Forever.

How does it fight context pollution?

is this backed by a hollywood celebrity ?

Isn’t “memory” just another markdown file that the LLM reads when starting a new session?

I keep two files in each project - AGENTS (generic) and PROJECT (duh). All the “memory” is manually curated in PROJECT, no messy consolidation, no Russian roulette.

I do understand that this is different because the vector search and selective unstash, but the messy consolidation risk remains.

Also not sure about tools that further detach us from the driver seat. To me, this seems to encourage vibe coding instead of engineering-plus-execution.

Not a criticism on the product itself, just rambling.

Wow another day, another memory system for AI agents!

How many are we up to now? Has to be hundreds of them.

Congratulations on the launch!

There is lots of competition in this space, how is your tool different?

What the heck is happening on this site with the pointer disappearing? For some reason the body tag has "cursor: none" which is never good.

Platform memory is locked to one model and one company. Stash brings the same capability to any agent — local, cloud, or custom. MCP server, 28 tools, background consolidation, Apache 2.0.

There is already memory palace ?

I’ve found the latter approach to work much, much better than simple “store”/“remember” systems.

So, it just feels misleading to say this can do what Claude.ai’s can do…

*I say Claude.ai because that’s specifically what has the system; Claude Code doesn’t have this system

I really want to try this approach. I'm curious because this has not been my experience at all. I created https://github.com/flippyhead/ai-brain mostly just for myself and a few friends use it. But so far, telling the AI (via CLAUDE.md) to look for relevant memories and to think about when and how to save them has worked very well. It can create structures based on decided priorities, notes for the future, that feel like they'd be very different if it was just trying to summarize everything.

That's an interesting concept. So it's like if you're an agent chatting with a user, you have an army of assistants who overhear the conversation and record important facts, or search relevant facts on some database and decide on the fly when to interrupt you with "this memory X looks relevant". Sounds easy enough if tokens were free, but an interesting problem to do it efficiently.

I agree. silent agent doing agentic things async is what would be helpful, not requiring a modification to the main prompt

Not casting aspersions on you personally, I’d really like this from every project, and would do the same myself.

This is a fair question, but not one I feel we can let people self answer.

I doubt many people will honestly admit they did no design, testing and that they believe the code is sub par.

It does give me an idea that maybe we need a third party system which can try and answer some of the questions you are asking… of course it too would be LLM driven and quite subjective.

There are many ways to use an LLM to generate a piece of software. I base most of my projects these days around sets of Markdown files where I use AI first to research, then plan and finally track the progress of implementation (which I do step-wise with the plan, always reviewing as I go along). If I was asked to provide documentation for my workflow those files would be it. My code is 99% generated, but I take care to ensure the LLM generates it in a way that I am happy with. I'd argue the result is often better than what I'd have managed on my own.

What's the point? You can make good or bad software, with or without LLMs. Do you ask a carpenter if they use a hammer or nail gun? Did they only use the nail gun for the roof and the deck?

If you care that much and don't have a foundation of trust, you need to either verify the construction is good, or build it yourself. Anything else is just wishful thinking.

Well the project is promising something without providing any details how exactly this is achieved which to me is always a huge red flag.

Digging deeper I can see it is effectively pg_vector plus mcp with two functions: "recall" and "remember".

It is effectively a RAG.

The only approach I've found that works is no memory, and manually choosing the context that matters for a given agent session/prompt.

A few things seem to work well for me (Codex):

1) An up-to-date detailed functional specification.

2) A codebase structured and organized in multiple projects.

My functional specification acts as the Project.md for the agent.

So far this simple workflow has been working very well in a fairly large and complex codebase.

Not very efficient tokens wise, but it just works.

By the way I don’t need to merge the entire codebase every time, I may decide to leave projects out because I consider them done and tested or irrelevant to the area I want to be working on.

However I do include them in the printed directory tree so the agent at least knows about them and could request seeing a particular file if it needs to.

this is a patch on top of the broken flat-compaction caching algorithm used by coding agents. Why not fix the cache algorithm directly? Union-find is a better impl june.kim/union-find-compaction

Is this only for vibecoders who work alone?

I am starting to think this is not meant for that kind of work.

It's not clear to me how or why this works, and how it compares to just using md files in my project. For something like this, we really need benchmarks.

It's a cool website..it says memory. It shows LLM suck and this product magically just works.

In a way, if it does accomplish that, it is a vectordb needing glorification.

Yeah I feel the same way. Wonder when/if we'll get continual learning from these models. I feel like they are smart enough already but their lack of real memory makes them a pain to deal with.

All the memories Claude created for me fell in the category remember-to-not-forget, so I disabled it altogether.

Interesting approach. How do you do the merging? Is it manual? Just changed files? A hybrid?

is this backed by a hollywood celebrity ?

Congratulations on the launch!

There is lots of competition in this space, how is your tool different?

Isn’t “memory” just another markdown file that the LLM reads when starting a new session?

I keep two files in each project - AGENTS (generic) and PROJECT (duh). All the “memory” is manually curated in PROJECT, no messy consolidation, no Russian roulette.

I do understand that this is different because the vector search and selective unstash, but the messy consolidation risk remains.

Also not sure about tools that further detach us from the driver seat. To me, this seems to encourage vibe coding instead of engineering-plus-execution.

Not a criticism on the product itself, just rambling.

>Stash makes your AI remember you. Every session. Forever.

How does it fight context pollution?

LLM Memeory (in general, any implementation) is good in theory.

In practice, as it grows it gets just as messy as not having it.

So now you still have to say, “continue working on the sass project”, sure there’s some context around details, but you pay for it by filling up your llm context , and doing extra mcp calls

True! But this is a very naive implementation, a proper implementation could surpass these challenges.

And once you're being specific about what it needs to remember you are 0 steps away from having just told AI to write and read files with the "memory"

What the heck is happening on this site with the pointer disappearing? For some reason the body tag has "cursor: none" which is never good.

Platform memory is locked to one model and one company. Stash brings the same capability to any agent — local, cloud, or custom. MCP server, 28 tools, background consolidation, Apache 2.0.

There is already memory palace ?

Wow another day, another memory system for AI agents!

How many are we up to now? Has to be hundreds of them.

its the todomvc of ai user. i made one for myself too. I try not to tell anyone about it .

This is a fair question, but not one I feel we can let people self answer.

I doubt many people will honestly admit they did no design, testing and that they believe the code is sub par.

It does give me an idea that maybe we need a third party system which can try and answer some of the questions you are asking… of course it too would be LLM driven and quite subjective.

> I doubt many people will honestly admit they did no design, testing and that they believe the code is sub par

I'd doubt any engineer that doesn't call most of their own code subpar after a week or two after looking back. "Hacking" also famously involves little design or (automated) testing too, so sharing something like that doesn't mean much, unless you're trying to launch a business, but I see no evidence of that for this project.

> I doubt many people will honestly admit they did no design, testing and that they believe the code is sub par.

Well no, but if people want to see a statement like this, and given that most people will want to be at least halfway honest and not admit to slop, maybe it will help nudge things in the right direction.

Yep pretty much same, although if I’m lax at any point of the reviewing (in-progress or final), I’d say the quality quickly drops to below my average manual effort, and then I don’t even have the benefit of thinking it all through as directly. I think getting really quality results out of LLM code generation for non-trivial projects still needs quite a bit of discipline and work.

What's the point? You can make good or bad software, with or without LLMs. Do you ask a carpenter if they use a hammer or nail gun? Did they only use the nail gun for the roof and the deck?

If you care that much and don't have a foundation of trust, you need to either verify the construction is good, or build it yourself. Anything else is just wishful thinking.

Interesting approach. How do you do the merging? Is it manual? Just changed files? A hybrid?

It's a cool website..it says memory. It shows LLM suck and this product magically just works.

In a way, if it does accomplish that, it is a vectordb needing glorification.

All the memories Claude created for me fell in the category remember-to-not-forget, so I disabled it altogether.

We do ask whether it's handmade or factory.

We even ask when cakes are made in house or frozen even though they look and taste great (at first).

It’s not all-or-nothing: a statement like what I want would be part of the assurance, not the whole thing.

Yeah I feel the same way. Wonder when/if we'll get continual learning from these models. I feel like they are smart enough already but their lack of real memory makes them a pain to deal with.

Google Gemini does this sort of thing. External to the model k presume. And it's very annoying.

A friend told me he would like Claude to remember his personality, which is exactly what Gemini is trying to do.

A machine pretending to be human is disturbing enough. A machine pretending to understand you will spiral very far into spitting out exactly what we want to read.

I agree. silent agent doing agentic things async is what would be helpful, not requiring a modification to the main prompt

Yeah. The other advantage is a summary-based memory also just… “pieces together” things that a “store”/“remember” memory wouldn’t, because they’re things that the actual main agent would not think to store. i.e. small disconnected things across conversations that alone, would not end up in memory because they’re insignificant. But when there’s an agent looking at multiple conversations at once it can actually reason about this stuff and piece it together.

True! But this is a very naive implementation, a proper implementation could surpass these challenges.

And once you're being specific about what it needs to remember you are 0 steps away from having just told AI to write and read files with the "memory"

Well let's talk again when the problems have been solved, then. Until then, manually curated skills and documentation will beat this

its the todomvc of ai user. i made one for myself too. I try not to tell anyone about it .

> I doubt many people will honestly admit they did no design, testing and that they believe the code is sub par

> I doubt many people will honestly admit they did no design, testing and that they believe the code is sub par.

We do ask whether it's handmade or factory.

We even ask when cakes are made in house or frozen even though they look and taste great (at first).

It’s not all-or-nothing: a statement like what I want would be part of the assurance, not the whole thing.

Google Gemini does this sort of thing. External to the model k presume. And it's very annoying.

A friend told me he would like Claude to remember his personality, which is exactly what Gemini is trying to do.

A machine pretending to be human is disturbing enough. A machine pretending to understand you will spiral very far into spitting out exactly what we want to read.

Well let's talk again when the problems have been solved, then. Until then, manually curated skills and documentation will beat this

stash.memory

What
Namespaces
See It
vs RAG
Quick Start
Pipeline
MCP
Backends

→ GitHub

Open Source · MCP Native · PostgreSQL + pgvector

Stash makes your AI remember you. Every session. Forever. No more explaining yourself from scratch.

MCP tools

Pipeline stages

∞

Agents supported

Sound familiar?

😫 Without Stash

Hey, I'm building a SaaS for restaurants. Can you help?

Of course! Tell me about your project.

We talked about this last week... I already explained everything.

I'm sorry, I don't have access to previous conversations.

...again?

🔁 You just wasted 10 minutes re-explaining yourself. Again.

😌 With Stash

Hey, continuing work on my project.

Welcome back! Last time we finalized the pricing model for your restaurant SaaS. You were about to work on the onboarding flow. Want to pick up there?

Yes! Exactly that.

Great. You also mentioned you wanted to avoid Stripe's complexity — I have that noted. Here's where we left off...

✓ Picked up instantly. Zero repetition. Full context.

New session

❌ "Who are you again?"

✓ Picks up where you left off

Your preferences

❌ Re-explain every time

✓ Already knows them

Past mistakes

❌ Repeats the same errors

✓ Remembers what didn't work

Long projects

❌ Loses track of goals

✓ Tracks goals across weeks

Token cost

❌ Grows every session

✓ Only recalls what matters

Switching models

❌ Start from zero again

✓ Memory is model-agnostic

What is Stash

Not just memory.
A second brain.

Stash is a persistent cognitive layer that sits between your AI agent and the world. It doesn't replace your model — it makes your model continuous. Episodes become facts. Facts become patterns. Patterns become wisdom.

"Your AI is the brain. Stash is the life experience."

your agent

Claude, GPT, local model, anything

episodes

Raw observations, append-only

facts

Synthesized beliefs with confidence

relationships

Entity knowledge graph

patterns

Higher-order abstractions

goals · failures · hypotheses

Intent, learning, uncertainty

postgres + pgvector

Battle-tested infrastructure

Namespaces

Memory organized
like folders.

Not all memory is equal. What your agent learns about you is different from what it learns about a project, which is different from what it knows about itself. Namespaces let the agent organize what it learns into clean, separate buckets — just like folders on your computer.

Each namespace is a path. Paths are hierarchical. Reading from /projects automatically includes everything under /projects/stash, /projects/cartona, and so on. You never have to think about it — the agent does.

📁 Write to one namespace. Read from any subtree.

example namespace structure

📁 / everything

📁 /users/alice who alice is, her preferences

📁 /projects all projects

📁 /projects/restaurant-saas pricing, features, decisions

📁 /projects/mobile-app design, tech stack, goals

📁 /self agent self-knowledge

📄 /self/capabilities what I do well

📄 /self/limits what I struggle with

📄 /self/preferences how I work best

🔍

Recursive reads

Recall from /projects and get everything across all sub-projects automatically.

✏️

Precise writes

Remember always targets one exact namespace — no accidental cross-contamination.

🔒

Clean separation

User memory never mixes with project memory. Agent self-knowledge stays in /self.

agent session

Stash vs RAG

RAG gives your AI
a search engine.
Stash gives it a life.

You've probably heard of RAG — Retrieval Augmented Generation. It's clever. But it's not memory. Here's the difference, in plain English.

📚 RAG

"A very fast librarian"

You give it a pile of documents. When you ask a question, it searches those documents and hands you the relevant pages. That's it. It doesn't remember your conversation. It doesn't learn. It doesn't know you. Every question starts from scratch — it's just a smarter search engine over files you already wrote.

Only knows what's in your documents
Cannot learn from conversations
Cannot track goals or intentions
Cannot reason about cause and effect
Cannot notice contradictions over time
Stateless — no continuity whatsoever
You must write the knowledge first

🧠 Stash

"A mind that grows"

Stash learns from everything your agent experiences — conversations, decisions, successes, failures. It synthesizes raw observations into facts, connects facts into a knowledge graph, detects contradictions, tracks goals, and builds an understanding of you that deepens over time. You don't write anything. It figures it out.

Learns from every conversation automatically
Builds a knowledge graph over time
Tracks your goals across weeks and months
Reasons about cause and effect
Self-corrects when beliefs contradict
Continuous — picks up exactly where you left off
Creates knowledge — you don't have to

📚

RAG is like...

A brilliant intern who reads your files perfectly — but forgets everything the moment they leave the room.

→

🧠

Stash is like...

A colleague who was there from day one, remembers every decision you ever made, and gets more valuable every single week.

Can you use both? Yes — RAG is great for searching documents. Stash is for remembering experience. They solve different problems. Stash just goes much, much further.

Why Stash is Different

Everyone gave AI
a notepad.
We gave it a mind.

Claude.ai has memory. ChatGPT has memory. They only work for themselves — locked to one platform, one model, one company. Stash works for everyone, everywhere, forever. And it goes far deeper than any of them.

Remembers you

✓

Works with any AI model

✗

✓

Works with local / private models

✗

✓

You own your data

✗

✓

Open source

✗

✓

Background consolidation

✗

✓

Goals & intent tracking

✗

✓

Learns from failures

✗

✓

Causal reasoning

✗

✓

Agent self-model

✗

✓

What it gives your AI

A notepad

A mind

The Problem

🧠

Brilliant brain, no experience

AI models reason brilliantly but remember nothing. Every session you re-explain who you are, what you need, and what you've already tried. You're training the same student every single day.

💸

Context windows are expensive

The workaround is stuffing full conversation history into every prompt. It's slow, expensive, and you still hit the limit. You're paying for tokens that repeat the same facts over and over.

🔄

Agents repeat their mistakes

Your agent tried something, it failed, and next session it tries the exact same thing again. There's no mechanism to carry lessons forward. Every failure is forgotten.

🔒

Memory is a platform privilege

Only a handful of AI platforms offer memory — and only for their own models. Your custom agent, your local LLM, your Cursor setup? They all start blind. Memory shouldn't be a premium feature.

Express Setup

Up and running
in 3 commands.

No infrastructure to set up. No dependencies to install manually. Docker Compose handles everything — Postgres, pgvector, Stash, all wired together and ready.

Clone the repo

Copy .env.example → .env and set your API key + model preferences

Run docker compose up — that's it. Stash is live.

terminal

$ git clone https://github.com/alash3al/stash

$ cd stash

$ cp .env.example .env

# edit .env with your API key,

# models and STASH_VECTOR_DIM

$ docker compose up

✓ postgres + pgvector ready

✓ stash migrations applied

✓ mcp server listening

✓ consolidation running in background

⚠️ Set STASH_VECTOR_DIM in your .env before first run. It cannot be changed after initialization.

📝

Episodes

Raw observations stored as they happen

💡

Facts

Clustered episodes synthesized by LLM

🕸️

Relationships

Entity edges extracted from facts

🔗

Causal Links

Cause-effect pairs between facts

🌀

Patterns

Abstract higher-order insights

⚖️

Contradictions

Self-correction and confidence decay

NEW

🎯

Goal Inference

Facts automatically tracked against active goals. Progress detected, contradictions surfaced.

NEW

💥

Failure Patterns

Detect repeated mistakes. Extract failure patterns as new facts. The agent stops repeating itself.

NEW

🔬

Hypothesis Scan

New evidence passively confirms or rejects open hypotheses. No manual intervention needed.

MCP Integration

Two commands.
Any agent.

Stash speaks MCP natively. Drop it into Claude Desktop, Cursor, or any MCP-compatible agent in under 5 minutes. No SDK. No vendor lock-in. Your agent remembers you everywhere.

28 tools covering the full cognitive stack — from raw remember and recall all the way to causal chains, contradiction resolution, and hypothesis management.

Claude Desktop Cursor OpenCode Custom Agents Local LLMs Any MCP Client

stash · mcp stdio

$ ./stash mcp execute --with-consolidation

$ ./stash mcp serve --port 8080 --with-consolidation

✓ remember · recall · forget · init

✓ goals · failures · hypotheses

✓ consolidate · query_facts · relationships

✓ causal links · contradictions

✓ namespaces · context · self-model

Agent Self-Model

Your agent can
know itself.

Call init and Stash creates a /self namespace scaffold. The agent uses its own memory layer to build and maintain a model of its own capabilities, limits, and preferences.

/self/capabilities

What I can do well

The agent remembers where it excels and recalls these when planning how to approach a task.

/self/limits

What I struggle with

Recorded failures and known weaknesses. The anti-repeat mechanism. Never make the same mistake twice.

/self/preferences

How I work best

Learned preferences for how to operate. The agent develops a working style over time, not just facts.

Autonomous Loop

An agent that
never stops learning.

Give your agent a 5-minute research loop. It orients from past memory, researches a topic it chooses itself, invents new connections, consolidates what it learned, and closes gracefully — ready to pick up next time.

Run it as a cron job. Every 5 minutes, your agent gets smarter.

→ See the loop prompt

Orient

Recall context, active goals, open hypotheses, past failures

Research

Search the web on a topic the agent chooses itself

Think

Surface tensions, gaps, contradictions in what it now knows

Invent

Generate something new — a hypothesis, pattern, or discovery

Consolidate

Run the pipeline. Synthesize raw episodes into structured knowledge

Reflect + Sleep

Write a session summary. Set context for next run. Stop.

⚡

Stash itself runs on OpenRouter. The author runs Stash locally pointed at OpenRouter — access to hundreds of models, one API key, zero infrastructure.

☁️

Cloud APIs

OpenRouter gives you access to hundreds of models — GPT, Claude, Gemini, Mistral — all behind one OpenAI-compatible endpoint. Point Stash at it and pick any model for embedding and reasoning.

🏠

Local Models

Running Ollama locally? Stash works out of the box. Use Qwen, Llama, Mistral, or any model you've pulled — your memory stays fully private, fully offline.

🔧

Self-Hosted

vLLM, LM Studio, llama.cpp server, Together AI, Groq — if it speaks the OpenAI API format, Stash speaks it back. Same provider serves both models.

⚠️

Set STASH_VECTOR_DIM before your first run and never change it. pgvector locks the embedding dimension at initialization — changing it later requires a full database reset. The default embedding model is openai/text-embedding-3-small with STASH_VECTOR_DIM=1536.

.env — same provider for embedding + reasoning

STASH_OPENAI_BASE_URL=https://openrouter.ai/api/v1

STASH_OPENAI_API_KEY=sk-or-...

STASH_EMBEDDING_MODEL=openai/text-embedding-3-small

STASH_REASONER_MODEL=anthropic/claude-3-haiku

STASH_VECTOR_DIM=1536

STASH_OPENAI_BASE_URL=http://localhost:11434/v1

STASH_EMBEDDING_MODEL=nomic-embed-text

STASH_REASONER_MODEL=qwen2.5:3b

STASH_VECTOR_DIM=768

STASH_OPENAI_BASE_URL=https://api.groq.com/openai/v1

STASH_EMBEDDING_MODEL=openai/text-embedding-3-small

STASH_REASONER_MODEL=llama-3.1-8b-instant

STASH_VECTOR_DIM=1536

Give your agent
a memory.

Open source. Apache 2.0 licensed. Backed by PostgreSQL. Works with any MCP-compatible agent.

Hacker Times

Hacker Times

Open source memory layer so any AI agent can do what Claude.ai and ChatGPT do

Discussion

Discussion

Not just memory.
A second brain.

Memory organized
like folders.

RAG gives your AI
a search engine.
Stash gives it a life.

Everyone gave AI
a notepad.
We gave it a mind.

Brilliant brain, no experience

Context windows are expensive

Agents repeat their mistakes

Memory is a platform privilege

Up and running
in 3 commands.

Two commands.
Any agent.

Your agent can
know itself.

An agent that
never stops learning.

Cloud APIs

Local Models

Self-Hosted

Hacker Times

Hacker Times

Open source memory layer so any AI agent can do what Claude.ai and ChatGPT do

Discussion

Discussion

Not just memory.A second brain.

Memory organizedlike folders.

RAG gives your AIa search engine.Stash gives it a life.

Everyone gave AIa notepad.We gave it a mind.

Brilliant brain, no experience

Context windows are expensive

Agents repeat their mistakes

Memory is a platform privilege

Up and runningin 3 commands.

Two commands.Any agent.

Your agent canknow itself.

An agent thatnever stops learning.

Cloud APIs

Local Models

Self-Hosted

Not just memory.
A second brain.

Memory organized
like folders.

RAG gives your AI
a search engine.
Stash gives it a life.

Everyone gave AI
a notepad.
We gave it a mind.

Up and running
in 3 commands.

Two commands.
Any agent.

Your agent can
know itself.

An agent that
never stops learning.