Supported AI agents' memory,
in one place you control.

Context dies at the boundary between tools.

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.

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.

// stdio -- local agents (Claude, Codex, Copilot, ...)
{
  "mcpServers": {
    "scritty": { "command": "scritty", "args": ["serve"] }
  }
}

# Streamable HTTP -- remote / multi-machine agents (current Team+ licence)
$ 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
  every exchange scritty recorded, as text

Terminal, MCP, and CLI share one MemoryService -- same data, same behavior. With a current Team+ licence, 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.

One agent answers from another agent's session.

Split your tmux window and run a different agent in each pane. scritty captures them as two separate conversations -- built from the bytes each pane itself emitted, so a neighbouring pane never leaks into an exchange, and your prefix, copy mode and popups are untouched. Then it serves that memory back: here Copilot is asked about fetch.rs, told not to open any files, and answers from what Antigravity found in the other pane.

The second agent answers from the first agent's work.

Recorded end to end, unedited except for trimming each agent's launch and a modest speed-up. Copilot designs a JWT auth middleware and writes its notes to a file. Antigravity is then started in a fresh session, given no context, and told to use scritty's cross_session_search tool -- it finds Copilot's decisions and answers on top of them, citing session storage and refresh token rotation it was never told about.

In the gap nothing else fills.

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 supported CLI agents 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.