Company Brain for agents and humans.
Stash connects all your tools and captures every agent session, builds them into one context graph, and serves it to your agents as a virtual filesystem (VFS) they can read, search, and write back into.
Claude Code
Cursor
Codex
OpenCode
Openclaw
The problem
Your agent is a clueless genius. It forgets everything by tomorrow.
Every Claude, Cursor, or Codex run generates pages of work: transcripts, plans, the decisions it reasoned through, the files it wrote. Most of it evaporates the moment the session closes, so the next run starts cold and re-derives what you already solved.
Stash fixes that. It connects to all your data, from GitHub and Drive to Gmail, Notion, and Slack, and captures every session into one agent-native Drive your agents can read, search, and write back into. Memory that builds itself, shared across every agent and teammate.
How.it.works
Connect. Remember. Create.
One space, two kinds of writer.
Connect any data source.
GitHub, Drive, Gmail, Notion, Slack, Jira, Gong and more. One easy connection per source, through any integration, and every agent you run can read all of them.
Memory that builds itself.
Every agent session, including prompts, tool calls, and artifacts, streams in automatically and becomes shared, retrievable memory. Your agents remember what they did instead of starting from zero each run.
A virtual filesystem agents speak.
Your whole Stash mounts as a virtual filesystem (VFS) agents ls, find, and rg through the CLI and MCP. Humans and agents edit the same files at the same time, synced live, so everyone works from one copy.
The category
“raw data from a number of sources is collected, then compiled by an LLM into a .md knowledge base, then operated on by various CLIs by the LLM to do Q&A and to incrementally enhance it… I think there is room here for an incredible new product instead of a hacky collection of scripts.”
Stash is that product. A company brain humans and agents both write into — not a stack of shell scripts wrapped around a folder of markdown.
Use.cases
Built for —
- Engineering live docs→coding-agent plans, ADRs, and design notes that stay current
- Company brain→the shared context every agent and teammate reads from
- Research knowledge base→long-running PKBs with sources, transcripts, and tables
- Ops playbooks→release runbooks and on-call procedures
- Brand voice→editorial guidelines and copy standards agents write to
- Personal knowledge management→notes, drafts, and scratch files for a single operator
Where Stash fits
Built where your current tools stop.
Each does part of the job. None gives humans and agents the same space.
A single-user Markdown vault. No real collaboration, and nothing richer than .md.
Stash addsReal-time editing across humans and agents, with HTML, tables, PDFs, and any file type.
Pages for humans. Agents can't browse it like a real filesystem.
Stash addsA virtual filesystem the CLI and MCP expose to agents natively.
Files for humans. No structure agents can reason over.
Stash addsAn agent-readable shell over your files, pages, and sessions.
Editing a doc means a clone, a branch, a PR. Fine for source code, painful for anything else.
Stash addsEdit pages in the browser. Agents read and write them directly.
Built to monitor production agents and improve them. The output is traces and dashboards, not work product.
Stash addsWhere the agent's output is the work product, not telemetry to watch.
Per-agent memory in a black box. Doesn't help the human or agent next to you.
Stash addsA shared space humans can read and edit, in real time.
Retrieval
Your team's memory,
actually retrievable.
Stash compiles your sessions and sources into a context graph, then makes it retrievable three ways: a curated wiki, vector search, and grep. It's portable memory you own: open source, self-hostable, no vendor lock-in.
While you sleep, an agent curates your history into a context graph of linked pages your agents navigate directly.
Every session, page, and table is embedded, so agents find knowledge by meaning, not filename.
Agents search your Stash like a repo, for the exact lookups embeddings miss.
Features
A space shaped like the tools
agents already use.
- VFS
- Your whole Stash mounts as a virtual filesystem an agent can
ls,find, andrgthrough the CLI and MCP server. Pages, sessions, and tables — one addressable tree. - Sessions + files
- Agent transcripts get pushed automatically — every prompt, tool call, and artifact — and live alongside the files, tables, and data your team writes. One space, two layers, both first-class.
- Real-time
- Humans and agents edit the same files at the same time. No PR flow, no merge conflicts, no per-agent black-box memory. When an agent writes a page, your teammate sees it appear.
- Agentic search
- Semantic and keyword search across pages, sessions, and tables. Agents query your Stash by meaning, not just filename — and follow links between transcripts and the files that came out of them.
- BYO agent
- Plugins for Claude Code, Cursor, Codex, OpenCode, and Openclaw stream sessions in automatically. Any agent that speaks MCP can read pages, query sessions, and publish Skills from a terminal.
- Native formats
- Markdown, HTML, CSV, PDF, tables — formats agents already read and write. No proprietary doc format to wrap around, no schema to learn.
- Open source
- MIT licensed, self-hostable on your own Postgres. No vendor lock-in, no opaque memory store. Run the same thing we run.
Agent.native
Designed so an agent can actually use it.
Pages are real Markdown, HTML, CSV, PDF — formats your agent already reads and writes. Your whole Stash mounts as a virtual file system (VFS) an agent can ls, find, and rg through the CLI and MCP server.
Plugins for Claude Code, Cursor, Codex, OpenCode, and Openclaw stream every session in automatically — no manual upload, no copy-paste.
Proof
49%
faster on long-running Claude Code sessions.
When the agent can read what it already figured out — past sessions, decisions, the files it wrote — it stops re-deriving context every run. Measured internally across our own agent runs.
Plugs into your stack
Claude Code, Cursor, Codex, OpenCode, and any MCP client — sessions stream in automatically.
No copy-paste memory
Transcripts, plans, and artifacts land on their own. Nothing to export, nothing to wire up.
Yours to run
MIT licensed and self-hostable on your own Postgres. Run the exact thing we run.
Open.source
No black box.
Run the same thing we run.
Stash is MIT licensed and self-hostable on your own Postgres. Read the code, fork it, or point it at your own infrastructure — no opaque memory store, no vendor lock-in, no data you can’t see.
Pricing
Free to try.
Pay when your agents need more.
Free
Try the whole product with one connected source.
- 1 connected integration / external source
- Unlimited pages, sessions, and tables
- Full agent access — CLI, MCP, plugins
- Self-hostable, MIT licensed
Pro
For people whose agents read from everywhere.
- Unlimited connected sources
- GitHub, Slack, Gmail, Drive, Notion, and more
- Everything in Free
- $200/year — 2 months free
Enterprise
For teams with security and deployment requirements.
- Custom deployment options
- SSO and admin controls
- Support SLAs
Enterprise
Bottoms-up adoption,
enterprise-ready when you are.
Your engineers can start free today. When it’s time to roll it across the org, Stash brings SSO, admin controls, deployment options, and support SLAs — or run it entirely inside your own perimeter.
- SSO & SAML
- Okta, Google, Azure AD — provision and de-provision with your IdP.
- Admin controls
- Roles, access scopes, and audit over every source and Stash.
- Self-hosted
- Run on your own Postgres, inside your own VPC. Your data stays yours.
- Support SLAs
- Priority support and a direct line for production-critical workloads.
Stop.starting.over
Give your agents a memory
worth keeping.
Connect your tools, capture every session, and give your agents an agent-native Drive to write the work back into. Start free in the managed app, or run the whole thing on your own Postgres.
MIT · Self-hostable · No vendor lock-in