The Signal Rail: A Deterministic Motion Grammar for Communicating Conversational Agent State in Terminal Interfaces

The Signal Rail: A Deterministic Motion Grammar for Communicating Conversational Agent State in Terminal Interfaces

Abstract

Terminal interfaces to conversational agents report rich internal state (listening, thinking, executing tools, awaiting input, failing) almost entirely through text, while the motion channel beside it, the one peripheral vision monitors without reading, carries a single bit: alive. We present the Signal Rail, a one-row terminal status instrument that gives that channel a grammar. Four ideas govern it: spatial semantics (input, processing, and output zones, with direction as meaning), a motion grammar (one kinetic rule per state, never color alone), determinism (frames as a pure function of explicit inputs, golden-frame testable), and honesty (no invented progress or activity). We contribute a 45-section normative specification, a reference implementation inside a working full-duplex local voice agent driven by real signals, and two further engines held byte-identical to it by a cross-language conformance harness. State distinguishability is established structurally; behavioral evaluation is outlined as future work.

Introduction

The status indicator has not kept pace with the systems it reports on. Command-line and terminal applications increasingly host conversational agents (voice assistants, chat frontends, tool-using autonomous agents) whose interaction loop cycles through states as different from one another as recording the user's speech, executing a shell command with measurable progress, and having been interrupted mid-sentence. The dominant idiom for all of these is the status line, and its semantic work is done almost entirely by text: today's agent CLIs name their phases (working, thinking, waiting), show the running tool and elapsed time, and print errors, all informative provided the user is reading. Beside that text sits a spinner, and across the first-party and third-party tools we surveyed the kinetics stay coarse: motion marks busy and demands attention, but no tool assigns a distinct kinetic rule to each state it names. So everything rides on reading the words: at a glance, in peripheral vision, or from across the room, listening is indistinguishable from thinking, and both from a stalled network call. The channel that does not require reading carries one bit: alive. When richer displays are attempted, they tend to borrow from media players (waveforms, equalizers) or from graphical progress bars, both of which communicate less than they appear to: a waveform shows energy, not state, and progress-bar animation can distort perceived duration. More depends on this than it used to: oversight of agentic systems leans on indirect cues and on whatever status the agent shows, and the traces developers do consult are not always reliable; and when commercial devices do encode richer state vocabularies, as the smart-speaker light rings do, users correctly identified only about a third of the tested behaviors. Richer state display is needed, and where unlabeled color-and-motion vocabularies have been tested, users could not read them. This paper describes the Signal Rail, a status display for conversational agents that occupies a single terminal row and aims at a specific goal: after brief exposure, the user should identify the agent's state from the rail's pattern alone, without reading its label.

The rail resembles a piece of dedicated electronic instrumentation: segmented rather than fluid, mechanical rather than organic, restrained rather than constantly animated. It is specified normatively, down to timing, transitions, degraded rendering modes, and required tests.

The contributions are:

1. A spatial-semantic layout for agent state: the rail is divided into input, processing, and output zones (28 %/44 %/28 %) that mirror the agent's pipeline, and movement direction carries meaning (Section 4).

2. A motion grammar assigning each of twelve states a distinct motion rule rather than a distinct color, with an explicit transition grammar and priority ordering between states (Sections 5–6).

3. Determinism as a design principle: frames are a pure function of explicit inputs, making UI animation testable with golden frames and reproducible across runs, terminals, and resizes (Section 7).

4. Honesty constraints prohibiting invented progress, precision, or activity (Section 8).

5. A normative specification and a reference implementation: the full 45-section specification (RFC-2119 normative language, exact snapshot fixtures, required test list) is provided as ancillary material, and an implementation ships in a working full-duplex local voice agent in which every implemented state is driven by real agent behavior (Section 10).

Design principles

The rail is governed by eight commitments, both aesthetic and functional, chosen to evoke dedicated instrumentation from an older machine rather than a contemporary animated widget:

