Positioning
On this page
cotty is a terminal shared by people and agents. It is a complete terminal first: emulation, rendering and a client on every platform, held to the standard of the best terminal on each. To that it adds a session kernel, which keeps the meaning of what happens in a session, and a frontend made for a person who supervises many agents.
cotty is at the design stage. This page says what problem it takes on, what it consists of, and what it holds to.
The problem
- Language models fit the terminal. Text goes in and text comes out, it works remotely, and programs compose through pipes. That is how models work best, which is why agents such as Claude Code and Codex run in terminals.
- The terminal throws meaning away. It does not know where a command starts or ends, what the exit code was, which output belongs to which command, or whether the foreground program is a shell or an editor. An agent has to wrap its own subshell, or take a snapshot of the screen, sleep, and guess.
- Human attention is the new bottleneck. The terminal was designed for one person watching one stream of bytes. One person now supervises many agents, and how fast and how well that person decides sets the total output.
- It still has to be a good terminal. People spend the whole day in one. Emulation that breaks a program, a screen that lags behind the keys, or a device with no client costs more than any new feature gives back.
The background is in What a terminal is. Real cases are in the field notes.
Who it is for
- People who work in a terminal all day. They want one that is correct and fast, and that is on every device they use.
- People who run agents. One agent or many, on one machine or on several. They have to follow what the agents do and answer what the agents ask.
- People who build agents and tools. They want to read a terminal and drive it through an interface, not by scraping the screen.
What cotty is
cotty has three parts.
- A terminal in its own right. Emulation, rendering and a native client on every platform: macOS, Linux and Windows on the desktop, iOS and Android on phones. A browser attaches to a session through a web page that the person’s own machine serves. It is worth using with no agent in sight.
- A session kernel. A background process that holds the sessions. It runs the emulator, keeps a structured record of every command, gives agents an interface, applies policy and redaction, and syncs state to the clients over poor networks.
- A frontend on top of the kernel. Its core is the attention card: a request from an agent, shown with what will be done, what it affects and what the risk is. It lets one person supervise many agents.
The capabilities of all three are listed in Capabilities.
What is different
The base is a terminal that does the ordinary things well. What is different comes in two layers.
As a terminal, with no agent in sight:
- Sessions that outlive the client. A session keeps running when the window closes, and opens again on any device.
- State sync over poor networks. The screen is synced as state, not as bytes, so a slow link stays usable.
- Commands as units. The screen knows where each command starts and ends. A person moves through commands, folds them, and searches and replays what was run.
- The same terminal everywhere. Every desktop system, phones and the browser all open the same sessions.
With agents:
- A record at the level of a command, open to any agent through one interface. An agent reads the exit code and the output of a command. It does not guess them from the screen.
- Control that does not depend on the agent. Policy, redaction and audit sit in the kernel, so they also cover the agents users bring.
- Approval that states its impact. A request says what will be done, what it touches and whether it can be undone. One decision can become a rule.
- Semantic output blocks. A program emits markdown, a diff or an image as a block. cotty draws the block natively, and a terminal that does not know it shows plain text.
Showing which agent waits for a person is becoming a standard feature of terminals, and OSC 7501 is becoming the common way for a program to report it. cotty supports OSC 7501 as it is. Its own work begins after that signal: what is asked, what the answer will do, and whether it can be undone.
How terminals handle these capabilities today is surveyed in Six capabilities across terminals.
Why the three parts are one design
The three parts could be three products. They are designed together because each depends on the others.
- The kernel has to run the emulator. The record, the snapshots for agents and the state sync all need to know what is on the screen. Only an emulator knows that. So the emulator runs inside the kernel, once for each session, and every client shows the same screen.
- The client has to draw what the kernel knows. The boundary of a command, a folded output, a card and a semantic block are not characters in a grid. A client that receives only a grid cannot show them.
- Speed is a property of the whole path. The delay between a key and its character runs through the client, the link and the kernel. Echoing a key locally, before the far end answers, works only when both ends agree on the state of the screen.
- Control has to sit below the interface. Policy, redaction and audit that live in one interface cover only what passes through that interface. In the kernel they cover every client, and the agents that reach the session. How cotty reaches the agents users bring is in Capabilities.
The price is scope. cotty has to be a complete terminal before anything else on this page counts, so the terminal comes first.
What cotty holds to
- Protocols in the open. The interface for agents, and every sequence cotty adds, will be specified on this site, so that other terminals and other agents can implement them. A protocol with one implementation is of little use.
- Correctness and feel are earned. Terminal compatibility, latency and behavior on poor networks come from tests, from measurement and from a great deal of real use. A design does not settle them.
- The data stays with the user. A terminal is full of secrets. cotty is local first: it needs no account, and no server of ours can read a session. A device outside the user’s own network can go through an optional relay, and the relay forwards only what it cannot read.
- Use adds value, and the value is the user’s. The record grows into a history that can be searched and replayed. A decision saved as a rule is a question that is not asked again. Both are kept on the user’s machine.
What cotty does not do
- Add an AI sidebar to a terminal. The agents people use already run in the terminal as programs, and they do that work well. cotty hosts them. It does not replace them.
- Break xterm and VT compatibility for a new feature.
TERMand terminfo must work, and old programs reached over ssh must not break. - Require a cloud account, or upload session data.
- Invent protocols that are incompatible with existing ones. cotty first supports OSC 133, OSC 7501 and OSC 9/99/777, and then extends them.
Open questions
- Which platform first. cotty is meant for every desktop system, for phones and for the browser. The order is not decided.
- Protocol route. Extend the existing protocols only, or also define a new set. The stance for now is compatibility first, as stated above.
- Rendering. Write a renderer, or build on an existing engine. Either way the result has to meet the standard of the best terminals.
- Measures of quality. The budget for the delay between a key and its character, and the target for compatibility, are not set.
- Sync protocol for poor networks. Extend the known approach of syncing screen state with scrollback, structured command blocks and multiple devices, or design anew.
- Pricing. cotty is planned as a paid product. What is charged for, and how, is not decided. The relay is one candidate.