delphin

Delphin 🐬

A duplex companion for AI agent CLIs, written in Rust.

🐋 Sibling project: MemoryWhale — the memory layer. Delphin handles communication (talk while the agent thinks); MemoryWhale handles memory (recall with explanations). They refer to each other — see ECOSYSTEM.md. Point Delphin at MemoryWhale's database with --db to feed your conversations into it.

Delphin — from the Greek delphís (dolphin), with a fin tipped to Delphi. Dolphins swim in pods, bow-ride alongside ships, and talk in a constant stream of clicks. Delphin does the same for your AI agent: it stays alongside while the agent thinks, lets you keep talking, and remembers every word.

The problem

Talking to an AI agent (Claude, Codex, …) is half-duplex. While it's thinking you either wait, or interrupt and lose the in-flight work. There's no natural "let me add one more thing" or "wait, wrong file" mid-thought.

What Delphin does

Delphin runs the agent in a PTY and mirrors its output, so it looks normal — but:

• Keep typing while the agent thinks. Extra prompts go into a queue and are released one at a time as the agent finishes.
• A pluggable arbiter decides what each new prompt deserves:
  • send now — agent is idle, forward immediately;
  • enqueue — agent is busy and the prompt can wait (the default — a half-finished thought is worth protecting);
  • stream — in --live mode, agent is busy but the prompt should be forwarded immediately without interrupting;
  • interrupt — agent is busy but you signalled urgency ("stop", "wait", "cancel", "halt", …), so it barges in.
• It remembers. Every prompt, the arbiter's verdict, and the agent's reply are written to a local SQLite file (agent_turns) — your conversation history, on your machine, nowhere else.

Honest scope: this is asynchronous handoff, not simultaneous listening. Your words reach the agent sooner (queued, streamed, or as a barge-in) instead of after you wait — but the agent still perceives them between turns, not mid-token. Delphin makes "talk while it thinks" ergonomic on today's CLIs; it doesn't make the model itself duplex.

        you type ──────────────┐
                               ▼
                        ┌─────────────┐  busy?   ┌───────────┐
   agent output ◀───────│  supervisor │─────────▶│  arbiter  │
   (mirrored to you)    │ (PTY + idle │          └───────────┘
                        │  detection) │  verdict: send / enqueue / stream / interrupt
                        └─────┬───────┘
                              ▼                  every turn ──▶ SQLite (agent_turns)
                        ┌───────────┐
                        │   queue   │ (drained one prompt per idle)
                        └───────────┘

Motivation

The idea for Delphin came after watching the release of Interaction Models by Thinking Machines Lab, led by Mira Murati, in May 2026. Their central argument was that today's AI interactions are constrained by a turn-based interface: while the user is speaking, the model waits; while the model is generating, it stops perceiving new information. They argued that this creates a communication bottleneck and that future AI systems should support continuous, duplex interaction rather than alternating turns. (Thinking Machines Lab)