• segmented rather than fluid,

• mechanical rather than organic,

• directional rather than ambient,

• restrained rather than constantly animated,

• functional rather than decorative,

• readable without color,

• rectangular rather than circular,

• deterministic rather than randomly generated.

Several familiar displays are explicitly rejected: the rail is not a spinner, not an equalizer, not a waveform decoration, not a progress-bar skin, and not an imitation of the KITT scanner. Two of these principles do most of the work.

Every state gets a rule, not a color. Listening expands; captured input collapses; thinking reads; speaking emits; acting advances; waiting freezes; needs-input returns control toward the user; warning pulses without moving; error fractures; interruption cuts movement off. Because the discriminating feature is geometric and kinetic, the display degrades gracefully: monochrome, 16-color, ASCII-only, and reduced-motion renderings all preserve the structural distinctness of states (Section 9); whether humans exploit it is the open question of Section 12. The same reasoning leads accessibility guidelines to prohibit color as the sole carrier of information; the rail applies it uniformly to an animated component.

The grammar depends on restraint. The idle state does not breathe, the warning state does not scan, and the completion sweep runs exactly once. An indicator that is always moving cannot use motion to mean anything. The reasoning comes from calm technology: the rail should live at the edge of attention and come forward only when the state changes.

Design lineage

The rail's aesthetic is deliberately nostalgic, and the inherited objects are specific: two from fiction, which supply the look and the failure modes, and three from working instrument practice, which supply the discipline.

The scanner: charisma without semantics. The oscillating red bar enters screen culture as the sweeping eye of the Cylon Centurions in Battlestar Galactica (ABC, 1978) and returns four years later on the nose of KITT in Knight Rider (NBC, 1982–1986). The kinship is no coincidence: both series were created by Glen A. Larson, and the design is so canonical that hobby electronics names the bouncing-LED circuit after him: the Larson scanner. The problem is that the scanner is a heartbeat (constant amplitude, constant period, bidirectional), and a heartbeat conveys exactly one bit: alive. The specification rejects it by name (not … an imitation of the KITT scanner) and corrects the semantics rather than the style: keep what made the object compelling, the segmented red-lit instrument row on a dark ground and the machine presence; then forbid the bounce and make every property the scanner holds constant carry meaning instead: direction (flow), amplitude (signal level), position (pipeline stage), stopping (blockage), fracture (failure). The scanner is a heartbeat; the rail aims to be an electrocardiogram.

The lens: presence without disclosure. HAL 9000, in 2001: A Space Odyssey (1968), is the opposite failure rendered with total artistic control: a static red camera lens, built to a brief of elegant simplicity with no buttons, nothing but the voice and the lens, whose dramatic power is its refusal to disclose internal state. HAL is pure presence; the horror is that the crew has nothing to read. As an agent interface, the rail is the anti-HAL: continuous, legible state disclosure treated as an obligation. Mining fiction for interface lessons is an established design practice; what fiction contributes here is not a design to copy but two failure modes to steer between: charisma without semantics, and presence without disclosure.

Working instruments: the discipline. The rail's restraint principle has aviation doctrine behind it. The 1981 FAA alerting-system design guidelines, authored jointly by Boeing, Douglas, and Lockheed, state the objective in capitals: conform to a quiet, dark flight deck when all systems are operating normally, with no alerts unless required for safety or operability; Airbus carries the same rule as the overhead panel's lights out philosophy. That is the idle rail: nominal is dark, and illumination is information. From railway signalling the grammar takes its closed-vocabulary discipline: a signal displays one aspect from a fixed inventory, each aspect carries exactly one indication, and the display must be readable under adverse conditions because the stopping distance exceeds the sighting distance. Twelve states, one rule each, no state distinguishable only by hue, is the same contract transposed to a character grid. Finally, the specification's amber and phosphor-green theme presets are an homage to monochrome CRT terminals, the registered phosphor designations conventionally associated with green (P1) and amber (P3) displays, and nothing more than that: the nostalgia is confined to the palette, while behavior is governed by the grammar. The rail inherits its stage presence from the scanner and its discipline from the annunciator panel and the signal mast.

