1984 DECwriter IV Connects to Amazon Kiro AI via RS-232, ACP and Rust

At first glance, hooking a forty-two-year-old mechanical line printer to an autonomous software engineering agent sounds like a high-effort sightseeing tour through computing nostalgia. Yet beneath the clattering printhead lies a serious lesson in systems architecture, protocol standardization, and security boundaries. By bridging RS-232 serial hardware to the Agent Client Protocol (ACP) via a custom Rust wrapper and Docker container, Mesaroš demonstrates that the gulf between 1980s terminals and 2026 agentic AI is narrower than modern glossy user interfaces make it look—and that slowing down an interaction might be the best way to keep developers sharp.

The Maple Valley Garage Where 1984 Meets 2026​

According to GeekWire's Kurt Schlosser, who toured the Maple Valley collection, Mesaroš's hardware obsession grew out of the economic realities of his youth in Serbia. Between 1991 and 2003, his only computer was a 1982 Commodore 64. When he finally upgraded, he jumped straight into modern PCs, completely bypassing the golden era of 1990s UNIX workstations and minicomputers. After moving to the Seattle area—arriving just as Paul Allen's famed Living Computers: Museum + Labs closed permanently—he began acquiring broken machines from Goodwill, Facebook Marketplace, and local collectors to experience the history he had missed.

Today, his collection spans everything from a 1970s Data General Eclipse S/230 minicomputer and a black NeXTstation to a bright blue 1990s Silicon Graphics Indy running IRIX, alongside boxed copies of original 1980s Microsoft Windows 1.0. His reverence for foundational PC history is quite literal: his arms are tattooed with symmetrical MS-DOS (C:\WINDOWS>) and Linux (root@localhost) prompts, a classic Windows 95 logo, and pinout diagrams for Zilog Z80 and MOS 6502 microprocessors.

Rather than letting these machines sit as static museum pieces, Mesaroš pushes them onto the modern network:

• 1984 DEC DECwriter IV: Wired to query Amazon's Kiro coding agent and even deploy AWS cloud infrastructure on paper. During GeekWire's live visit, Mesaroš typed "What is GeekWire?" into the teletype, which clattered back a concise summary describing the publication's coverage of Pacific Northwest startups, Amazon, and Microsoft.
• Commodore 64 & IBM PC: Connected over raw TCP ports using vintage terminal packages like NovaTerm and Kermit to chat with the same AI agent.
• 1986 Tandy 102: Used as a portable terminal to deploy Kubernetes clusters.
• Windows 98 Time Capsule: Used for a weekend challenge in which Mesaroš restricted himself solely to a Windows 98 PC, documenting the experience on a VHS camcorder while using Kiro as his "only window into the future."

Section Summary: Mesaroš's garage is not a static trophy room; it is an active hardware lab where machines spanning from 1970s minicomputers to Windows 98 PCs are repaired and adapted to interact with contemporary cloud infrastructure and AI coding tools.

Under the Hood: How a 1984 Teletype Talks to an AI Agent​

It is tempting to hear "AI on a 1984 teletype" and imagine a neural network somehow crammed into a kilobyte of vintage SRAM. In reality, the DECwriter IV has no screen and runs no local models. As Mesaroš detailed in an October 11, 2026 technical breakdown on his personal blog (rup12.net), a teletype (or teleprinter) is an electromechanical input/output terminal that translates serial electrical signals into characters struck onto paper. All of the heavy lifting happens in a containerized cloud-connected environment on a modern host, while a two-stage translation pipeline bridges the physical and protocol gaps.

Stage 1: Bridging RS-232 Serial to TCP/IP​

To get bytes into and out of the DECwriter IV without building custom microcontroller boards from scratch, Mesaroš leaned on existing hardware standards. The teletype communicates via a standard RS-232 serial interface. Attached to that port is an older WiModem232—a serial-to-Wi-Fi bridge originally popular among retro enthusiasts for connecting Commodore 64s to modern Telnet Bulletin Board Systems (BBSes).

Because the WiModem232 emulates a standard Hayes-compatible modem, the teletype treats the local wireless network just like a 1980s telephone line. Using standard AT commands, the device initiates a Telnet session over Wi-Fi to a waiting Docker container on Mesaroš's local network.

Stage 2: Stripping Modern TUIs Down to 7-Bit ASCII via ACP​

Once the network connection reaches the host machine, a much harder software problem appears. Modern command-line tools—including the standard kiro-cli interface—are built for virtual terminal emulators like Windows Terminal, xterm, or Ghostty. They rely heavily on ANSI escape sequences, cursor movement codes, color palettes, Unicode spinners, and screen redraws. If you feed a modern Terminal User Interface (TUI) to a mechanical line printer running at 30 characters per second, you cannot "redraw" a line that has already been physically hammered onto paper with an ink ribbon.

Rather than trying to scrape and sanitize the visual output of kiro-cli, Mesaroš used the Agent Client Protocol (ACP). Implemented by Kiro CLI so that third-party integrated development environments (IDEs) and editors like JetBrains, Zed, and Obsidian can plug directly into Kiro's agentic engine, ACP exposes the agent's communication over structured JSON-RPC via standard input and output (stdio).

