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 both sides of every exchange -- your prompts and the agent's replies -- tags each with the provider, and indexes it for search. Then it serves that memory back -- to your agents over MCP, and to you over the CLI. On Linux and Windows, set it as your system's default terminal, and every shell your desktop, editor, or file manager opens is already scritty -- already capturing. Your captures stay on your machine. No copy-paste, no per-vendor silos. One agent gives you a searchable memory of your own work; every agent you add shares the same corpus.
Four agents. One memory.
Copilot, Codex, Claude Code, and Antigravity run on one project and share memory across sessions; then the same memory is searched from the terminal panel and the CLI, synced to a browser and a paired phone, run offline with local Ollama models, and federated into an operator control plane with per-tenant isolation and audited admin overrides.
Context dies at the boundary between tools.
one project.
Claude for architecture, Codex for tests, Copilot for boilerplate, Antigravity 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.
One process. Two live views.
The desktop terminal embeds a token-secured web server. Open that URL in any browser -- on the same machine or another device on your network -- and you are looking at the exact same PTY and the same memory panel. Type on the desktop and the browser updates; type in the browser and the desktop updates. One process, two views, byte-for-byte in sync.
- A per-session bearer token rides in the URL; nothing is shared until you hand out the link.
- Install it as a desktop PWA (Chrome / Edge "Install app") -- a standalone window, no browser chrome.
- A trusted cert unlocks secure-context features, so the browser treats it like a first-class app.
- The browser is not a read-only mirror: it drives the same session, memory, and search as the desktop.
Start on your desktop. Continue on your phone.
Your desktop session is reachable from your phone the moment scritty is running. Scan the pairing QR and the same live terminal -- scrollback, memory panel, and all -- opens on your phone. Switch a tab on the desktop and your phone follows; drop the connection and it reconnects on its own.
- Pair in seconds with the startup QR; reach it from outside your LAN over a Tailscale Funnel with a trusted cert.
- 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.
- Drive the session from the phone -- keystrokes reach the same PTY as the desktop, not a read-only view.
- Search every agent and session from your phone, the same corpus as the desktop.
- Locked down by default: TLS is always on (no plain-HTTP mode), every connection is bearer-token gated with only the token's hash stored, a CIDR allowlist sits in front, and reaching it beyond your LAN takes an explicit opt-in.
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 Antigravity 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 rules. Every agent. Every message.
Capture is the inbound half. On the way out, scritty assembles every message before it reaches the agent: it folds in your standing instructions, enforcement rules, the current goal, and the provider's own rule file -- so the same rules apply whether you're in Claude, Codex, Copilot, or Antigravity.
- Write your instructions once in prompt.toml; stop re-typing and re-pasting them into every tool.
- Reads each vendor's native rule file too: .claude/CLAUDE.md, AGENTS.md, copilot-instructions.md, GEMINI.md.
- Every section toggles live from the terminal -- flip a rule off for one message, back on for the next.
- Then press Ctrl+Shift+M to query your whole substrate inline, without leaving the terminal.
Your standing instructions from prompt.toml -- written once, applied to every agent.
Hard constraints that get injected on every send, not politely suggested once.
The current objective, kept in front of the agent so it doesn't drift.
Tone classification and control signals assembled before the message leaves.
Open cross-agent search in a side panel, in the same terminal -- native or browser.
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.
Close it. Reopen it. Right where you left off.
Quit with a dozen tabs open across a dozen projects, and the next launch brings every one back -- each shell already in the directory you left it. Like a browser restoring your tabs, for your terminal.
Six things nothing else does together.
Agent-agnostic capture
The terminal sits upstream of every CLI agent. Whatever you launch (Claude Code, Codex, Copilot CLI, Antigravity, Grok, Aider, Ollama) gets captured without vendor cooperation, plugins, or wrappers.
Process-level provider detection
It reads the process running in the terminal, not the prompt text, so both sides of every exchange -- what you send and what the agent answers -- are captured and tagged with the provider that produced them. 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 offline ONNX embeddings, one tuned for code and one for prose. Press Ctrl+Shift+M and search everything.
Pluggable vector backend
A built-in embedded engine by default, or qdrant, pgvector, chroma, weaviate, all behind one trait, with dimension and fingerprint enforcement and atomic blue/green rev swaps.
Yours at rest
Captures stay on your machine, and opt-in at-rest encryption locks the whole local store -- transcript, keyword index, and vector index -- under a passphrase only you hold, so nothing is readable to another process, another agent, or a synced backup. Agents reach memory over scoped tokens, so one can be pinned to a single session and can't widen to the whole corpus.
In the gap nothing else fills.
| You currently use | What it does | What it does not do |
|---|---|---|
| iTerm2 / Alacritty / Windows Terminal | A traditional terminal emulator | Renders a shell, nothing more. No agent detection, no capture, no memory. scritty is a drop-in system default terminal (Linux x-terminal-emulator, Windows DefTerm handoff) that renders your shell and captures every agent inside it. |
| 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 | Bring its own agent or model. It captures the ones you already run. |
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.
One control plane for your whole team.
Roll scritty out to your team and every member's captures land in one control plane for your org, isolated from everyone else's. Admin search is gated by compliance role: a member's private sessions stay private, while team-marked work is searchable across the org. Members, billing, seats, audit, license, SSO and SAML are each a tab.
Local-first architecture. Paid product.
Your captures live on your machine and the data stays yours; that is the architecture, not the price. Solo devs start on Personal; teams meter by captured exchange volume. There is no per-seat pricing, ever.
One dev, every agent, on your own machine.
Runs fully local: your captures never leave your machine. No team, no central plane, no cloud account -- just a license key. The same capture, dual-embedding search, MCP, and CLI the bigger tiers get, sized for one person.
- Full Pro feature set on shared infra
- Converts to Pro / Pro Plus / Enterprise
- Solo dev? Use the Personal Pilot instead
- 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. Start a Team Pilot - 25,000 pooled pairs or 35 days, 3+ seats.
The Personal Pilot and Team Pilot are limited-time offers and may be changed or ended at any time. Ending a Pilot program does not affect anyone already on an active Pilot trial; current trial users keep their Pilot through its stated term.
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.
- Free 14-day Personal Pilot, then Personal at $19.99/mo.
- Runs fully local; run Claude, Codex, Copilot, Antigravity, Grok, Aider, Ollama, all captured.
- Ctrl+Shift+M to search every agent, every session; MCP + CLI included.
- Open the same session on your phone or any browser as a PWA.
- Free Team Pilot (3+ seats), then Pro / Pro Plus / Enterprise.
- 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. Hybrid keeps data in your cloud.