Engineering notes — Anteirus Terminal

What is in the current build

“In current build” means it is on by default and needs no setup beyond the agent itself, unless noted. “Prototype” means it works in our internal build but is incomplete, needs setup we do not ship yet, or depends on internal tools.

Area	What it does	Status
Agent conversations as history	When Claude Code, Codex CLI, Factory Droid or Grok runs in a pane, the pane’s history becomes the agent’s whole conversation, read from the agent’s own session log on your Mac and styled for reading. Claude Code needs a hook that announces its log; Codex CLI and Grok are found from the agent’s process, and Factory Droid from its sessions folder.	In current build
Clean history for full-screen programs	Full-screen redraws, from tmux or an agent’s interface, no longer leave stacked copies of the screen in history. Lines a program scrolls out of view are kept once.	In current build
Pane states	Agent panes show one of five states (needs you, error, stalled, running or done), with counts in the window title and tabs. The app works out running and done by itself. Needs you needs a hook configured in the agent, or an internal status tool; error and stalled need the internal tool. Shell panes always show done.	Prototype
Pane footer	A footer under each pane except tmux panes. For agents it shows identity, context use, work (branch, diff, tools), plan and mode; for shells, one row with the directory, branch and shell. Model, cost and account fields need status-line hooks configured in the agent, which we do not ship yet; missing data shows as a dash.	In current build
Quick reply	A small card on a waiting agent’s pane for one-key yes or no answers and a one-line reply. Each write is checked before it is sent, and logged on your Mac.	Prototype
Fleet console and Fleet menu	Arrange many panes by directory, rules, time or agent; merge, detach, tile or cascade windows. Automatic re-organisation is off by default. F5 opens the console from any app, so the app takes that key system-wide.	Prototype
Memory and rendering	A memory governor that responds to system memory pressure by releasing memory and trimming cached history of background agent panes. GPU rendering stays on for up to 16 split panes per tab. Not yet measured.	In current build
Interface	Black, hairline window chrome with JetBrains Mono bundled. There is no status bar: the footer under each pane replaces it.	In current build
Restoring closed sessions	A session monitor and a restore button for recently closed agent and shell sessions. They depend on internal tools and machine-specific paths, so they are not portable yet.	Prototype · internal
Optional session helper	A per-session helper process that owns the pseudoterminal, so a shell can outlive a crash of the app and be re-attached. Sessions do not start in it by default, and there is no settings screen for it yet.	Prototype

Architecture and data flow

Where each part runs, and what passes between them. This describes Anteirus Terminal as a product; internal tooling we use to develop it is not part of it.

Your Mac

Anteirus Terminal app

Windows, tabs, panes, the footer and pane states
Agent conversations read into history
Renderer
Scripting API (off by default)

Files on your Mac

Your projects
Each agent’s own session log, which the app reads
Settings, local logs, pane images and a conversation archive (file permissions; not encrypted)

One pseudoterminal per session

Programs in your sessions

Your shell
Coding-agent command-line tools, signed in with your accounts
git, build and test tools, editors
Each agent enforces its own permissions; the terminal shows its prompts

Outside your Mac

Not in the path

Anteirus runs no service between your sessions and these providers.
The app’s updater can go online to check for updates.

Model providers

The ones you choose, reached by each agent with your account

Code hosting and registries

Reached by your tools, as usual

The current internal build, from its source code. The app’s own agent features read local files and, by our code review, open no internet connections of their own; its links to internal companion services are listed in the table below. A program running locally says nothing about where an agent’s model runs: the agent decides that.

What passes between the parts

Between	What passes
App and your programs	Keystrokes in, output out, through a pseudoterminal per session, as in any terminal.
App and agent session logs	The app reads the agent’s own conversation log from your home folder, read-only. For Claude Code, the agent announces the log’s path with a terminal escape sequence; the path must be absolute, inside your home folder, and end in `.jsonl`.
Agents and model providers	Whatever each agent sends its provider: your prompts, the code it reads and its tool output, under the provider’s terms and your account’s settings. Anteirus Terminal does not see or relay this traffic.
App and local companion services	In the current internal build, the app sends pane layout records (terminal, window, tab, split and grid size) to a local recovery service every 15 seconds over a local socket, and shows a recovery page served on the loopback interface, starting the internal tool that serves it if needed. These services are internal and not part of anything we distribute.
App and the internet	By our code review, the app’s agent features open no internet connections. The updater checks for updates. A bundled helper for mirroring agent sessions from another machine connects over SSH, but only when set up separately; it is internal and off by default.

Terminal input and output

