Every AI agent's memory,
in one place you control.
scritty is a terminal emulator. Run any AI CLI inside it; scritty detects the agent, captures every exchange, tags it with the provider, and indexes it for search. Your captures stay on your machine. No copy-paste, no per-vendor silos.
Four agents. One memory.
Claude Code, Codex, Copilot, and Gemini run on one project and share memory across sessions; then the operator control plane shows per-org search isolation, audit, and a read-only index attached and dropped live, on camera.
Context dies at the boundary between tools.
one project.
Claude for architecture, Codex for tests, Copilot for boilerplate, Gemini for research, Ollama on a plane. Every tool is its own silo, and none of them know what the others said.
You re-explain decisions. You repeat yourself. You lose work.
- Each vendor keeps its own log, in its own format, in its own silo.
- No cross-agent search. No embeddings. No shared corpus.
- The decision your Claude session made is invisible to Codex.
- So you paste context between tools by hand, or just lose it.
Start on your desktop. Continue on your phone.
The desktop terminal embeds a web server. Open the same session from any device on your network and you are in one shared PTY: same output, same keystrokes, live in both directions. Switch a tab on the desktop and your phone follows; drop the connection and it reconnects on its own.
- One shared PTY across desktop, browser, and mobile; either side drives the same session.
- Install it as a PWA (Add to Home Screen on iOS or Android); offline-aware, auto-reconnects when scritty comes back.
- The mobile UI adapts: touch-friendly targets, a full-width exploration panel, swipe to scroll the live terminal.
- Scan the startup QR to pair a phone in seconds; reach it from outside your LAN over a Tailscale Funnel with a trusted cert.
- Search every agent and session from your phone, the same corpus as the desktop.
Monitor a long-running agent from the couch, review output on the train, or fire off a prompt from anywhere on your network.
How it works, in one line.
# Monday Claude refactors auth middleware -> captured # Tuesday Codex writes tests for the refactor -> captured # WednesdayCopilot scaffolds the API routes -> captured # Thursday Gemini researches OAuth2 PKCE -> captured # Friday Ollama (offline) ties it together -> captured search> auth decisions 14 matches / 5 sessions / 5 providers / one unified view same results on your phone, laptop, or any browser
The terminal is the one boundary every CLI agent has to cross. scritty captures it there, so capture is agent-agnostic by construction and the corpus is yours.
Your agents query the memory. Not just you.
Capture is only half of it. The corpus is a substrate, not a side panel: one engine, reachable three ways. A human at a keyboard, an agent over MCP, and a shell script all read and write the same data with the same behavior.
Press Ctrl+Shift+M to search every agent and session inline, without leaving the terminal.
Expose the corpus over MCP -- stdio for local agents, or Streamable HTTP for remote and multi-machine agents, with bearer-token auth and per-tenant routing. Any agent can search its own and other agents' prior turns.
Scriptable access to the same store -- list, read, and search sessions from any shell or pipeline.
// stdio -- local agents (Claude, Codex, Copilot, ...)
{
"mcpServers": {
"scritty": { "command": "scritty", "args": ["serve"] }
}
}
# Streamable HTTP -- remote / multi-machine agents
$ scritty serve --http --bind 127.0.0.1 --port 8081
scritty HTTP MCP listening at http://127.0.0.1:8081/mcp
(bearer-token auth, per-tenant routing) $ scritty memory cross-session-search \ --query "auth refactor" --limit 10 14 matches / 5 sessions / 5 providers $ scritty memory read-session --session-id abc-123 full conversation, every agent, as text
Terminal, MCP, and CLI share one MemoryService -- same data, same behavior. The HTTP transport is the standard MCP Streamable HTTP endpoint (/mcp), so any compliant client connects with a bearer token. The corpus is also exposed as MCP resources (memory://sessions, memory://search) for agents that read resources instead of calling tools.
Five things nothing else does together.
Agent-agnostic capture
The terminal sits upstream of every CLI agent. Whatever you launch (Claude Code, Codex, Copilot CLI, Gemini, Aider, Ollama) gets captured without vendor cooperation, plugins, or wrappers.
Process-level provider detection
/proc on Linux, NtQueryInformationProcess on Windows. Every exchange is tagged with the provider that produced it. No prompt sniffing, no heuristics.
One corpus across vendors
Your Claude session about an OAuth bug and your Codex session two weeks later about the same bug live in the same store, in one query.
Hybrid search
Vector plus keyword search fused with Reciprocal Rank Fusion. Dual ONNX embeddings: jina 768d for code, MiniLM 384d for prose. Press Ctrl+Shift+M and search everything.
Pluggable vector backend
cosynt (default, embedded), qdrant, pgvector, chroma, weaviate, all behind one trait, with dimension and fingerprint enforcement and atomic blue/green rev swaps.
In the gap nothing else fills.
| You currently use | What it does | What it does not do that scritty does |
|---|---|---|
| Warp | Agentic terminal with its own AI | Captures only Warp's own agent. Claude Code, Codex, Aider running inside it are invisible. Cloud-tied. |
| Cursor / Continue / Cody | IDE-side AI with codebase indexing | Indexes your code, not your conversations. Lives in an editor, not a terminal. |
| mem0 / Letta / Zep / Cognee | Memory-as-a-service and agent runtimes | A library; you build the agent that uses it. No terminal, no auto-capture, mostly cloud. |
| Per-vendor session logs | Claude Code memory, Codex sessions, Copilot history | Siloed by vendor, one format each, no cross-agent search, no embeddings, no shared corpus. |
| asciinema / ttyrec / script(1) | Terminal recorders | Capture bytes. No agent detection, no parsing, no semantic search. |
| scritty | Every CLI agent captured at the terminal, into one searchable corpus you control | n/a |
scritty sits between AI terminals (which own the surface but not cross-agent memory) and agent memory layers (which own memory but make you build the agent). It is the only one that captures every CLI agent at the OS boundary they all share: the terminal.
Local-first architecture. Paid product.
Your captures live on your machine and the data stays yours; that is the architecture, not the price. scritty is a paid product with no permanent free tier. You evaluate it with a capped pilot, then meter by captured exchange volume. There is no per-seat pricing, ever.
- Full Pro feature set on shared infra
- Self-serve; converts to a paid tier
- Captures stay local after the cap
- Central federation, one org
- Tenant-scoped isolation
- Google / GitHub SSO
- Everything in Pro, plus SAML SSO
- 90-day audit retention
- Email and chat support
- Multi-org federation, dedicated isolation
- BYOK, custom DPA, 99.9% SLA
- Hybrid keeps captured data in your cloud
Own the entire stack. Nothing leaves your walls.
Run scritty end to end in your own environment: your infrastructure, your network, your data. No shared infra, no hybrid dependency, full data sovereignty. Built and priced for your org, your compliance posture, and your scale.
Metered by exchange-pairs (one prompt plus its reply counts as one pair; the reply is not billed separately), not seats. One power user is roughly 4,800 pairs/mo; a 10-developer team lands near 60k-100k. Request a pilot and we will scope it to your fleet.
One terminal for every agent.
Every conversation, searchable.
Run any AI CLI inside scritty and it captures, tags, and indexes every exchange on hardware you control. You own your context; no agent gets to forget it.
- Full Pro feature set, capped at 25,000 pairs or 35 days.
- Run Claude, Codex, Copilot, Gemini, Aider, Ollama; all captured.
- Ctrl+Shift+M to search every agent, every session, in one place.
- Open the same session on your phone or any browser as a PWA.
- Central Plane for shared cross-team search, self-hosted or managed.
- Per-org isolation, audit, OIDC and SAML, configurable telemetry.
- No per-seat pricing; metered by captured exchange volume.
- Enterprise Hybrid keeps captured data in your own cloud.