meat · Rust · Responses API · Kitty graphics

meat

A reverse coding agent. meat serves an OpenAI-compatible API and opens a terminal where you answer each request: think out loud, reply, call tools on the client's machine and end the turn, while their agent waits on an open stream. Behind your panel, through the glass, sits the person you are talking to — reading their own screen backwards.

meat                                   # tailnet:8437 · model "meat" · token from the state file
meat --model my-id --bind 0.0.0.0 --port 8437
meat --funnel                          # and on the public internet, via tailscale funnel
meat connect                           # a pi models.json and a curl line to hand over

A conversation

pi on the left; on the right a person answers as the model: thinking, replies, tool calls, a cancel, then autopilot.

Through the glass

meat in a kitty terminal: on the left the agent's panel with a user message about a failing lexer test, a thinking line and a draft being typed; on the right, behind curved glass, a 3D-rendered woman with long auburn hair and round glasses rests her chin on her fist, eyes half-closed, in a dim home office with bokeh lights and a plant; her own agent screen glows mirrored across the glass.
An open turn, 36 seconds in: she is getting impatient. The shadow model's suggestion sits above the draft box.

With Kitty graphics (kitty, Ghostty, WezTerm — and inside tmux) the pane is a view from inside the monitor. The person is a 3D model — sculpted from signed distance fields, meshed, and rasterized and shaded in software every frame — sitting at their desk with their hands on the keys, lit by their screen and a desk lamp. The glass between you curves at the edges, splits colour at the rim and carries fingerprints, a sheen and their coding agent, mirrored and glowing. Your own UI floats on the glass in frosted cards, with the person behind it. They lean in to read, sharp and close; when they sit back to wait they drift out of focus. Their posture follows the conversation: waiting, impatient with their chin on a fist, on their phone, reading your reply, watching tools run, pleased when you finish, hands in their hair when they cancel. Rooms and people are seeded per conversation.

Through the glass How meat's screen is composed in a Kitty-graphics terminal, from back to front. A defocused room (an environment seeded per conversation, with bokeh, plants and passers-by) is the farthest image. In front of it is the human: a 3D model rasterized and shaded in software each frame, posed by the conversation's state, lit by their screen, blurred by how far they sit back. Then the glass: curved at the edges with a colour-split rim, a sheen and smudges, frosted cards behind the agent's panel and dialogs, and the human's own agent screen, mirrored and glowing. The agent's text interface is drawn on top as ordinary terminal text. Each image layer is rendered off-thread and replaced only when its inputs change. roomdefocused · ≤2 fps human3D · posed · depth of field glasscurved · frosted cards their screenmirrored · bloom your TUItext on top youinside the screen
Four images under the text. Each layer is rendered off-thread and replaced only when its inputs change — the room every half second, the human on every pose change, their screen when the text does — double-buffered so nothing flickers, and placed below cell backgrounds so your interface stays on top.

Answering a turn

A request opens a turn on its conversation's tab. The draft box has two modes, thinking and responding; every ⏎ sends what you typed as a live delta and empties the box, so the client sees an agent streaming. Tools come from the request: pick one, fill a form generated from its schema, stage it, and call a batch — the response ends with function calls, the client runs them, and the results come back on a new request, matched by call id. Press F3 for auto-flush, which makes typing append-only and sends each word as you finish it, so you stream like a model. F4 dictates through the tools stt CLI: with auto-flush on, your words go straight to the client; with it off, they land at the cursor and wait for ⏎.

One turn, answered by hand A client agent such as pi sends a Responses request to meat and keeps the stream open. meat opens a turn on the conversation's tab and forwards the same transcript to a shadow model for suggestions. The operator streams thinking and text: each Enter sends what was typed as a live delta. Calling tools ends the response with function calls; the client runs them and comes back with a new request carrying the results, matched by call id, which reopens the turn. Ctrl+D sends the last text and completes the response, returning control to the client. If the client gives up, the turn is marked cancelled and the operator's draft and staged tools are kept. POST /v1/responses (stream)1 same transcript, one turn2 thinking · reply · tool calls3 ⏎ thinking4 reasoning_summary_text.delta5 T — call staged tools6 function_call × 2 · completed7 runs the tools function_call_output × 28 ⇥ ⏎ reply · ^D end9 output_text.delta · completed10 or the client presses esc cancelled · draft kept11 client agentpi · any OpenAI SDKclient agentpi · any OpenAI SDK meatthe open turnmeatthe open turn youdraft · toolsyoudraft · tools shadowgpt-6-lunashadowgpt-6-luna
The client never knows. SSE comments keep idle streams alive well inside pi's 300-second timeout; buffered requests get leading whitespace, which is still valid JSON. Cancellation is noticed in milliseconds, and your draft and staged tools wait for the next turn.
The tool picker open over the scene: a bash tool form with a command field being filled in, and hints for staging, calling now and raw JSON.
t — the tool picker; ^⏎ calls now.
The tool results sidebar on the right with a bash result, the transcript on the left showing the call and its output, and the woman behind the glass checking her phone.
r — recent tool results beside the transcript.
i ⏎write — also between turns: drafts are kept for the next one
⏎ ⇧⏎ M-⏎send the draft; with a line break
⇥thinking ↔ responding
^⏎ ^Dsend and end the turn (staged tools are called instead)
t T Etool picker · call staged tools · edit a staged call
e Dend the turn · decline it (the client sees an error)
M-1…9tabs, one per conversation

The draft box is vim-modal by default (esc normal, esc again leaves), with readline keys while inserting.

The shadow

Every turn is also forwarded, for one turn, to a helper model — by default gpt-6-luna through pi's GitHub Copilot login. Its thinking, reply and tool calls appear above your draft. Send any part as-is, pull it into your draft to edit, stage its calls into the picker, or accept its whole turn with a. When you go your own way, the shadow follows: it reads your reasoning, never repeats a call that already has a result, and picks up a half-written reply mid-sentence.

A man with a pink mohawk clutches his head with both hands in a warm café, seen through curved glass: the client cancelled the turn. The agent panel shows 'cancelled by the client' and the unsent draft; a coffee mug sits out of focus in the foreground and the keyboard below.
The client pressed esc. Your draft survives.
After the turn ends the woman behind the glass sits back with her hands on the desk and a mug in the foreground; the transcript shows the fix and the reply.
Turn ended: she reads your reply, then starts typing the next message.

Without graphics

The same interface in text mode: rounded panel and draft cards, an ASCII person with a beanie and beard at a keyboard in front of server racks with blinking lights, and their screen mirrored glyph by glyph across the window.
Text mode: their screen mirrored glyph by glyph, and an ASCII person.