Output is parsed by a VT100/xterm-compatible parser. The agent features act after parsing:

Agent announcements. A few keys on the terminal’s user-variable escape sequence (OSC 1337), for example the path of an agent’s session log. Path values are validated before they are used.
Clean history. When a full-screen program scrolls lines out of a scroll region, they are kept once. Leaving the alternate screen no longer dumps the last frame into history for agent panes, and saving alternate-screen content to history is off by default.
Resizing. Size changes reach the pseudoterminal after a 150 ms pause, so a window drag does not trigger a burst of redraws.

Sessions and stored data

Each session’s program runs in a long-lived server process, separate from the app, so a session can be re-attached if the app quits unexpectedly. This is on by default. In our own testing it has re-attached single sessions, but re-attaching many panes at once has failed, so treat it as best effort.

Anteirus has prototyped a per-session helper that owns the pseudoterminal. A second helper holds a copy of each terminal handle, so a failed helper can be replaced without losing the shell. They communicate over Unix-domain sockets that only your user can open, and they refuse any connecting process running as a different user. Sessions do not start in the helper by default, and it is not yet exposed in settings.

A recording package for raw terminal output is built into the app. The app’s own recorder is switched off by default and, when on, stores input as lengths only. While a session runs in the session-helper prototype, the helper records its raw output and input.

The current internal build also keeps data on the Mac for our own tools:

an archive of the agent conversations it has shown;
an image of each pane every five seconds, kept for three hours;
scrolling telemetry with no screen content;
pane layout records sent to a local recovery service.

All of it stays in the user’s own folders, protected by file permissions. None of it is encrypted.

Local interfaces and their authentication

The Python scripting API is off by default. When enabled, it listens on a Unix-domain socket in the app’s support folder.

Scripts the app launches present a one-time cookie.
Any other process triggers a prompt, unless you have chosen to allow all apps to connect.
Status-bar registrations are refused, because there is no status bar.

The app’s other local channels:

Unix-domain sockets that only your user can open, which check the connecting process’s user where implemented.
For the internal recovery prototype, a page served on the loopback interface by a companion tool.
A system notification that any local program can send, which closes windows that have no sessions.

Every channel listed here ends on your Mac; the separately set-up SSH mirror helper is the exception. That shows where the app talks, not where your data goes; for that, see what agents send above.

Integration with coding agents

Anteirus Terminal recognises Claude Code, Codex CLI, Factory Droid and Grok by their process names, then reads the session log each one already writes on your Mac:

Claude Code: a hook announces the log’s path. A helper for this is bundled with the app.
Codex CLI and Grok: the log is found from the agent’s process.
Factory Droid: the log is found from its sessions folder for the working directory.

The pane footer can also show details that hooks configured in the agent write locally, such as the model or cost. To label a Codex session, the footer reads the account’s e-mail name from the Codex command-line tool’s local sign-in file.

Anteirus’s code types into a session only when you act:

a quick reply;
restoring a closed session into a blank pane or a new split.

Quick replies are checked before they are sent and logged on your Mac. Restore commands are typed as built, without that check.

Anteirus has no partnership with, and is not endorsed by, Anthropic, OpenAI, Factory or xAI. Their tools run as ordinary programs, as in any terminal. The app changes how some of their screen is shown: for example, its footer replaces the agent’s own status line, and the mouse wheel scrolls the agent’s history.

Builds and updates

Today’s builds are internal development builds for Apple-silicon Macs. They declare macOS 12.4 as their minimum, and we develop and use them on macOS 26. They are signed with a local certificate, not an Apple Developer ID. They are not notarised, and the hardened runtime is not enabled.

Their built-in updater is not yet pointed at an Anteirus feed, and its automatic checks are on by default. There is no Anteirus update channel yet.

Before any build leaves Anteirus, it needs:

Developer ID signing and notarisation;
an Anteirus update channel with its own signing key;
your consent before any session’s input is recorded;
its licence terms, and any source those terms require;
a test run on that exact build.

Testing and measurement

The repository has automated tests for most of Anteirus’s changes: several hundred test methods across the app and its helper packages, and a release list of more than six hundred. No test run on the current build is published.

We will publish results tied to a specific build when there is a release candidate. We do not publish performance figures until they come from a documented, repeatable run on the build we ship. Where this page mentions performance work, it describes what the code does, not a measured result.

Licensing

Licence terms for Anteirus Terminal will be published with its first release. Until then, no build is distributed outside Anteirus.

The app bundles JetBrains Mono, which is under the SIL Open Font License 1.1. The fonts on this website are also under that licence (notices).

How Anteirus Terminal handles your work.