stashai 0.1.338

CLI for Stash — shared memory for AI coding agents

Knowledge bases for the agent era.

The one place your agents connect to all your data — GitHub, Drive, Gmail, Notion,
Slack, Linear, Jira, Asana, Granola and more — plus an agent-native Drive in
Markdown and HTML where their sessions, files, and pages all land.

When we tested this internally, we found that it sped up long-running instances of Claude Code by 49%.

How it works

• Sessions stream in automatically. A hook for your coding agent pushes every transcript — prompts, tool calls, artifacts — into your Stash.
• Files and sessions live side by side. Markdown, HTML, tables, PDFs. You and your agents both write here; both sides see edits in real time.
• Agents query it like a filesystem. A CLI, MCP server (~70 read/write tools), REST API, and virtual-filesystem shell expose your Stash to any agent. One search spans your pages, sessions, and every connected source at once.
• There's an agent in the box too. Chat with an agent that already has all of this — in the app, from Slack, or from Telegram. It's a real coding-agent CLI (Claude Code, Codex, or opencode) running on your own cloud VM, so it can read, write, and run things. Give it a cron and it becomes a scheduled agent.
• Memory is a wiki an agent keeps for you. A scheduled curator reads whatever is new since its last run — sessions, files, saves — and compiles it into linked pages: entities, concepts, and a running log. It writes only inside the reserved Memory folder, and never reads its own output.
• Skills are the shareable slice. A Skill is just a folder with a SKILL.md in it — put the pages, files, and tables that belong together in one folder and it becomes shareable as a unit. Publish it to the world, fork a public Skill into your own Stash, or stash skills install one into your agent — installed skills auto-update at session start, and stash skills follow auto-installs skills people share with you.
• Bring your own MCP servers. Register MCP servers once (Tools page or stash tools add); your cloud agent gets them automatically and stash tools install writes them into any local agent's .mcp.json.

Why persistent beats per-session

When you run Claude on a repo, you generate valuable session transcripts. However, your coding agent can only access transcripts generated on the machine where the agent is currently running. As a result, work is duplicated and velocity is decreased. This is especially true as coding agents begin to run autonomously for significant periods of time.

With Stash, every agent run has context about every session you've created. Here are some use cases:

• Code Faster / Don't Duplicate Work: "Have I tried fixing the memory leak in our API gateway before? What was attempted?"
• Stay Organized: "What did I get done this week? What other work did I do that isn't tracked in Git?"
• Recover Lost Context: "Why did I increase the timeout to 30s? The git history is unhelpful."
• Pick Up Where You Left Off: "Please add a feedback endpoint to our API" -> Claude: "FYI, you decided earlier not to add a feedback endpoint since we want to encourage churned users to hop on a call directly"

"raw data from a given 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."

— Andrej Karpathy, LLM Knowledge Bases

Stash is that product. The one place your agents connect to all your data, with an agent-native Drive they write it back into — not a stack of shell scripts wrapped around a folder of markdown.

Built for —

Use case	What teams put in it
Engineering live docs	coding-agent plans, ADRs, and design notes that stay current
Second brain	the persistent context every one of your agents 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

Quick Start

uv tool install stashai
stash signin

stash signin authenticates you in the browser, asks whether you want to share your agent transcripts, then finds the coding agents installed on your machine and installs hooks for the ones you pick. It offers to connect the repo you're standing in and to import conversations you've already had. Use stash connect later when you're already signed in and only need to bind another repo.

Prefer a one-liner?

bash -c "$(curl -fsSL https://joinstash.ai/install)"

The installer uses uv to install or update stashai, bootstrapping uv when needed, and then runs stash signin. Use this when you don't already have a Python toolchain on your machine.

Then try it: ask your coding agent if it has access to Stash.

Agents can browse Stash with an app-level virtual filesystem shell:

stash vfs ls /
stash vfs "tree / -L 2"
stash vfs "find / -maxdepth 3 -type f | head -n 20"
stash vfs "rg \"database migration\" /"

Connected sources

Connect a source once and every agent you point at Stash can read and search it.

