Parallax

A terminal client and an Electron client over one agent runtime, built to find out how much of an IDE an agent actually needs.

Status

Superseded by vertexcode. Both clients still public.

Stack

TypeScript · React + Ink · Next.js 16 · Electron · Server-Sent Events

Size

~210k of CLI, ~550k of desktop client

Links

GitHub (CLI) · GitHub (desktop)

Two front ends over one agent runtime. The CLI renders a reactive terminal interface with React and Ink — a status bar that holds session state, a reasoning trace that streams as it arrives, line-numbered diffs. The desktop client is an Electron shell around a Next.js app that connects to the same daemon over Server-Sent Events and renders the parts a terminal is bad at: collapsible reasoning blocks, a side-by-side patch viewer, session history.

The question I was actually asking: how much of an IDE does an agent need before the interface starts getting in the way?

What the two clients answered

The terminal wins for everything that is a stream. Reasoning, tool calls, status — text arriving in order is what a terminal is for, and a reactive TUI fixes the one thing plain output gets wrong, which is that you cannot tell a working process from a stuck one.

The desktop client wins for exactly one thing, and it is diffs. A large multi-file patch in a terminal is unreviewable no matter how well you colour it. Everything else I built into the desktop app — session management, icon routing per tool type, a settings surface — was comfortable rather than necessary.

That answer is the reason I stopped extending it. The next agent I wrote had no desktop client and hooked the editor's own diff viewer instead.

Things worth keeping

Interrupts that actually interrupt. Ctrl-C signals an AbortController that hard-stops generation and aborts running tools, rather than killing the process. You correct course without losing the session.

Compaction as a command. /compact summarises the conversation, clears the old message blocks and replaces the window with the summary. Every long-running agent needs this and most of them discover it late.

A router rather than an abstraction layer. The CLI streams to several providers directly instead of through a generic middle layer. Generic abstractions over tool-calling schemas are where the schemas quietly break, because every provider disagrees about the shape in a slightly different way.

Parallel subagents. A coordinator model decomposes an objective and spawns lighter subagents that execute concurrently against a non-blocking tool engine. It works, and it is also the feature most likely to spend a lot of tokens doing something a single careful pass would have done better — which is a scheduling problem, not a model problem.