While Claude works, a real kitten sits on your terminal and keeps watch.
The moment you're needed — permission prompt, question, done — it rears up, meows, and steps aside.

catsit demo: a real white kitten walks onto the terminal, sits while Claude Code works, then rears up in a meow when a permission prompt appears and walks off

_{One kitten, one continuous take — not a sprite sheet (see the FAQ for how it was made). By default catsit never touches your input; --guard is opt-in.}

Full-quality kitten in kitty · Ghostty · WezTerm · iTerm2 — every other terminal gets the lo-fi living cat.

한국어 · 日本語 · 简体中文

The cat's day

One continuous performance, one kitten — every transition connects.

agent starts working _{walks in, settles down}	still working _{sits and waits — if the cat is calm, you're not needed}	60s without your input _{curls up for a nap}
you touch a key _{wakes up the slow way: yawn, stretch, sit}	you're needed _{rears up with a meow (+ terminal bell)}	steps aside _{walks off — an empty screen means it's your turn}

Try it in 10 seconds (no agent, no tokens)

npx catsit --demo

Run it in kitty, Ghostty, WezTerm, or iTerm2 to meet the full-quality kitten. Anywhere else (Terminal.app, VS Code, tmux…) you get the lo-fi half-block version — same cat, chunkier pixels.

Use it

npx catsit claude

That's the whole setup. No config files, no hooks, no permissions to grant.

Why

Agents made us babysitters. You can't look away — it might need a permission right now — so you sit there, watching a spinner, guarding a process that doesn't need you 95% of the time.

catsit inverts the notification. The cat's presence is the signal:

The cat...	means
🐈 walks in and sits down	the agent is working. You're not needed. Go do something else.
😴 curls up asleep	you've been away a while. Still handled.
🥱 wakes up with a yawn	you touched a key — it noticed, that's all.
❗ rears up, meows, steps aside	permission prompt / question / finished — your turn.

If you can see the cat, you can ignore the terminal. That's the deal.

The cat never touches your input

By default catsit is watch-only: typing, message queueing, steering mid-task — every keystroke reaches your agent exactly as it would without catsit. The cat is pure signal.

`--guard`: gatekeeper mode (opt-in)

Want the cat to actually stop you from micromanaging? catsit --guard claude:

While the agent works, the cat swallows printable typing and Enter — and shows what it ate in a little bubble (🐟 hell…), so a blocked key never looks like a bug. The first catch comes with a hint: guarding · ctrl+g to shoo.
ctrl+c, ctrl+d, esc, arrows, every control key — always pass through instantly, even in guard mode.
The moment a permission prompt is detected, the gate opens before any animation runs.
If the state is unknown, the gate is open. If anything inside catsit breaks, it permanently degrades to a transparent passthrough — the cat dies, your session doesn't.
ctrl+g shoos the cat away for the rest of the session.

How it looks where you are

Terminal	You get
kitty, Ghostty, WezTerm, iTerm2 3.6+	a real kitten — one continuous filmed performance floating above the text (kitty graphics protocol): it walks in, sits down, waits, rears up in a meow, and walks off
everything else (incl. tmux, VS Code, Terminal.app)	the same living kitten in chunky truecolor half-blocks — lo-fi, but it still walks, naps, and meows
`NO_COLOR` / dumb terminals	a humble kaomoji `(=˘ω˘=)`

How it works

catsit wraps your agent in a PTY and forwards every byte verbatim, while mirroring the screen into a headless terminal (@xterm/headless). When the cat is visible, each output flush becomes one atomic repair → app bytes → cat → cursor restore batch inside a synchronized update — the cat and the app can't corrupt each other, and nothing ever leaks into your scrollback.

Working / needs-you state is fused from two channels: screen patterns (ported from ccmanager's production-tested detectors, MIT) and the Claude Code session transcript (~/.claude/projects/…), whose turn_duration record is the reliable "turn ended" signal. Permission prompts are detected from the screen itself.

Two runtime dependencies. Node 20+. macOS & Linux.

Flags

catsit <command> [args...]   wrap any agent CLI (claude today; more soon)
catsit --demo                bundled fake agent, for trying it out (guard on)
  --guard                    gatekeeper mode: the cat swallows typing while
                             the agent works (ctrl+g shoos it)
  --no-cat                   no overlay at all
  --quiet                    no bell when the cat gets up

FAQ

Is that a real cat? It's one continuous AI-generated performance (Kling) of one kitten on a green screen that doesn't exist — every state was generated with its first frame pinned to the previous state's last frame, so it never cuts, teleports, or slides. Details in assets/cat-frames/CREDITS.md.

Why "catsit"? The cat sits on your terminal, and it cat-sits your agent.

Can I still queue messages while Claude works? Yes — the default mode never intercepts input, so typing-to-queue and steering work untouched. --guard exists precisely for when you want to be stopped.

Codex / Gemini CLI / opencode? Planned — the detector is an interface, and the transcript channel is Claude-specific but optional. PRs welcome.

Windows? Not yet (ConPTY port planned).

Does it slow the agent down? Compositing costs ~0.1 ms per frame and nothing at all while the cat is off screen.

Credits

The "cute thing physically intervenes" mechanic was inspired by Cat Gatekeeper by ZOKUZOKU — a giant cat that blocks your doomscrolling. catsit is an independent project; different cat, different problem: it guards the agent, from you.

The kitten itself is an AI-generated continuous performance (Kling), cut into seamlessly chained beats — see assets/cat-frames/CREDITS.md. Terminals without graphics support play the same beats from a pre-baked low-res grid (half.bin) as half-block cells.