Source	What lands in your Stash
GitHub	Repo contents, indexed for search — one repo, a pick-list, or every repo you can see
Google Drive	Your Drive, searchable by name and path; pick a folder to extract full contents (PDFs and scans included)
Gmail	Recent mail, with search federated live to Gmail. Multiple mailboxes supported
Slack	Messages from the channels you choose, filed as a transcript per channel per day
Notion	Pages and database rows as Markdown
Linear / Jira / Asana	Issues and tasks, indexed by team, project, or board section
Granola	Meeting notes and transcripts
PostHog	Dashboards, insights, feature flags, and experiments
X	Your bookmarks, posts, replies, and articles — with thread context and media archived
Instagram	Saved posts and reels, captured by the browser extension

You can also drop in an Obsidian vault, and the Chrome extension adds a web clipper, a bookmark importer, YouTube transcripts, and your ChatGPT and Claude.ai conversations.

Slack and Linear push changes to Stash over webhooks; everything else syncs on a schedule. Pick Slack's channels yourself — nothing is indexed until you do.

Coding agents

Stash supports the following coding agents:

• Claude Code
• Cursor
• Codex
• OpenCode
• Gemini CLI
• Openclaw
• Hermes

Stash supports opt in per-coding agent. stash signin detects every agent on your machine and auto-installs its hooks — pick which ones during signin. Mix and match — different teammates can use different agents against the same shared brain. (Openclaw's code scanner requires its unsafe-install flag, which the installer passes; Hermes asks you to approve the hooks once via hermes hooks list.)

CLI Reference

See here for a CLI reference.

Self-Hosted

Run Stash with prebuilt GHCR images:

To host locally:

git clone https://github.com/Fergana-Labs/stash.git
cd stash
cp .env.example .env
docker compose -f docker-compose.prod.yml -f docker-compose.local.yml pull
docker compose -f docker-compose.prod.yml -f docker-compose.local.yml up -d
curl http://localhost:3456/health
open http://localhost:3457/login

Docker Compose generates and persists the OAuth token encryption key when INTEGRATIONS_ENCRYPTION_KEY is unset. Set it yourself only if you manage deployment secrets outside Compose.

For a public domain with Caddy and HTTPS:

# Set PUBLIC_URL and CORS_ORIGINS in .env, then replace app.example.com in Caddyfile.
docker compose -f docker-compose.prod.yml pull
docker compose -f docker-compose.prod.yml up -d
curl https://app.example.com/health

docker-compose.prod.yml pins the image versions it was tested with. To upgrade, pull the latest compose file and restart:

git pull
docker compose -f docker-compose.prod.yml -f docker-compose.local.yml pull
docker compose -f docker-compose.prod.yml -f docker-compose.local.yml up -d

Then install the CLI:

uv tool install stashai
cd /path/to/the/repo/you/want/to/connect
stash signin   # choose "Self-host" and enter http://localhost:3456

When connecting to a domain-backed install, enter your public URL (e.g. https://app.example.com) at the same prompt. To change the endpoint later, run stash settings.

Finally see it in action:

claude
> what did I get done last week? check stash.

Privacy

Stash is built for engineering teams working in private repos.

• LLM calls are optional and scoped. An Anthropic key powers ask-the-stash, session titles, and OCR for scanned PDFs; the chat agent runs on Anthropic, OpenAI, or OpenRouter with your own key. Without any of them, the rest of Stash works — those features are simply unavailable.
• Private by default. Your Stash is yours alone. Content becomes public only when you make it so: publishing a Skill, creating a public link to a page, file, folder, or table, or posting to the pastebin.
• Transcripts are opt-in. If you don't want to upload your agent transcripts, you can give your agent read access to your Stash without uploading any of your own session data.

FAQ

What LLMs does Stash use? An Anthropic key covers ask-the-stash, session titles, and scanned-PDF OCR. The chat agent is separate and runs whichever harness you point it at — Claude Code, Codex, or opencode — against your own Anthropic, OpenAI, or OpenRouter credentials. Embeddings are a third, independent choice (OpenAI, HuggingFace, or a local model). All of it is optional; without any keys the rest of Stash works and those features are disabled.

What writes to my Stash on its own? One thing by default: the Memory curator, a scheduled agent that compiles your Memory wiki from new sessions and files. It only writes inside the reserved Memory folder, and it only reads what's new since its last run. Beyond that, nothing runs unless you create it — any agent you give a cron to becomes a scheduled agent, and those have the same reach you do.

Can I use this without Claude Code? Yes. You can use the CLI with anything, and Stash has native plugins for Cursor, Codex, Opencode, Gemini CLI, and more.

Contributing

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

Found a bug? Open an issue.

License

MIT — Copyright (c) 2026 Fergana Labs

---

Built by Fergana Labs.