Mesaroš wrote a lightweight custom wrapper in Rust called kiro-tty. When a vintage machine logs into the container, kiro-tty acts as its login shell. It takes the user's plain-text prompt, forwards it to Kiro over ACP, receives the structured response, and renders a strictly sanitized stream limited to 7-bit ASCII—stripping out every modern formatting ornament so the DECwriter IV receives only printable characters and basic carriage returns.

Container Port Architecture​

To support multiple eras of vintage hardware simultaneously, Mesaroš packaged kiro-cli and his kiro-tty Rust binary into a Docker Compose service exposing four distinct network profiles:

Notice the distinction between port 2323 and ports 6400/6401: standard Telnet embeds "Interpret As Command" (IAC) negotiation bytes into the data stream. For raw serial terminal programs like MS-DOS Kermit or C64 NovaTerm connected over simple TCP bridges, stripping out Telnet IAC bytes prevents garbage control characters from corrupting the display.

Section Summary: By combining a WiModem232 serial bridge with a custom Rust client speaking the Agent Client Protocol (ACP), Mesaroš bypassed incompatible terminal animations entirely, delivering pure 7-bit ASCII to vintage hardware over tailored Telnet and raw TCP ports.

Security and Operational Realities: Why This Stays on the LAN​

For Windows administrators, DevOps engineers, and home-lab tinkerers who might be tempted to spin up a similar retro gateway—or even build custom headless wrappers for AI coding agents—Mesaroš's published docker-compose.yaml configuration includes candid security warnings that deserve close examination.

When you wire a 1980s protocol to a 2026 autonomous agent, you inherit the security posture of 1984 alongside the execution power of modern AI:

1. Plaintext Over the Wire: Telnet (port 2323) and raw TCP sockets (ports 6400 and 6401) provide zero encryption. Every password prompt, user query, and line of generated code travels across the network in cleartext.
2. Unrestricted Agent Execution (--trust-all-tools): In Mesaroš's container configuration, the Kiro agent runs with the --trust-all-tools flag enabled so it can operate autonomously without interactive confirmation pop-ups that would break a teletype flow. Consequently, anyone who authenticates to the port can instruct the AI agent to execute arbitrary shell commands inside the container.
3. API Key Identity and Billing Exposure: Headless authentication relies on a KIRO_API_KEY environment variable (which requires a paid Kiro Pro, Pro+, Pro Max, or Power subscription). The container acts with the privileges of that key's identity and directly consumes its subscription credits.
4. Loopback Binding and Firewall Bypasses: To prevent accidental exposure, Mesaroš binds all four ports to 127.0.0.1 (localhost) by default. When opening the service to a hardware terminal on the local network, he explicitly advises setting the KIRO_TTY_BIND variable to the host machine's specific LAN IP address rather than 0.0.0.0. Binding to 0.0.0.0 would inadvertently publish the plaintext, command-executing agent across VPN tunnels or secondary bridge interfaces—an especially dangerous trap on Linux hosts where Docker-published ports routinely bypass ufw (Uncomplicated Firewall) rules.

Section Summary: Connecting legacy unencrypted protocols like Telnet to an AI agent running with --trust-all-tools creates an immediate remote-code-execution boundary. Container isolation and strict LAN IP binding (KIRO_TTY_BIND) are mandatory to keep a fun hardware demo from becoming a network liability.

Why Slow Hardware Matters in an Era of Fast AI​

Why go through the trouble of debugging RS-232 data-ready pins and writing Rust protocol adapters just to watch an AI agent print at 30 characters per second? Even Mesaroš readily admits in his blog post that no developer in their right mind would use a 42-year-old serial teleprinter for daily production coding.

Yet his broader argument hits at the heart of a growing debate in software engineering. As AI coding assistants—from GitHub Copilot and Cursor to Amazon Q Developer and Kiro—make it trivial to generate boilerplate applications with a single prompt, it is remarkably easy for engineers to mentally check out.

In his interview with GeekWire, Mesaroš pointed back to the landmark 2017 Google research paper "Attention Is All You Need," which introduced the Transformer architecture behind today's large language models. In 2026, he argues, that title applies verbatim to human programmers: curiosity and paying close attention are the two skills that separate effective engineers from passive prompt-pushers.

From an engineering perspective, forcing a modern system through a narrow, unforgiving constraint is one of the best diagnostic exercises available:

• Protocol Literacy: Building kiro-tty forced Mesaroš to look past the polished IDE button and inspect how the Agent Client Protocol actually negotiates capabilities over JSON-RPC—revealing along the way that not all ACP servers and clients implement the specification uniformly.
• Observability and Control: Even as autonomous agents take on heavier workloads, Mesaroš remains skeptical of trends toward screenless, invisible computing. Having briefly owned and sold a pair of camera-equipped smart glasses, he told GeekWire that developers still need visual, observable control over what their systems are doing.
• Deliberate Pacing: When a machine takes several noisy seconds and physical paper to print a paragraph, you naturally care a great deal more about signal-to-noise ratio. You notice token bloat immediately when it costs ink ribbon and fanfold paper.

Mesaroš is already planning his next iteration: adapting the setup to run with Strands Harness so he can invoke arbitrary models from vintage terminals without being tied to a single coding agent. Whether you are administering a fleet of Windows 11 workstations, managing cloud deployments, or experimenting with local LLMs in a home lab, his Maple Valley garage offers a timely reminder. The newest AI agents in the world still rest on decades-old foundations of standard streams, serial logic, and network sockets—and the engineers who understand the whole stack from top to bottom will always have the upper hand.