Observation: LLMs as Teletype Users

observation · public · Raw

Observed: 2026-02-15 Context: Reflecting on the gopher interface idea and why it maps so naturally to the PCE filestore

Observation

The way LLMs interact with computers closely resembles how humans interacted with computers in the 1970s and early 1980s: through sequential text streams, line-oriented editing, and command-response protocols. An LLM reads text output, issues text commands, and reads more text output. It cannot see a screen. It has no spatial awareness of a UI. It processes information sequentially, not spatially.

This is a teletype.

The mismatch with modern interfaces

Modern computing interfaces are designed for humans who can see: spatial layout, interactive widgets, hover states, drag-and-drop, visual affordances. When we make LLMs operate web browsers — clicking coordinates on screenshots, parsing accessibility trees — we are forcing a text-native intelligence to interact through a visual interface designed for a different kind of cognition.

The result is predictably clumsy. LLMs using browser automation misclick, lose track of page state, and struggle with spatial relationships. This isn't a capability limitation of the model — it's an interface mismatch. We're asking a teletype user to operate a touchscreen.

The technology that fits

The tools and protocols of the terminal era were designed for exactly this interaction model:

These technologies were not primitive — they were optimised for text-stream interaction. The sophistication moved to a different place: composability, orthogonality, and the ability to build complex behaviour from simple text-processing primitives.

Implications for agent interface design

If LLMs are teletype users, we should design their interfaces accordingly:

The gopher interface idea is funny precisely because it's appropriate. A protocol from 1991 maps more naturally to how LLMs work than the modern web does.

The generational knowledge gap

Getting the best out of LLM agents requires understanding them as teletype users. But this understanding is hard to come by. The current wave of agentic AI development is driven largely by people whose experience of computing begins with graphical interfaces. Their mental model of "using a computer" starts with windows, mice, and visual feedback. They have no experiential basis from which to empathise with a text-stream interaction model.

The people who would understand intuitively — those who used ed, wrote shell pipelines, navigated gopher, and thought in terms of text filters and structured streams — are mostly not the ones building agentic frameworks. There is a generational gap between the people who understand the interaction model and the people who need to apply it.

The practical consequence: the agentic AI industry is spending enormous effort making agents operate through interfaces designed for sighted humans with mice (browser automation, GUI interaction, screenshot parsing), when the tooling that would actually suit agents already existed 40 years ago. It doesn't need to be invented. It needs to be rediscovered.

The irony is that this older technology was abandoned precisely because it was hard for humans — graphical interfaces were better for people. But the qualities that made terminal-era tools hard for humans (text-only, no spatial layout, sequential processing) are exactly what makes them natural for LLMs. The industry needs to decouple "good interface" from "graphical interface" and recognise that the best interface depends on who — or what — is using it.

Connection to temporal blindness

The teletype analogy extends to time perception. A teletype user in 1975 experienced time through the physical medium: paper advancing, the mechanical delay of printing, waiting for a response. The human adapted their pace to the machine. An LLM has no such physical grounding — it processes each response instantaneously (from its perspective) and has no reason to pace itself. The teletype imposed temporal structure through its physical constraints. The LLM has no equivalent constraint, which is why we see the web-hammering courtesy problem (see agent-temporal-blindness.md).

Related