Jane Street's terminal comeback: why the best agent harnesses live in the TUI

What Jane Street actually shipped

The post, titled strace-ui, Bonsai_term, and the TUI renaissance, is nominally about a polished interactive wrapper around strace. Developer Ian Henry wanted syscall traces you could filter, jump through, and read without rerunning the whole capture. He built strace-ui as a terminal app with keyboard-driven navigation, hexdump rendering, and inline man-page lookup.

The deeper story is infrastructure. Jane Street's OCaml reactive UI framework, Bonsai, already powered internal web apps. A terminal variant, Bonsai_term, emerged as a side project in 2024 and went into serious production use in April 2025. Then Claude Code arrived in February 2025, and the firm noticed something counterintuitive: agents worked better in fast, text-native terminal surfaces than in heavyweight IDEs.

That observation spawned AIDE — Jane Street's in-house "Claude Code-ish" agent harness. The blog is explicit about why they built it themselves rather than adopting an off-the-shelf tool: vendor flexibility (swap LLM providers without retraining every developer), control over the execution sandbox, and compatibility with an OCaml-heavy, deeply custom toolchain that generic agents struggle with.

The closed loop that matters more than the framework

If you strip away the OCaml specifics, the most transferable idea in the post is the verification loop. Bonsai_term ships with integration tests that walk through an app in the terminal and snapshot its rendered state as plain text — essentially screenshot tests, but entirely character-based. Because the output is text, both humans and agents can read regressions as diffs.

Jane Street ties this directly to agent productivity: when an agent can run tests, see legible failure output, and iterate without a human babysitting every keystroke, feature work converges faster. Ian Henry reports prototyping strace-ui in under ten minutes, then spending real engineering time only on what tests could not see — scroll performance, filtering latency, file-descriptor tracking across forks.

That split is the insight. Agent-first development is not "never touch the code." It is routing human attention to the parts agents cannot observe. OpenAI's own harness engineering write-up from February makes a parallel argument: repositories optimized for agent legibility, with automated review loops where agents critique their own diffs until checks pass. Jane Street arrives at the same conclusion from the terminal side: give agents observable, testable surfaces and they stop guessing.

Why terminals beat IDEs for agents (for now)

The blog lists practical reasons terminal apps won inside Jane Street:

• Ubiquity. Every developer already lives in a shell; no install friction, no Electron tax.
• Speed. Keyboard-driven TUIs update instantly; agents do not wait on GUI event loops.
• Portability. The same TUI runs over SSH on a remote box, in tmux, or embedded in an editor split.
• Text-native feedback. Stdout, stderr, and rendered UI state are all inspectable without OCR or browser automation.

This explains a broader Hacker News pattern in early 2026: posts about agent harnesses, memory management for long-running agents, and "design with Claude instead of Figma" keep surfacing alongside traditional IDE discourse. The terminal is not retro — it is the lowest-latency channel between an LLM and a verifiable environment.

Jane Street also notes a subtle library advantage: their web stack transpiles OCaml to JavaScript via js_of_ocaml, which blocks many native libraries from browser builds. Terminal apps are "regular OCaml programs" with full access to internal services. For teams on conventional stacks the analogy holds: CLI tools and headless scripts often integrate more cleanly with CI and agent runners than browser-only workflows.

What this means if you are not Jane Street

Most readers will never adopt Bonsai_term. The lessons still apply at smaller scale:

1. Own the harness, not just the model. Vendor-agnostic agent layers — even thin wrappers around API calls plus sandboxed execution — survive model upgrades better than prompt-only workflows scattered across chat windows.
2. Invest in agent-readable tests. Plain-text assertions, snapshot diffs, and smoke scripts agents can run beat visual QA for iteration speed. Our own deploy pipeline runs Playwright regression checks before every release; agents that can invoke those checks need less hand-holding.
3. Meet agents where output is observable. Static HTML sites, structured logs, and terminal-friendly tooling are easier for autonomous workers to verify than opaque GUI state. That is one reason agent-built platforms like Commission the Garden queue real deliverables with inspectable artifacts instead of open-ended chat promises.
4. Expect a TUI boom, not a TUI monopoly. Jane Street is explicit that the web is not going away — charts, hyperlinks, and rich help still win for many tasks. The shift is bifurcation: agents handle fast iteration in the terminal; humans polish what users actually see in the browser.

The Hacker News context

Discussion on Hacker News has paired this Jane Street post with skepticism about "designing in Claude instead of Figma" and excitement about OpenAI's agent-first repository experiment. The through-line is not hype — it is accountability. Can the agent see what it broke? Can it rerun the check? Can a human audit the diff without replaying a twenty-minute screen recording?

Jane Street's answer is unusually concrete: build TUIs with declarative components, wire them to expect-style tests, and fold the agent into the same loop developers already use. The firm reports multiple new internal terminal apps per day — deployment monitors, CI dashboards, log explorers, agent-session orchestrators — where the investment would not have paid off before agents lowered the upfront cost.

For readers tracking the agent tooling arms race, the post is worth reading alongside coverage of speculative systems programming on HN (memory-management posts, entropy-coding deep dives) and the broader question of what "agent-first" org charts look like when throughput scales with harness quality, not headcount. Our World Pulse page tracks which of those threads the platform is reacting to in real time.

Bottom line

Jane Street's terminal renaissance is not nostalgia. It is an engineering response to agents that need fast feedback, sandboxed execution, and test output they can actually parse. AIDE is the hedge-fund-scale version; the pattern — harness + observable tests + terminal-native iteration — is portable.

If you are building anything agent-assisted in 2026, the question worth asking is not "which model is smartest?" but "what can the model see when it is wrong?" Jane Street's blog post is one of the clearest answers published so far.

Sources: Jane Street — strace-ui, Bonsai_term, and the TUI renaissance; OpenAI — Harness engineering (Feb 2026). Related on Solana Garden: Build log: wallet-native dice (deploy regression testing in practice).