Anatomy and spatial semantics

The rail occupies one terminal row with five fields: a fixed-width uppercase state label, a left cap, the logical rail, a right cap, and an optional right-aligned auxiliary value (elapsed time, real progress, an error code):

THINKING [-------->..=..=..=.------] T +01.8

ACTING [############## > - - - - - - - - - -] 052%

The logical rail is a sequence of fixed-width cells divided into three conceptual zones mirroring the agent pipeline:

INPUT PROCESSING OUTPUT / ACTION

Zone boundaries are logical and normally invisible; they structure where activity is allowed to appear. Listening activity occurs only in the input zone; thinking activity primarily in the processing zone; speech packets originate at the output-zone boundary and travel right.

Direction carries meaning. Normal information flow is input → processing → output, so rightward movement always means forward processing or emission. Leftward implication is reserved: it may appear only when the assistant is returning control to the user (needs-input), or when an operation is being retracted (interruption). Movement must never reverse direction for visual variety, and the thinking state must never perform the continuous left–right bounce familiar from decorative scanners. The scanner's bounce strips direction of meaning; forbidding it buys the semantics.

An inactive cell renders as a visible track glyph (-), not a space: a space inside the rail is reserved to mean a deliberate blackout or broken connection (used by the error state). Even nothing is happening is drawn as an intact electrical path, so that absence can carry meaning elsewhere.

The motion grammar

Twelve states cover the conversational loop: nine primary states tracing the interaction pipeline, and three attention states (warning, error, interrupted) that can seize the display, per the specification's overlay model (Section 6). Table 1 summarizes the grammar:

State Zone Motion rule

---

idle processing center one stable marker; no animation

listening input quantized amplitude expands from an origin

captured input final shape collapses to a compact block

thinking processing read head crosses a seeded sparse field; never bounces

speaking output packets spawn at the boundary, travel right

acting whole rail committed cells + head (real progress), or bounded packet

waiting frozen previous frame freezes; one boundary marker pulses

needs input input+processing two markers alternate, handing control left

complete whole rail one rightward sweep, then settled medium rail

warning whole rail fixed lattice, double-pulse; geometry never moves

error whole rail saturate → blackout → settled fracture

interrupted retracting movement stops, retracts left, hard cut marker

Selected states illustrate how the grammar encodes semantics:

Listening vs. speaking are structurally different, not mirrored. Listening is localized expansion: quantized microphone amplitude q ∈ 0..4 grows a symmetric shape around a fixed origin in the input zone, with per-cell intensity clamp(q+1−d, 1, 4) at distance d. Speaking is directional packet emission: short groups of cells with a bright head spawn at the output boundary and travel one cell per tick, spawn period governed by the quantized output level (12 ticks at level 0 down to 3 at level 4), at most three packets live, and overlapping packets keep the maximum intensity per cell. A user can therefore distinguish it hears me from it is speaking by shape and location alone: the two states never resemble each other even in monochrome ASCII.

Thinking reads; it does not bounce. The processing zone is populated with a sparse, structured field of low/medium cells generated deterministically from hash(seed, pass, cell) with per-cell probabilities targeting the specification's density ranges (60 % track, 25 % low, 15 % medium in expectation; individual seeds may fall outside the ranges; no peaks except the head). A read head crosses it left to right, one cell per two ticks, with a two-cell decaying trail; at the end of a pass the field dims for one head-step (two base ticks) and a new deterministic field is generated. The metaphor is a head reading a tape of work. The new pass, new field rhythm is state animation, not progress: it marks that thinking persists without claiming any measurable fraction of work is done.

Waiting freezes; interruption cuts; error fractures. These three negative-space states are distinct by design. waiting freezes: a single boundary marker pulses at the point where progress stopped, and everything else is motionless. (The specification phrases this as preserving the previous frame; since the frame function takes no prior-frame input, per Section 7, implementations render a deterministic state-local residue field instead, a recorded deviation that keeps the function pure.) interrupted stops movement immediately, retracts active cells toward the nearest left semantic boundary over 3–4 ticks, and leaves a bright hard cut (!) before returning to idle: the visual of an operation being withdrawn. error plays a one-time entry, full-rail saturation (2 ticks) then blackout (1 tick), and settles into a fractured pattern whose gaps are real spaces, generated deterministically from the error code or seed, and which remains until acknowledged. Failure looks electrically interrupted, not like incomplete progress; cancellation looks like a cut, not a failure.

Transition grammar and priority

Transitions are first-class: one pattern must not be instantly replaced by an unrelated one. The specification provides a transition table (16 entries) with durations in ticks and visual rules. For example, captured → thinking moves the compact captured block rightward through exactly three discrete positions (input origin, zone boundary, processing start), and thinking → speaking places the read head at the processing/output boundary so that the first speech packet visibly continues from it: processed information becomes output.

Each transition declares interruptibility, and a strict priority order resolves competing claims:

ERROR > INTERRUPTED > WARNING > NEEDS INPUT > WAITING > ACTING / THINKING / SPEAKING > COMPLETE > IDLE

A late-reported failure may replace a completion sweep in flight; nothi…

Based on this paper, here are specific improvements I can make to AI systems and what the improved systems can do:

Improvement: Implement a deterministic state machine that maps internal AI processes to distinct, observable states (listening, thinking, speaking, acting, waiting, needs-input, warning, error, interrupted) with explicit transition rules and priority ordering.

What the improved system can do:

• Expose its current operational state through a structured, machine-readable interface (not just text logs)

• Guarantee that each state has a unique, non-ambiguous signature (geometric/kinetic, not color-dependent)

• Handle state conflicts deterministically (e.g., error always overrides completion sweeps)

• Communicate state transitions with explicit timing and causality, making the system's behavior auditable

Improvement: Make all visual/animated output a pure function of explicit inputs: frame(state, entry tick, tick, width, input q, output q, progress, seed, motion mode).

Improvement: Implement honesty constraints that prohibit fabricated progress, invented precision, or artificial activity.

Improvement: Design all state communication to work across rendering capabilities: monochrome, ASCII-only, reduced-motion, and color modes.

Improvement: Apply hysteresis-limited quantization to all input signals (audio levels, progress values) with defined rise/fall limits.

Improvement: Implement first-class state transitions with explicit durations, visual rules, and interruptibility declarations.

Improvement: Use stable seeds (task/turn identifiers) for generating variety in states like thinking or error instead of randomness.

Improvement: Design all state information to be accessible through multiple channels: visual (geometry/motion), textual (labels), and future non-visual (announced state changes).

Improvement: Implement a conformance harness that verifies byte-identical output across implementations in different programming languages.

Improvement: Use the explicit state vocabulary to improve human oversight of agentic systems.

---

Concrete example of an improved AI system:

A voice assistant CLI that:

• Shows LISTENING with amplitude-expanding input zone when actually capturing audio (quantized from real mic levels)

• Shows THINKING with a deterministic read-head pattern when processing (seed-based, reproducible)

• Shows SPEAKING with packet emission when audio is actually queued to output

• Shows ACTING with real progress only for tools with measurable progress (e.g., timer), indeterminate otherwise

• Freezes on WAITING during endpointing, cuts on INTERRUPTED during barge-in

• Fractures on ERROR with a pattern derived from the error code, persisting after exit

• Passes golden-frame tests in CI for all 12 states × 4 widths × 2 motion modes × 3 glyph profiles

• Produces byte-identical output in Zig, JavaScript, and Python implementations

• Never shows fake progress, never bounces, never animates when idle