stash

Agent memory for your repos.

Stash is the hive mind for your team's coding agents. Every session, decision,
and search flows into one shared brain. The next agent that touches your
repo already knows what's been learned.

Shared agent memory can save up to 46% of your team's coding work
that's otherwise wasted re-investigating fixes an earlier session already tried and ruled out.

Table of Contents

• Why Stash
• How it works
• Quick Start
• Features
• What you get
• Integrations
• Coming from...
• CLI
• Self-Hosted
• Privacy
• Documentation
• FAQ
• Latest updates
• Contributing
• License

Why Stash

Every coding agent on your team starts from zero. Your agent just debugged a flaky auth test. An hour later, a teammate's agent hits the same test and starts from scratch. Multiply that across a week and half the team is reinventing the same fixes.

With Stash, every agent on the repo can ask (and answer):

• "Why did Sam bump the rate limit from 100 to 500?"
• "Has anyone already tried fixing the memory leak in auth?"
• "What pattern did we land on for background workers last sprint?"

"raw data from a given number of sources is collected, then compiled by an LLM into a .md wiki, then operated on by various CLIs by the LLM to do Q&A and to incrementally enhance the wiki… I think there is room here for an incredible new product instead of a hacky collection of scripts."

— Andrej Karpathy, LLM Knowledge Bases

Stash is that product. For teams of coding agents working on the same repo. Your agents' streamed sessions are the raw data. The wiki is curated automatically by our sleep agent. Everything lands in one workspace your whole team can query.

How it works

Stream → Curate → Search. Three steps running over a shared workspace:

1. Stream — Prompts, tool calls, and session summaries automatically push to the workspace's history as they happen. Nothing to remember to save.
2. Curate — On SessionEnd, a curation agent reads recent history and organizes it into wiki notebooks with [[backlinks]] and a page graph. Sleep-time compute, not session time. Auto-runs with a 24h cooldown; trigger manually with the /curate slash command.
3. Search — stash search via Stash's CLI runs a cross-resource agentic loop over files, history, notebooks, tables, and chats. Your agent answers with sources, not hallucinations.

Quick Start

One line installs the CLI, signs you in, picks a workspace, and installs plugins for your coding agent (currently supports Claude Code, Cursor, Codex, Openclaw, and OpenCode):

bash -c "$(curl -fsSL https://raw.githubusercontent.com/Fergana-Labs/stash/main/install.sh)"

Then try it:

stash history search "authentication patterns"      # Full-text search over events
stash history push "session notes here"             # Push an event
stash --help                                        # Full command list

pipx install stashai        # or: uv tool install stashai
stash connect               # Interactive: sign in, pick a workspace, install plugin

Features

What you get

Stash organizes your team's agent activity into a workspace that looks like this:

your-workspace/
├── history/                       # append-only event log — every prompt, tool call, summary
│   └── (streamed live from every agent + human)
├── notebooks/                     # auto-curated wiki, written by stash:sleep
│   ├── auth-patterns.md           #   ...with [[backlinks]] between pages
│   ├── memory-leak-v2.md          #   ...folder structure inferred from your work
│   └── rate-limits/
│       ├── gateway-500-per-min.md
│       └── batch-import-flow.md
├── tables/                        # structured data with optional row embeddings
└── files/                         # PDFs, screenshots, attachments (S3-compatible)

A live page graph, embedding projection, and knowledge-density treemap render over the same workspace — the visualizations you see in the GIFs above.

Integrations

The one-line installer auto-detects which agent you have and wires up the plugin. To install one manually:

Every plugin streams session activity to the same workspace, injects relevant memory into prompts, and uses the shared stash CLI underneath. Mix and match — different teammates can use different agents against the same shared brain.

Coming from...

Stash sits alongside whatever you have today. Here's how it maps:

CLI

stash connect                        # Configure API key + default workspace
stash history push <content>         # Push an event
stash history search <query>         # Full-text search over history events
stash notebooks list --all           # List notebooks across your workspaces
stash --help                         # Full command list

Every command accepts --json for machine-readable output and --ws ID to target a specific workspace. Full reference at joinstash.ai/docs/cli.

Self-Hosted

git clone https://github.com/Fergana-Labs/stash.git
cd stash
cp .env.example .env          # fill in credentials + API keys
# edit Caddyfile → replace app.example.com with your domain
docker compose -f docker-compose.prod.yml up -d

Brings up four containers: PostgreSQL 16 + pgvector, FastAPI backend (:3456), Next.js frontend (:3457), and Caddy for automatic HTTPS via Let's Encrypt. Alembic migrations run on backend startup.

Embeddings default to local sentence-transformers — no API keys required to run. Set EMBEDDING_PROVIDER to switch to OpenAI, Hugging Face, or any OpenAI-compatible endpoint. Optional S3-compatible object storage (R2, S3, MinIO) for file uploads.

Local development? Use docker compose up -d (no -f flag) — simple setup with hardcoded dev credentials.

Privacy

Stash is built so you can keep your team's memory under your control:

• Transcripts are opt-in. You can give your agent shared read access to the workspace's memory without uploading any of your own session data.
• No LLM calls from the server. Curation and search run inside your agent (Claude Code, Cursor, etc.) using the keys it already has. The Stash backend itself makes no model calls.
• Self-hostable end-to-end. One Docker Compose file. PostgreSQL + pgvector, local sentence-transformer embeddings, no required external API keys.
• Permissioned workspaces. On the hosted version, only invited members can read or write a workspace. Public visibility is per-resource, opt-in.

Documentation

FAQ

What LLMs does Stash use?
None on the server. Curation and agentic search run inside your agent (Claude Code, Cursor, etc.) as plugin skills, so they use whatever model and keys the agent is already configured with — the Stash backend itself makes no LLM calls. Embeddings are pluggable and default to local sentence-transformers (no key). Set EMBEDDING_PROVIDER in .env to switch to OpenAI, Hugging Face, or any OpenAI-compatible endpoint.

Can I use this without Claude Code?
Yes. The CLI and REST API work standalone with any client, and there are first-party plugins for Cursor, Codex, OpenCode, Gemini CLI, and Openclaw.

Where does the "save up to 46%" number come from?
A 4-session memory-leak benchmark documented in On Agent Velocity by Henry Dowling (one of Stash's maintainers). Without transcript sharing, nearly half of agent actions re-investigated fixes earlier sessions had already tried and ruled out. With shared transcripts, wasted work dropped ~97% and tool calls dropped ~50%.

Latest updates

• 2026-04-22 — Initial open-source release

For the full log, see CHANGELOG.md.

Contributing

Contributions are welcome. See CONTRIBUTING.md to get started.

Found a bug? Open an issue.

Maintainers

License

MIT — Copyright (c) 2026 Fergana Labs

Built by Fergana Labs.