Coucou: The notch app that turns AI agents into a character

A deep look at the socket bridge, state machine, and animated “Mochi” layer that make terminal workflows feel visible, responsive, and oddly alive.

8 to 10 min read • View on GitHub • More from Louis-CFM

A tiny character living inside a macOS notch with glowing terminal threads feeding into it from the left. Approval buttons, file icons, and task tokens orbit around the notch like a miniature control room. The scene explains how Coucou turns agent activity into something visible and interactive instead of hiding it in a terminal.
Coucou treats the notch like a control surface, not a status light. Mochi sits between the terminal and the user, turning agent events into something you can read at a glance.

A tiny friend that lives in your notch (macOS) or at the top of your screen (Windows, Linux) and keeps an eye on your coding agents: Claude Code, Codex, Cursor, Gemini CLI, Antigravity and more.

Louis-CFM, Author/Maintainer · Louis-CFM/coucou - GitHub
Key Takeaways

Why Mochi matters

Coucou’s most unusual idea is also its most obvious one once you see it: Mochi makes agent activity feel embodied. Instead of treating the notch as a tiny meter, the app turns it into a character that reacts, hesitates, blinks, and asks for permission like a little coworker perched at the top of the screen.

That matters because AI agent workflows are full of ambiguity. You are not just watching progress. You are deciding whether to trust a process that is changing files, asking for approvals, and moving through tasks you may not be reading line by line.

WSJ-style portrait of Louis-CFM based on his GitHub avatar. The image presents a faithful editorial headcut on a pure white background, meant to identify the maintainer behind Coucou without inventing a new likeness.

The bridge between terminal and notch

Under the character layer, Coucou is doing something very plain and very important. It listens to local agent events through a Unix domain socket, translates them into application state, and sends approval responses back the same way. That is why it feels responsive instead of ornamental.

The hidden trick is not the notch itself. It is the path from terminal event to app state to visible reaction and back again when the user approves or denies an action.

A close-up of Mochi being animated by a set of mechanical dials labeled lookX, morph, eyeShape, and dt. Thin wires connect a socket packet on one side to a drawing canvas on the other. The image explains that Mochi is driven by state and timing, not by generic window transitions.
Mochi is not a sticker on top of a UI. It is a state-driven animation system where the character’s motion is computed from live inputs and timing.

A character engine, not a widget stack

The codebase makes a clear bet: animation should come from an engine, not from scattered view transitions. That is why the project leans on pieces like BotEngine and BotCanvasView rather than treating Mochi as a static status element.

The practical effect is that the character can express internal state. It can look around, morph, dance, blink, or react to file drops and approval prompts. Those behaviors are not decorative extras. They are the interface.

This is also where the product becomes easier to trust. When motion is driven by state, the UI stops feeling like a pile of effects and starts feeling like a system with memory.

What the state machine is actually doing

Coucou separates the island’s visible mode from the broader app state. The island can be hidden, petit, home, or coucou, and that distinction matters because the app is always deciding how much surface area to expose, when to collapse, and when to keep attention on the workflow.

That separation is the difference between a clever animation and a product that can hold timing under pressure. The state machine owns transitions. The character engine owns motion. App state owns truth.

StateWhat it meansWhy it matters
HiddenNothing is surfaced in the notch.Keeps the interface out of the way when no attention is needed.
PetitA compact presence is visible.Signals that the system is awake without demanding focus.
HomeThe island is expanded into a usable surface.Makes room for tasks, notifications, and approvals.
CoucouThe full character experience is active.Lets Mochi become expressive when the workflow needs it.

Why this feels different from other notch tools

The category is crowded with tools that live in the notch, but most of them are utilities first. Coucou’s edge is that it combines a local-first control surface with a character model and broader platform reach. It wants to be useful, but it also wants to be legible.

That gives it a distinct middle ground. It is more expressive than a simple session monitor, more interactive than a passive notification strip, and less locked into one platform than macOS-only companions.

The comparison is less about winners than about product shape. Some tools optimize for power-user density. Others optimize for polish. Coucou tries to make the agent workflow feel like a relationship you can actually watch.

ProjectPlatformInteraction modelPersonalityApproval handlingBest fit
CoucoumacOS, Windows, LinuxCharacter-first notch companionHighInline Allow / DenyPeople who want agent oversight to feel alive and immediate
NotchcodemacOSNotch-first monitorLowBasicUsers who want simple monitoring with minimal flair
Vibe IslandmacOSControl panelLow to mediumStrongDevelopers who want a utility-focused command surface
Claude PeekmacOS onlySession viewerLowLimitedUsers focused on observing multiple sessions and history
ccmuxTerminalTUI workflowNoneTerminal-nativePower users who prefer tmux-style control over a GUI

The broader bet: ambient control for AI workflows

Coucou is bigger than its notch. The product points toward a future where agent work is supervised through ambient surfaces that stay present without taking over the desktop. Approvals, progress, and context can live in a persistent layer that is fast to glance at and fast to act on.

That is why the project matters even if you never use Mochi exactly as shipped. It is a prototype for a new kind of developer interface: one that treats oversight, trust, and personality as part of the workflow instead of as separate concerns.