DEV Community: Little Pan

PonyMux Pro is here: ten computers and the Theme Pack

Little Pan — Wed, 11 Nov 2026 22:31:00 +0000

Nothing you use today goes behind a paywall. The whole PonyMux app stays free on macOS and Windows, and so does Remote Control from one computer.

PonyMux 0.17 opens Pro, and it adds two things on top of that: you can share your agents from up to 10 computers at once, and you unlock the Theme Pack, eight themes and eight cursor effects. Pro is $12.99 a month, or $10.83 a month billed yearly ($129.90, which saves 17%). Windows has its own 0.17.0 with the same Pro.

What does Free still have?

All of it. Terminals, live agent status, search across every conversation, the Inspector, multi-select preview, Focus Mode, pets, and the standard themes and cursor effects. Remote Control works on Free too: open my.ponymux.com on your phone and answer the agent that's waiting.

The one limit is how many computers share their agents at once. On Free it's one. Phones and browsers that only view your agents never count toward it.

What does Pro add?

Ten computers. If you work on a Mac at home and a Windows PC at the office, or a desktop and a laptop, you can turn on sharing on all of them. Every agent from every computer shows up in the same list on your phone. On Free, turning sharing on in a second computer asks which one should stop. Pro removes the question.

The Theme Pack. Eight themes and eight cursor effects that Free doesn't have. They are below.

What's in the Theme Pack?

Eight themes, four dark and four light, each taking its colors from a piece of clothing: Charcoal Trousers, Cloud Sneakers, Navy Jacket, Striped Shirt, Burgundy Shorts, Pink Oxford, Spruce Leggings, and Lime Panel. They sit in their own section at the bottom of Settings → Appearance, under a PRO label. On Free each one shows a lock, and clicking it tells you it comes with Pro.

Eight cursor effects: Burst, a small firework where the cursor lands. Teleport, which breaks the cursor into pixels and puts it back together. Shockwave, a ring that pushes the text aside. Glitch, which splits slices of text into red and blue. Jelly, a wobble. Vortex, which swirls the text away like a drain. Shimmer, like air over a hot road. Smear, a pan blur along the path.

The still above is Shockwave. On ponymux.com the effects run live, on the app's own shaders.

What happens if I stop paying?

You go back to one computer. The one you used most recently keeps sharing, and your agents keep running on all of them.

The Theme Pack stays. Once your account has had Pro, the Pack unlocks on every device you sign in to, and a device keeps it after Pro ends, after a refund, and after you sign out. I built it that way on purpose. A theme you picked shouldn't turn off because a card expired.

How do I get it, and what does it cost?

Open Settings → Plan at my.ponymux.com and choose Upgrade to Pro. In the app, the lock on a Pro theme and See Pro in Settings → Account open the same page. You pay with a card, Apple Pay, or Google Pay, and PonyMux never sees your card number. Payments go through Waffo Pancake, which is the merchant of record and sends the invoice.

It's $12.99 a month, or $10.83 a month billed yearly as $129.90. Both renew automatically until you cancel, and Pro stays on to the end of the period you paid for. Manage billing in the same Plan page cancels, switches between monthly and yearly, and updates your card.

You can ask for a refund within 7 days of a first monthly charge, 14 days of a first yearly charge, and 7 days after a renewal. The pricing page and the refund policy have the exact wording.

What else is in 0.17?

A Claude Code background session that reports itself idle no longer counts as busy. On Windows, Wake All now waits for each agent to report in before it starts the next one, so a batch of sessions comes back one after another. The 1 px gap between the sidebar and its divider is gone.

To see what each plan includes, start with Plans and limits. The Theme Pack is explained in Themes and appearance and Screen effects.

PonyMux is free for macOS and Windows: download it.

How to answer Claude Code or Codex from your phone

Little Pan — Tue, 10 Nov 2026 17:00:00 +0000

You start an agent on the computer at home and leave. An hour later your phone shows that it stopped to ask for permission to run a command. It stays stopped until you answer, and you're nowhere near the desk.

Each of the big agents has a way to answer from your phone. They just don't work the same way:

Claude Code: run /remote-control in the session, then open it in the Claude app or at claude.ai/code. It needs a Pro, Max, Ultra, Team, or Enterprise plan.
Codex: set up Control this Mac or PC in the ChatGPT desktop app, pair your phone with the QR code, and answer from the ChatGPT mobile app.
Any agent: turn on SSH on the computer, reach it from outside your network, and keep the agent in tmux. A terminal app on the phone does the rest.
The catch: the computer has to stay awake and online. If it sleeps, every one of these stops.
The other catch: each agent has its own app and its own setup. With three agents, that's three.

If you run more than one, that gets old fast. PonyMux lists all of your Claude Code, Codex CLI, and Grok Build agents in one place at my.ponymux.com, so you answer whichever is waiting from your phone. More on how it works below.

How do I answer Claude Code from my phone?

Use Remote Control, Claude Code's own feature. In a session you've already started, type:

/remote-control

(/rc is the short form.) The session keeps running on your computer, with your files, MCP servers, and settings. Your phone only shows it and sends messages. Open the session by name in the Claude app under Code, or at claude.ai/code. A session that's online shows a computer icon with a green dot.

You can also start it from the shell:

claude remote-control      # server mode, shows a URL; press space for a QR code
claude --remote-control    # a normal interactive session with Remote Control on

To be told when it needs you, open /config and turn on Push when actions required. Install the Claude app and sign in with the same account.

What to know before you rely on it:

It needs a Pro, Max, Ultra, Team, or Enterprise plan with a claude.ai login. API keys aren't supported.
Outside server mode, each claude process supports one remote session, and that process has to keep running. Close the terminal and the session ends.
A session you started without it can't be reached until you run /remote-control in it, unless you turn on Enable Remote Control for all sessions in /config.

The full list is in Anthropic's Remote Control documentation.

How do I answer Codex from my phone?

Codex does it through the ChatGPT apps, and setup starts on the computer, not in the terminal. You can't set it up from the Codex CLI or the IDE extension.

In the ChatGPT desktop app on the computer, open Settings → Connections → Control this Mac or PC, choose Set up or Add, and approve remote access.
Scan the QR code with your phone. It opens the ChatGPT app.
Confirm the same account and workspace. The computer then appears under Codex in the app, or Remote if your app still uses that name.

From the phone you can continue chats, answer questions, approve commands, and read diffs and terminal output. The work still runs on the computer, with its files and tools.

The computer must be awake, online, and signed in. On a Mac laptop, remote access can stay available with the lid open and power connected; with the lid closed it also needs an external display, and choosing Sleep ends it. Each phone is paired with each computer it controls. The rest is in OpenAI's remote connections documentation.

Can I use SSH and tmux for any agent?

Yes, and it's the one method that doesn't care which agent you run. You connect to the computer, then attach to a terminal where the agent is already running. It takes more setup than the two above.

On the Mac, turn on SSH: open System Settings → General → Sharing, then turn on Remote Login. Under Allow access for, choose Only these users and add yourself.

From outside your home network you also need a way to reach the Mac. Don't open its SSH port to the internet. Use a VPN or a mesh network such as Tailscale, so only your own devices can connect.

Then run the agent inside tmux, which keeps the terminal alive when you disconnect:

tmux new -s agents     # start a session named "agents", then run claude or codex inside it
# Ctrl-b, then d       # detach: the agent keeps running
tmux attach -t agents  # from your phone's SSH app, pick it up again

Anthropic's own documentation suggests the same for Claude Code over SSH: use tmux or screen so the session survives a dropped connection.

This works, but it's the roughest on a phone. You're typing into a full terminal with a touch keyboard, and the keys an agent needs, Esc, Tab, Ctrl, and the arrows, aren't on it. You also set up the SSH app, the network, and the Mac yourself.

Why does my agent stop answering when I'm away?

Almost always, the computer went to sleep. Locking the screen doesn't stop an agent; idle sleep does, and so does closing the lid. Remote Control for Claude Code and Codex, and SSH, can only reach a computer that's awake and online.

None of the agents keep the Mac awake between turns, and that's exactly when you're waiting to answer from the phone. How to keep your Mac awake for Claude Code and Codex covers it step by step.

What if I run Claude Code, Codex, and Grok together?

Then there's no single place to answer. Claude Code's remote lives in the Claude app, Codex's in the ChatGPT app, and a Grok session on your own computer has no remote from xAI that I could find in its documentation. Over SSH you can reach all three, but you have to find the right tmux session yourself and read the terminal to see which one is waiting.

With one agent, any of the methods above is fine. With three, the problem is no longer how to connect, it's which one is waiting for you.

Can PonyMux answer all of them from one place?

Yes. PonyMux runs the real CLI of each agent in its own Terminal, so Remote Control doesn't depend on any agent offering its own remote. It's free on macOS and Windows.

In the sidebar, select the cloud next to Agents, then Sign In…, and sign in with GitHub or Google.
Scan the QR code on the card with your phone. my.ponymux.com opens with your agents already listed.
Every agent running in PonyMux shows up in one list with the same status lights: Claude Code, Codex, or Grok. Open the one that's waiting.
Opening an agent only shows its Terminal. Choose Start control to send keys to it. On a phone, a key bar adds the esc, tab, ctrl, and arrow keys the keyboard lacks.

One device controls an agent at a time. On the computer, a Stop button takes control back whenever you want.

What it doesn't do: it doesn't wake a sleeping computer, so Keep Awake is worth turning on before you leave. There's no end-to-end encryption, and no approval cards that answer for you; you read the Terminal and type the answer. The server relays the screen and keystrokes and saves none of them. On the Free plan, one computer shares its agents at a time.

For setup, see Set up Remote Control. Remote Control on your phone covers the key bar and notifications, and How Remote Control stays safe lists exactly what is and isn't protected.

Download PonyMux, free for macOS and Windows: ponymux.com/download

Your agents are at home. You're at the office.

Little Pan — Tue, 10 Nov 2026 01:15:28 +0000

You kick off three agents on the Mac at home, then head to the office. Somewhere on the way one of them asks for permission to run a command, and it waits. The other two finish and wait too. Nothing is broken. Everything is just stopped until you're back at the desk that is eight kilometres away.

PonyMux 0.16 adds Remote Control for that. Your agents keep running on your computer. Open my.ponymux.com on your phone or any browser, and you see the same agents with the same status lights, whether they are Claude Code, Codex, or Grok. Open the waiting one, choose Start control, and answer it. It's free, on macOS and Windows.

How do I turn it on?

Select the cloud next to Agents in the sidebar, then Sign In…. PonyMux opens your browser, you sign in with GitHub or Google, and confirm that this computer may share. That's the whole setup. The card then shows a QR code: scan it with your phone and the web app opens with your agents already listed.

Each computer signs in once and reconnects on its own after that. Agents are reachable only while the computer is awake, so Keep Awake is worth turning on if you plan to leave.

What can I do from the browser?

Two things, kept apart on purpose.

Watching is the default. Open an agent and you see its Terminal, refreshed about once a second, with the Inspector beside it: working directory, model, pull requests, and the files it made, which you can download. Nothing you do there reaches the agent.

Controlling starts when you choose Start control. Then your keys go to the real Terminal: arrows, Esc, Ctrl combinations, all of it. You can also paste, drag, or pick an image or file to send, and change that one Terminal's text size. On a phone, a key bar adds esc, tab, ctrl, and the arrows that the keyboard lacks.

Opening an agent is a look. Starting control is a decision.

What if two devices want the same agent?

One device controls an agent at a time. The other one sees who has it, for example iPhone in control, and what it did last, like typed 12 chars. It can take over, and the first device goes back to viewing and is told.

On the computer, the Terminal's title bar shows who is controlling it, and a row under the toolbar has Stop. That takes it back at any time. It's the one thing that always works from where the agent actually runs.

Is it safe to type into my computer from a browser?

I thought about this more than about anything else in the feature. Only your account can see and control your agents. The server relays the screen, your keystrokes, and files, and saves none of them. Before each key, PonyMux on the computer checks that the agent is still the program in front and still running, and drops the key if not, so a key doesn't land in the shell under an agent that just exited.

One gap remains. If the agent exits in the exact instant a key is written, a single Enter could reach the shell. End control when the agent is done, and use Stop if something looks off. How Remote Control stays safe has the full list, including what it doesn't have: no end-to-end encryption, and no approval cards that answer for you.

Does it work for Claude Code, Codex, and Grok together?

Yes, and that's the part I care about most. PonyMux runs the real CLI in each Terminal, so Remote Control doesn't need each agent to offer its own remote. Every agent running in PonyMux shows up in the same list, with the same status lights, whichever one it is.

The agents' own remotes work differently. Claude Code has /remote-control, which you run in the session you want to reach. Unless you turn on auto-connect, a session you didn't start it in can't be reached, and outside server mode each instance supports one remote session at a time. It needs a Pro, Max, Ultra, Team, or Enterprise plan, and API keys aren't supported (docs). Codex has its own: the ChatGPT mobile app connects to the ChatGPT desktop app on your Mac or Windows PC (docs). For Grok Build, xAI's web and mobile versions are hosted, and I haven't found an official way to reach a session on your own computer; what exists is community tools. Those are fine if you use one agent. With three, it's three setups and three apps. How to answer Claude Code or Codex from your phone walks through each one.

The agent changes. The place you answer it doesn't.

What does it cost?

Remote Control is free. On Free, one computer shares its agents at a time. If you want more than one sharing together, Pro is coming soon, and nothing else in Remote Control is held back on Free. Plans and limits has the details.

What else is in 0.16?

The sidebar collapses to a slim icon rail, and hovering over it peeks it open. Agent Integrations moved to the bottom of the sidebar, one line per agent. You can resume an archived or trashed Terminal in one click, create a Terminal straight into any List, and wake every suspended agent with Wake All. ⌘+, ⌘−, and ⌘0 change one Terminal's text size without touching the others. The Windows app got the same Remote Control in its own 0.16.0.

For setup, start with Remote Control, and Remote Control on your phone covers the key bar and notifications. The rest is in the changelog.

Download PonyMux, free for macOS and Windows: ponymux.com/download

The icon says it's waiting. The pane shows what for.

Little Pan — Tue, 03 Nov 2026 07:44:11 +0000

In February a Codex user asked for four conversations on screen at once. The reply was that the app already runs as many sessions as you want. The answer back: "the multi-session feature works perfectly, and I use it as well. It’s more about the visual experience — being able to display, say, four sessions in parallel." Seven months later, in the same thread, someone else put it shorter: "fast switching between tabs is not enough" (openai/codex #13036).

In a terminal you've been able to do this for decades: split the window. Past four panes, though, you're arranging a layout instead of watching agents, and the layout doesn't know which agent needs you.

PonyMux keeps your Terminals in a list, the way an app keeps conversations, with the real CLI running in each one. In 0.15 that list can show several at once. Select a few Terminals and they appear side by side, live, each at its real size. When one needs you, click its pane and type. You never leave the group, and the other agents keep going around it.

Why isn't a status icon enough?

Three agents, three rows, three icons. One of them turns yellow. I click it: Codex wants to run a migration and is asking first. I approve, click back to the Claude Code row to see how far it got, and while I'm reading that, Grok has been waiting four minutes for me to pick between two approaches.

The icon told me something was waiting. It didn't tell me what. Knowing which one is already more than many people get: in a Claude Code issue from March, someone running several sessions wrote that "there's no way to know which session is blocked waiting for user input" (#36885). But the next question is always what: what is it asking, how far did it get, is the other one about to finish? A row in a list can only show a summary. The terminal shows the actual question.

A summary tells you to look. The pane is the thing you look at.

How do I see several agents at once?

Select them. ⌘-click rows, Shift-click a range, or press ⌥⌘A for the whole list. Then click the Preview Layout button in the toolbar, the little 2 × 2 grid, and choose Auto. The preview stays off until you pick a layout, so nothing changes for people who select rows only to move them.

Claude Code, Codex, and Grok in the preview grid. Hovering a pane lights up its row in the list.

Auto lays the Terminals out in tall, narrow columns. That was a deliberate choice. An agent's output wraps at about 80 columns, and what you want more of is rows: the question, the diff above it, the plan above that. If you'd rather fix the shape, pick up to 5 × 4 from the table.

Every pane is the real Terminal at that size, not a screenshot. The program reflows to fit, and the output keeps moving.

How is this different from splitting the window?

Splitting a terminal is old news. tmux, and the terminals that took after it, give you panes first: you divide the window, decide what goes where, and the layout stays until you change it. That works. Past four or five panes, each one gets too small to read, and the layout is one more thing to look after.

PonyMux started from the list instead. One Terminal at a time, picked from a list, and that's still how it opens. The grid isn't a layout you build. It's what a selection looks like. Select three Terminals and you see three. Press Esc and the grid goes away, and the list is still where your Terminals live.

Because the grid shows only what you selected, it doesn't have to fit on one screen. Select ten, and Auto keeps every pane at least 40 columns by 24 rows, then scrolls by whole rows. A 2 × 2 with eight Terminals scrolls the same way. You scroll through agents the way you scroll through the list.

A split is a layout you keep. A selection is a question you're asking right now.

Can I answer an agent without leaving the grid?

Yes. Click a pane and type. The toolbar says Typing in and the Terminal's name, so you always know where your keys go. ⇧⌘] and ⇧⌘[ move the keyboard to the next pane. Click the × to give it back. While you're typing, the Inspector switches to that Terminal, with its pull requests, links, and model, as if you had opened it.

Typing in the Codex pane while the other two keep running.

The list and the grid track each other. Hover a pane and its row lights up. Hover a row and its pane does. Click a selected row to type in its pane. When you want one agent full size, click the open button on its title bar. Back brings the group back.

Watching is free. Answering costs one click, and you stay where you are.

Can I wake a whole group at once?

When you quit and reopen PonyMux, your Terminals come back asleep, each with its conversation saved. In the grid, a sleeping Terminal shows a moon in its pane. Click it, and it wakes right there and takes the keyboard once its shell is up.

To bring the whole selection back, choose Wake … Sleeping in the Inspector. PonyMux wakes them one at a time, resumes each conversation, and shows the progress in the Inspector. For more than five it asks first, and Stop ends the queue. Without PonyMux, this guide has the commands to resume several Claude Code and Codex sessions after a restart.

With a group selected and no pane typing, the Inspector holds the batch actions: List, Reaction, Archive, Trash. Settings the Terminals don't share say Mixed, so you know you're about to set them all. Back and Forward remember the selection, and Esc leaves it.

What else changed?

PonyMux runs on Intel Macs now, as well as Apple silicon: one app, macOS 14 or later. Usage limits fit in one ring per agent, and an empty ring tells you why, whether you're signed out, offline, or on an API key with no plan usage to read. In the Inspector, you can mark a pull request ready for review or turn it back into a draft.

The Windows version got the same preview in its own 0.15.0. The preview is covered in Preview several Terminals, and usage in Usage limits. For everything else, see the changelog.

Download PonyMux, free for macOS and Windows.

How to find and stop dev servers Claude Code and Codex left running

Little Pan — Tue, 27 Oct 2026 22:34:16 +0000

You run npm run dev and Vite says Port 5173 is in use, trying another one.... You didn't start anything on 5173. An agent did, an hour ago, to check a page. It said the page looked good and moved on. The server didn't.

Here's how to find it and stop it:

Find it: lsof -nP -iTCP:5173 -sTCP:LISTEN shows the process listening on the port. Drop the port number to list every listening process.
Stop it: kill <PID>. If it's still there a few seconds later, kill -9 <PID>.
Claude Code: /tasks lists the session's background tasks. Select one and press x to stop it.
Codex: /ps lists the session's background terminals, and /stop stops all of them.
Grok Build: /tasks or Ctrl+G shows background tasks. Press x on one to stop it.
The catch: a server started with & or nohup inside an ordinary command isn't a background task. None of those lists show it, and it keeps running after the session ends.

Why does it say port 5173 is already in use?

Because something is still listening on it. Dev servers pick a fixed default port: 5173 for Vite, 3000 for Next.js. When it's taken, both quietly move on. Vite tries the next free port and logs Port 5173 is in use, trying another one.... next dev does the same when you didn't set a port, and says Port 3000 is in use by process <pid>, using available port 3001 instead.

That's convenient once. With agents, it adds up. Each one that checks a page starts its own server, and the next one lands on 5174, then 5175. Your browser tab, a callback URL, or a proxy config still points at 5173, which is now serving yesterday's code.

To make Vite stop instead of drifting, set server.strictPort: true in vite.config, or run vite --strictPort. Then a leftover server shows up as an error the first time, not as a mystery an hour later.

Which process is holding the port?

Ask lsof for the process listening on it:

lsof -nP -iTCP:5173 -sTCP:LISTEN

COMMAND   PID   USER   FD   TYPE  DEVICE SIZE/OFF NODE NAME
node    48213   you    21u  IPv6  0x...      0t0  TCP *:5173 (LISTEN)

-sTCP:LISTEN matters. Without it, lsof -i :5173 also lists every program connected to the port, your browser included. That's why the popular one-liner lsof -ti :5173 | xargs kill can kill your browser along with the server.

To see everything that's listening, leave out the port: lsof -nP -iTCP -sTCP:LISTEN. macOS has a few listeners of its own, such as ControlCenter on 5000 and 7000 for AirPlay. Leave those alone.

Then look at where the process came from:

ps -o pid,ppid,lstart,command -p 48213
lsof -a -p 48213 -d cwd -Fn

The first line shows when it started and the full command. The second prints its working directory, which tells you the project. If the parent PID (PPID) is 1, the process that started it has already exited and launchd adopted it. That's what a forgotten background server usually looks like.

Did Claude Code or Codex start it?

The process tree can't tell you once the parent is gone. The environment can. Claude Code sets CLAUDECODE=1 and CLAUDE_CODE_SESSION_ID in every command it runs, and Codex sets CODEX_THREAD_ID. A server inherits them, and they stay with it after its parent exits. On macOS, ps -E prints a process's environment along with its command:

ps -E -o command= -p 48213 | tr ' ' '\n' | grep -E '^(CLAUDECODE|CLAUDE_CODE_SESSION_ID|CODEX_THREAD_ID)='

This loop lists every listening process an agent started, with its port, directory, and session:

for pid in $(lsof -tiTCP -sTCP:LISTEN | sort -u); do
  agent=$(ps -E -o command= -p "$pid" | tr ' ' '\n' |
    grep -E '^(CLAUDE_CODE_SESSION_ID|CODEX_THREAD_ID)=' | head -1)
  [ -n "$agent" ] || continue
  port=$(lsof -nP -a -p "$pid" -iTCP -sTCP:LISTEN -Fn | sed -n 's/^n.*://p' | sort -u | tr '\n' ' ')
  dir=$(lsof -a -p "$pid" -d cwd -Fn | sed -n 's/^n//p')
  echo "$pid  port $port $(basename "$(ps -o comm= -p "$pid")")  $dir  $agent"
done

The session ID is the one claude --resume <id> and codex resume <id> take, so you can reopen the conversation that started the server and ask it what the server was for. ps -E shows the environment the process started with, and only for your own processes. That's all this needs. For Grok Build, use the working directory and the command.

How do I stop it without breaking anything?

Send it a normal terminate signal first:

kill 48213

A dev server catches this, closes its watcher and sockets, and exits. Check with the lsof line again. If it's still listening after a few seconds, force it:

kill -9 48213

Kill the process that's listening, not its parents. When node exits, the npm run dev above it exits too. Killing upward can hit the shell or the agent that's still running in another tab.

Avoid pkill node and killall node. They also stop every editor extension, language server, and MCP server written in Node, and any dev server you meant to keep.

How do Claude Code, Codex, and Grok stop their own background servers?

Each agent keeps a list of the background work it started, and each list has a stop control:

Claude Code: Claude starts a long command as a background task, and you can move a running command there with Ctrl+B. /tasks (also /bashes) lists them; select one and press x to stop it. Tasks stop when Claude Code exits, including processes that detached under setsid or timeout. If you send the session to the background with /background instead of exiting, they keep running there.
Codex: a command that keeps running after Codex stops waiting for it becomes a background terminal, and the footer says how many are running. /ps lists them and /stop stops all of them. Since 0.115, interrupting a turn with Ctrl+C or Esc doesn't stop them. Quitting doesn't always stop them: Codex can keep a session running in its local background service, for example when you leave a running turn with Run in background. Run /stop before you quit.
Grok Build: the agent runs commands in the background itself, and Ctrl+B sends a running one there. Ctrl+G or /tasks shows them; press x on one to stop it. Stopping a task ends its process group, but not descendants that detached with setsid or nohup.

These lists only know about what the agent started as background work.

Why do some servers outlive the session?

Because the agent didn't start them as background work. When it runs npm run dev & as an ordinary command, the command returns at once, the server is handed to launchd, and no task list ever shows it. Quitting the agent doesn't touch it. The same happens when a background task starts its own nohup … &. Claude Code then reports the task as completed, while the children keep running (issue #92399).

Even tracked work gets lost. In one Claude Code issue, a wrangler dev started as a background task kept running for two days at 89% CPU and 2.5 GB of memory after the user moved on. In another, a hung Python process ran for 136 minutes at 16 GB after the session's context was compacted. The user found it with ps aux. Codex users report background terminals that "run forever", too.

Sessions you didn't close count as well. A Claude Code session sent to the background, or a Codex turn left with Run in background, keeps its servers on purpose.

How do I stop agents leaving servers behind?

None of the three vendors publish a rule for this, but you can tell the agent in CLAUDE.md or AGENTS.md:

## Dev servers
- Start dev servers as a background task, never with `&`, `nohup`, or `setsid`.
- Use the project's fixed port and set it explicitly (`vite --strictPort`, `next dev --port 3000`). If the port is taken, tell me instead of picking another.
- Stop any server you started once you've finished checking it.

The first rule keeps the server in the task list, where quitting the agent stops it. The second turns a leftover server into an error you see right away. The third is a request, not a guarantee: a Codex issue reports background jobs left running even after the user said not to. So keep the lsof check around.

Can I see which Terminal started each server?

That's what the Servers section in PonyMux's Inspector does. For each Terminal it lists every port that a process started there is listening on, with the port and the process name. It doesn't matter whether the agent used a background task, &, or nohup. PonyMux marks each Terminal's processes when they start, and the mark stays after the parent exits.

Click a row to open the server in your browser.
Hover it to see when and in which directory it started, the processes that started it (claude › npm › node), and its command.
Click the trash button to stop it. PonyMux sends a terminate signal and forces it after 3 seconds. Your shell and the agent keep running.

When the agent exits, Servers moves up near the top of the Inspector, where a forgotten server is hard to miss. Moving a Terminal to the Trash or Archive stops everything running in it. Servers only covers processes started in PonyMux Terminals; for anything else, use lsof.

For the details, see Servers.

PonyMux is free for macOS: download it here.

How to wait for CI and code review on a pull request your agent opened

Little Pan — Mon, 26 Oct 2026 16:07:26 +0000

Claude Code opens the pull request four minutes after you asked. Then CI takes twenty, the review bot waits for CI before it starts, and you spend the afternoon refreshing a GitHub tab.

Here's how to wait without the tab:

CI: gh pr checks <number> --watch --fail-fast returns when the checks finish, and exits non-zero if one fails. Chain a notification onto it.
Review: each bot reports in its own way. Codex leaves a comment or a 👍, CodeRabbit posts a commit status, Claude and Cursor Bugbot post check runs. reviewDecision doesn't show most of them.
Merging: gh pr merge <number> --auto --squash merges once required checks pass. Without required checks, it merges right away.
The agent can wait too: /loop in Claude Code or Grok Build, a background gh pr checks --watch in Codex. It costs turns.

Why does the pull request take longer than the agent?

Because two queues start after the agent is done. CI runs first. Review bots usually run after it: CodeRabbit waits for GitHub Checks to finish and reads their output before it reviews.

The gap is measurable. A Harvard working paper by Fiona Chen and James Stratton, with data from 718 companies, found that after teams adopted coding agents, the time from submitting a pull request to merging it rose by 3.45 days, a 49% increase. On Hacker News, a developer described fixing CI "on a 5-minute-delay loop" as hell.

How do I get told when CI finishes?

Let gh wait for you:

gh pr checks 42 --watch --fail-fast \
  && osascript -e 'display notification "Checks passed" with title "PR 42"' \
  || osascript -e 'display notification "A check failed" with title "PR 42"'

--watch refreshes every 10 seconds (change it with -i). --fail-fast returns on the first failure instead of waiting for the rest. The exit code is 0 when everything passed and 1 when a check failed. Checks from other apps count too: the command reads the same list as the PR page.

Three things to know:

Right after a push, there may be no checks yet, and gh pr checks exits at once with no checks reported. Give it a few seconds first.
A cancelled check exits 0, like a pass.
--json turns off --watch. For a one-line summary, use it on its own: gh pr checks 42 --json bucket --jq 'group_by(.bucket)|map("\(.[0].bucket): \(length)")|join(", ")' prints fail: 1, pass: 1.

How do I see what the review bots said?

gh pr view 42 --json reviewDecision,mergeStateStatus gives GitHub's summary. reviewDecision only counts reviews that approve or request changes, and mergeStateStatus (CLEAN, BLOCKED, BEHIND, DIRTY, UNSTABLE) can read UNKNOWN for a few seconds while GitHub works it out. Most review bots don't move either field:

Codex reacts with 👀 while it reviews, comments if it finds something, and reacts with 👍 when it finds nothing. No check, no approval.
CodeRabbit posts a commit status named CodeRabbit and a review with its comments.
Claude Code Review posts a check run that always concludes neutral, plus inline comments. It never approves or blocks.
Cursor Bugbot posts a Cursor Bugbot check run.
GitHub Copilot and Gemini Code Assist leave reviews and comments only.

So "is the review done?" means a different question for each bot, and the answer is in the reactions, comments, and checks on the PR page.

Can GitHub merge it for me when it's ready?

Yes, with auto-merge. Turn on Allow auto-merge in the repository settings, then:

gh pr merge 42 --auto --squash

GitHub merges once every required check and review passes. Cancel with gh pr merge 42 --disable-auto.

The catch is the word required. If the branch has no rule that requires checks, nothing is blocking the merge, and --auto merges immediately, with CI still running. Add a branch protection rule or ruleset that requires your CI jobs first. Review bots that only comment are never required, so auto-merge won't wait for them.

Can the agent watch the pull request itself?

Yes, and each agent does it differently:

Claude Code: /loop check whether CI passed and address any review comments re-runs the prompt at an interval Claude picks, from one minute to an hour. A bare /loop tends the current branch's pull request: review comments, failed CI runs, merge conflicts. Where it's available, Claude may use the Monitor tool instead, which streams a script's output rather than polling.
Codex: there's no /loop. Ask it to run gh pr checks --watch as a background terminal; /ps shows it.
Grok Build: /loop 5m check the PR's checks and reviews runs every five minutes, at least one minute apart.

Every check-in is a turn: it uses your plan, and the agent can start fixing things while you're doing something else. For one pull request that's fine. With three agents and three pull requests, it adds up.

What does GitHub notify me about?

You're subscribed to your own pull requests, so new reviews and comments notify you, in the browser and in GitHub Mobile. For GitHub Actions, you get a notification when a run you triggered completes; under Settings → Notifications → System → Actions you can limit it to failed runs. Checks from other apps, and bot reactions such as Codex's 👍, don't notify you.

Can I see every pull request's checks and review in one place?

That's what the Inspector in PonyMux does. Next to each Terminal running Claude Code, Codex, or Grok, Pull Requests lists the pull requests the agent opened or mentioned for this project, including the ones its subagents opened, and every row shows where the PR stands:

Checks: a pulsing ring while they run, a green check when they pass, a red ✕ with the number failing. Review bots' own checks aren't counted here.
Conflicts: a red triangle when the branch conflicts with its base.
State: the icon turns purple when merged, red when closed, and dims for a draft.
Review: a badge on the PR icon combines every bot's verdict, worst first. Changes requested, comments, still reviewing, passed, or passed while another bot hit its usage limit.

PonyMux reads each bot the way that bot reports, which is what reviewDecision can't do. It reads Codex's review state from its summary comment, CodeRabbit's from its commit status and the number of actionable comments, Claude's and Cursor Bugbot's from their check runs, and Copilot's and Gemini's from their reviews. Other bots are read from their review states. Hover a row and the tooltip spells it out, one line per bot: "Codex: no issues", "CodeRabbit: has comments", "Codex: usage limit reached, comment @codex review to retry". A bot that hasn't started on the latest commit shows as waiting, and one that stays silent too long shows as stalled.

Status updates on its own. A row on screen is checked every 30 seconds while something is running and every few minutes otherwise, and again when you come back to PonyMux. It uses your gh login, so private repositories work. If gh isn't installed or signed in, the ⓘ next to Pull Requests turns yellow and gives you the command to copy. To turn it off, clear Show pull request status in Settings → General.

Can I merge it from there?

Yes. Open the row's ⋯ menu and choose Merge. The menu already knows the repository's merge methods. When a merge can't go, the item is greyed out with the reason: a draft, conflicts, branch protection, a branch behind its base, or already in the merge queue. When branch protection is waiting on checks and auto-merge is allowed, it offers Enable Auto-Merge instead.

Merging asks first. The sheet reads the PR from GitHub again and says what it found: "Ready to merge.", or what's still open, such as failing checks or a bot that's still reviewing. Pick a merge method from the ones the repository allows, and choose whether to delete the branch. The merge is sent for the commit you were shown, so if someone pushed in the meantime, GitHub refuses it instead of merging code you didn't see. The sheet waits for GitHub's answer and shows it.

It doesn't approve, re-run checks, request reviews, or update a branch that's behind. For those, open the PR on GitHub.

For every status and setting, see Pull requests.

PonyMux is free for macOS: download it here.

Your agent is done. The pull request isn't.

Little Pan — Sat, 24 Oct 2026 03:55:10 +0000

Claude Code fixed the bug in four minutes and opened a pull request. Then I spent the next forty refreshing it. E2E tests still running. Refresh. Still running. Refresh. Review bot waiting for checks. Refresh. Red.

The agent was done. The pull request wasn't.

PonyMux 0.14 moves that wait into the app. Every PR in the Inspector now shows where it stands: checks running, passed, or failing, merge conflicts, and what the review bots said. When it's ready, merge it from the same row. And a new Servers section lists the dev servers your agent started in the Terminal, so the one from an hour ago stops holding port 5173.

Why am I still waiting after the agent finished?

Writing the code got fast. Everything after it didn't. CI runs, then the review bots run, and CodeRabbit by default waits for GitHub Checks to finish before it reviews. With two or three agents going, that's two or three PRs, each in a different state, each behind a browser tab.

It isn't just me. A Harvard working paper by Fiona Chen and James Stratton, using data from 718 companies, found that coding agents raised code output by about 30%, while the time from opening a pull request to merging it went up 49% (summary). It's not peer reviewed yet, and the data come from an analytics vendor. Still, it matches the afternoon above. On Hacker News someone described fixing CI on a "5-minute-delay loop" as hell, and the reply was a skill that spins up a subagent just to poll the PR.

I wanted the poll without the tab.

Is CI done yet? Did the review pass?

Open the Inspector next to a Terminal running Claude Code, Codex, or Grok. Each row under Pull Requests now carries its status. A pulsing ring while checks run, a green check when they pass, a red cross with the number failing. A triangle when the branch has conflicts. A badge on the PR icon for the review bots: Codex, CodeRabbit, GitHub Copilot, Gemini Code Assist, Claude, and Cursor Bugbot. Hover the row and you get each bot's verdict in words.

Status updates on its own while the row is on screen, and again when you come back to the app. It's read with your gh login, so private repositories work. If gh isn't installed or signed in, the ⓘ next to the section turns yellow and tells you the command. Don't want it? Turn it off in Settings → General.

You find out it's red when it turns red, not on the fourth refresh.

Can I merge without opening GitHub?

Yes. Open the row's ⋯ menu and choose Merge. The menu already knows the repository's merge method, and when a merge can't go it says why: a draft, conflicts, branch protection, or a branch behind its base.

Merging asks first. The dialog reads the PR from GitHub again, so you're confirming what's true now, not what was true when the row last updated. Pick a merge commit, squash, or rebase from what the repository allows, and tick a box to delete the branch. If branch protection is still waiting on checks, it offers auto-merge instead. The dialog stays until GitHub answers, so you see the result instead of guessing. Close and reopen work the same way.

Which server did my agent leave running?

This one is quieter. The agent runs npm run dev & to check a page, says it looks good, and moves on. The server doesn't. An hour later Vite tells you port 5173 is in use and quietly moves to 5174.

People find these the hard way. In one Claude Code issue, a wrangler dev that Claude Code started in the background kept running for two days at 89% CPU and 2.5 GB of memory. In another, a stuck process used 16 GB for over two hours, and it turned up only in ps aux. If you have one right now, here is how to find and stop it.

Servers lists every port a process started from this Terminal is listening on. Hover a row to see when and where it started, what started it (claude › npm › node), and the command. Click the trash button to stop it. PonyMux asks it to quit, forces it after 3 seconds, and leaves your shell and the agent alone. When the agent exits, Servers moves up near the top, where a forgotten one is hard to miss.

The agent forgets what it started. The Inspector doesn't.

What else changed?

PRs and files created by subagents now show up in Pull Requests and Outputs, for Claude Code, Codex, and Grok.
An agent you have installed but never ran shows a Connect button, with up-to-date install links.
The working indicator stays on while a background subagent is still busy.
Moving a Terminal to the Trash or Archive stops what's running in it, servers included.
Quit and crash dialogs follow your light or dark theme.
The status badge on Terminal rows no longer sits on a backing circle.

Status, merging, and Servers are covered in Workspace and Navigation. For the full list, see the changelog.

PonyMux is free for macOS: download it here.

A mental health feature for people who work with agents

Little Pan — Sun, 18 Oct 2026 09:25:52 +0000

It's late. The review agent has found one more thing: a boundary case in a regex. The coding agent fixes it, opens another PR, and the reviewer finds the next one. Some nights that's dozens of PRs, and none of them is wrong.

I didn't want to scold anyone. I wanted to hit something.

What actually wears me out?

Not the big failures. A broken build is easy: you're angry for a minute and you fix it. These are the ones that wear me down.

The review that never ends. One agent writes, another reviews, and the reviewer always has a nitpick. A person knows when to say "good enough." An agent forgets it's allowed to say no, and keeps polishing the same corner.
The side quest. Halfway through task A it trips over task B, and puts all its energy into B. A is forgotten.
Pulling teeth. It stops at some boring little spot and tells me what it did, but not what comes next. I ask, it moves one step, it stops again.
The silent decisions. The work is done, and the choices it made along the way aren't mentioned. Ask, and you get a little more.

None of these is a bug. That's why they're so tiring.

Why would a terminal need therapy?

Plenty of tools help agents work better. I haven't found one that asks how the person on the other end feels at that moment.

You can type "seriously?" into the prompt. It doesn't help. You can walk away, which is the right call, and not always possible.

I wanted a third option: something you can do right now, with one click, that's a little funny. If a bad afternoon can at least be absurd, I can stay in the work.

What's on the rack?

At the bottom left of the Inspector there's a sofa button. Click it and a rack opens: three weapons and three spells. Pick one and click the terminal. It's called Terminal Therapy. Here's each tool in action.

Hammer lands right where you click. The text slips and cracks and the screen shakes, but nothing burns. It's the one for the fifth "You're absolutely right."

Pistol fires a short way ahead along a dashed aim line that follows the way you move the pointer. It leaves a small charred pit. It's what I'd type "seriously?" with.

Rocket Launcher flies farther and blows a crater with a glowing rim. It needs a moment to reload, which is probably healthy. This is for when it rewrote the whole package. Again.

You hold a weapon until you put it away. Spells are used once.

What are the spells for?

Bless is my favorite. A column of light comes down, every mark you left is cleared, and the text glows gold for a few seconds. The practical part is that the screen is clean again. But I also think of it as a small superstition. You make a wish for the next run: first try, no surprises. I know it does nothing to the agent. I do it anyway.

Ignite and Freeze don't mean anything. Sometimes you just want to burn the whole thing down, or freeze it right where it stands. Fire spreads from your click for about five seconds and leaves scorch marks. Frost covers the screen and thaws away by itself, leaving nothing behind. A new spell replaces the one still showing.

Your turn: the original post on ponymux.com has the real rack running in the page, and every tool works.

How does it work?

Everything is drawn in PonyMux's own renderer, on top of the terminal's output.

It's built on Ghostty's renderer, with a custom patch so the renderer knows where you clicked. That's why it's PonyMux-only. You can't just drop a shader into another terminal and get this.

The damage stays after you put a weapon away. The × beside the sofa clears it, so does Bless, and so does restarting the terminal. Nothing is saved.

Sounds are off by default. Turn them on at the bottom of the rack. If macOS has Reduce Motion on, nothing flies or shakes; the damage just appears.

And if you keep firing for long enough, the terminal will eventually have something to say. I'll leave you to find it.

Serious work should still feel alive. Even the bad afternoons.

Everything the tools do, one by one, is in the Terminal Therapy docs. PonyMux is free for macOS: ponymux.com/download.

Claude Code and Codex pets: how to get one for every session

Little Pan — Fri, 16 Oct 2026 16:10:46 +0000

Codex has pets in two places. In the ChatGPT desktop app, open Settings → Pets, type /pet, or press ⌥Space on macOS to show a floating pet. In an interactive Codex CLI session, type /pets or /pet to choose a terminal pet for that session. Claude Code and Grok Build have no built-in equivalent today.

A pet is a small animated companion that shows what your agent is doing: working, waiting for you, done. It is a nice way to keep an eye on an agent without reading its output.

Here is how to set one up:

In the ChatGPT app: type /pet, choose Show pet from the command menu, or press ⌥Space on macOS. Pick a built-in or custom pet in Settings → Pets.
In the Codex CLI: type /pets to pick one, /pets <name> to choose it directly, or /pets off to hide it. It needs iTerm2 3.6 or later, or a terminal with Kitty graphics or Sixel, and doesn't show in tmux or Zellij.
Make your own: in Settings → Pets, click Create pet. The app installs its bundled hatch-pet skill and opens a chat where you describe the pet. It saves the pet to ~/.codex/pets/<name>/.

How do Codex pets work?

The pet plays an animation for the state of the chat: Running while it works, Needs input while it waits for an answer or an approval, Ready when it finished and you haven't looked yet, and Blocked when it failed. In the ChatGPT app it floats on screen above a small chat box, and Mini shows the box without a pet. In the Codex CLI it sits in the terminal.

A pet is two files in a folder:

pet.json: the id, display name, description, and the sprite sheet's file name.
spritesheet.webp: a grid of 192×208 pixel frames, eight columns wide, one row per animation. Nine rows cover idle, running right and left, waving, jumping, failed, waiting, working, and review. Pets made by the hatch-pet skill that ships with the ChatGPT app add two rows of poses for looking in 16 directions (11 rows, spriteVersionNumber: 2 in pet.json); older pets have the nine rows only. Both kinds load.

How do I make my own Codex pet?

The ChatGPT app makes pets with OpenAI's hatch-pet skill:

Open Settings → Pets and click Create pet. The app installs the bundled hatch-pet skill and opens a chat.
Describe the pet, or give it a picture: a photo of your dog works.
The skill generates every animation row, checks the frames, and saves the folder under ${CODEX_HOME:-$HOME/.codex}/pets/.
Back in Settings → Pets, click the refresh button and pick the new pet.

Look at the result frame by frame before you keep it. Generated sheets can have a fifth leg in a pose, a size jump between rows, or leftover background color between the legs. The skill can repair a single row when you ask it to.

What happened to Claude Code's /buddy?

Claude Code shipped /buddy on April 1, 2026, in version 2.1.89: a small character next to the input that hatched from your account and reacted while you worked. On April 9, version 2.1.97 removed it. Anthropic said it was a small April Fools feature, and typing /buddy now says "Unknown command: /buddy". Claude Code has no pet today.

Can each session get a different pet?

In the Codex CLI, yes: /pets <name> chooses a pet for the current CLI session, and that pet reports the state of that session. The ChatGPT desktop pet is a floating companion for the app; when several chats are active, its activity tray lets you open the one that needs you. Claude Code and Grok Build have no built-in pets of their own.

PonyMux gives every Terminal a persistent pet in one shared window. Each Terminal running Claude Code, Codex, or Grok gets a pet when you create it and keeps it, and the pets line up above the window. So a pet tells you which session it is as well as what it is doing:

Working: the agent is running.
Waiting, with a wave every few seconds: it needs an answer or an approval.
A hop: a turn just finished.
Standing: the agent is idle.
Failed: it stopped on an error.

Click a pet to jump to its Terminal. Shell-only Terminals and ended sessions don't get a pet on stage. Pets need the Claude Code, Codex, or Grok integration, which you connect once from the bottom of the sidebar.

Can I use the pet I hatched in PonyMux?

Yes. PonyMux reads ~/.codex/pets/, so a pet you made with hatch-pet, or downloaded, shows up next to the others. When ChatGPT is installed, its built-in pets are in the list too.

You don't need any of that to get started. PonyMux ships with six ponies of its own, Mochi, Nyx, Opal, Pixel, Rex, and Mocha, so different Terminals get different pets without Codex or ChatGPT installed.

If a pet in ~/.codex/pets/ has the same id as one of the ponies, yours takes its place.

How do I choose a pet for a Terminal in PonyMux?

Open Settings → General → Pets:

Show a pet for every live session turns pets on or off.
New Terminals get chooses the pet for new Terminals: one pet, or Random to spread them out.
The row below says how many pets were found and where from. Click Rescan after you add a pet to ~/.codex/pets/.

To change one Terminal, open its Inspector. In the Pet section, pick another pet from the menu, or remove the pet from that Terminal with the trash button that appears when you hover the row.

For themes, cursor effects, and the rest of PonyMux's personal touches, see Personalize PonyMux.

Originally published on ponymux.com, where the pet demos are interactive.

Every link your agent gave you, and a rocket launcher for your terminal

Little Pan — Mon, 12 Oct 2026 15:45:31 +0000

Two hours into a Claude Code session, I want the PR it opened an hour ago. To check whether CI passed, or to merge it. The link is somewhere up there, between a few thousand lines of test output and three plans.

So I scroll. Every time.

PonyMux 0.13 keeps those links for you. The Inspector now lists the pull requests and links the agent gave you in the running conversation, newest first, with their real titles. A new Outputs section does the same for what the agent made: Artifacts, pages, Markdown plans, reports. And for the moments when the agent gets it badly wrong, there's Terminal Therapy.

Where did that PR link go?

Open the Inspector next to any Terminal running Claude Code, Codex, or Grok. Under Pull Requests you'll see this project's PRs and any PR the agent opened, even inside a retry loop or a heredoc. Everything else the agent linked to goes under Links: docs, issues, dashboards, each with the site's icon and the page's title.

Titles come from the pages themselves. With GitHub CLI installed, PRs in private repositories get their titles too, so you're not guessing between #412 and #418. Issues the agent files with gh issue create show up even when its reply doesn't mention them.

The newest link is always on top. Click it and you're there.

The link you need is usually the one from an hour ago.

What happened to the files the agent made?

Agents make a lot of things now. A Claude Artifact with a review. A page Codex wrote. A PLAN.md. An HTML report from a test run. Claude Code prints the Artifact link at the bottom of its reply, which works for the first one and stops working by the fifth.

Outputs collects them in one list. Each item shows the title it declares, so five index.html reports don't look the same. When Codex edits a page, it moves back to the top. Markdown opens in the Files panel next to the Terminal, HTML in your browser, everything else in Quick Look.

None of this is stored. The lists live in memory for the running conversation, the same way the conversation itself does.

What is Terminal Therapy?

Everyone who works with an agent knows the moment. Fourth try at the same fix, it breaks something else, and the agent is absolutely right again.

Another angry prompt won't fix the build. The terminal gets a rocket launcher instead.

At the bottom of the Inspector there's a weapon rack: a pistol, a hammer, a rocket launcher, and two spells, Ignite and Freeze. Pick one and click the Terminal. Blow up the test output. Smash it. Set it on fire.

Then pick Bless and wish the next run luck. The light clears the damage, and you get back to work. Keep firing without cleaning up and you'll find out what happens at 128.

Serious work should still feel alive. Even the bad afternoons.

What else changed?

When Claude Code moves a conversation to the background with /bg, the Sessions panel says so and can bring it back, even after you restart PonyMux.
Built-in ChatGPT pets show up again with the latest ChatGPT app.
Selecting text in Codex copies it again.
Crashes when resizing the window or switching Terminals are fixed.
Animations follow your Reduce Motion setting.

Everything Terminal Therapy does is in Terminal Therapy, and the Inspector's new sections are in Workspace and Navigation. For the full list, see the changelog.

Originally published on ponymux.com, where the demos are interactive.

How to preview Markdown files from Claude Code and Codex

Little Pan — Fri, 09 Oct 2026 16:18:07 +0000

Claude Code just wrote the plan to PLAN.md, or Codex left a HANDOFF.md. You cat it and scroll through pound signs, asterisks, and pipes. The agents render Markdown in their own replies, but a file they write you read raw. A few ways to read it properly:

In the terminal: glow PLAN.md renders headings, lists, tables, and code right there. Install it with brew install glow.
In an app: open PLAN.md opens it in whatever app handles .md files on your Mac.
Let the agent open it: add a line to AGENTS.md or CLAUDE.md telling it to run open on every Markdown file it writes.
Click it: Claude Code prints file names as links. Cmd-click one to open the file.
The catch: each of these sends you somewhere else to read, and back again to reply.

How do I read a Markdown file in the terminal?

Use a Markdown renderer. Glow is a common one:

brew install glow
glow PLAN.md

It prints the file with styled headings, bullet lists, tables, and highlighted code blocks, then returns to the prompt. For a long file, glow -p PLAN.md opens it in a pager you can scroll with the arrow keys and leave with q.

Glow reads from a pipe too, so cat NOTES.md | glow - works. It's the quickest way to read a plan without leaving the session's terminal, but it's a snapshot: when the agent edits the file again, run it again.

How do I open a Markdown file in an app?

macOS has a command for that:

open PLAN.md

It opens the file in the app your Mac uses for .md files, such as your editor or a Markdown app. To change which app that is, select any .md file in Finder, press Cmd-I, pick an app under Open with, and click Change All.

This works from anywhere, including from the agent itself, since it's an ordinary shell command.

Can the agent open the file for me?

Yes. Agents read your project instructions at the start of every session, so one line is enough. Add it to AGENTS.md, which Codex and Grok Build read, or to CLAUDE.md for Claude Code:

- After you write or update a Markdown plan or note, run `open <file>` so I can read it.

From then on, when the agent writes PLAN.md, it should finish by running open PLAN.md, and the file comes up in your Markdown app. If both agents work in the project, put the line in AGENTS.md and have CLAUDE.md import it with @AGENTS.md; see How to hand off a task from Claude Code to Codex.

Can I click the file name in Claude Code's output?

Yes. When Claude Code writes or edits a file, it prints the file name as a terminal link. In terminals that support links, such as Ghostty and iTerm2, hold Cmd and click the name, and the file opens in its default app.

That's handy when the agent mentions a file in passing. You don't have to copy the path or switch to Finder.

Can I read the file next to the agent's terminal?

Yes. PonyMux has a Files panel that renders Markdown beside the Terminal: headings, code blocks, tables, task lists, and images. Press Cmd-Option-F to show it.

PonyMux's Files panel rendering a Markdown file next to the Terminal, with back/forward navigation and a pin button.

A file gets there three ways:

Cmd-click a link to a .md file in the terminal output, such as a file name Claude Code prints. It opens in the panel instead of another app.
Run pony open PLAN.md in a PonyMux Terminal. The agent can run it too: put pony open <file> in the line above instead of open <file>, and a brief note shows which agent opened the file.
Click a link inside a rendered file. Relative links to other .md files open in the panel, like a browser, with back and forward.

You can pin up to 10 files. The panel is for reading; to edit, open the file in your editor from its context menu. For more on the panel and the pony command, see Workspace and Navigation and pony CLI.

Originally published on ponymux.com, where the demos are interactive.

Eight cursor effects you can try first, and a pony for every Terminal

Little Pan — Thu, 08 Oct 2026 16:09:16 +0000

Most of a day at the terminal is the same keys again and again: j, k, w, $, G. The work matters. The keystrokes don't feel like much. I wanted them to feel a little like casting a spell, where every jump leaves a spark behind.

PonyMux 0.12 adds four new cursor effects, eight in all, and Settings now plays the one you select in a live terminal before you pick it. Six ponies also ship with the app now, so each Claude Code, Codex, or Grok session gets its own pet without installing anything else.

Cursor Lightning in PonyMux: a bolt from where the cursor was to where it lands.

What are the new cursor effects?

Comet, Sparks, Afterimage, and Lightning join Warp, Tail, Sweep, and Ripple. I wrote the four new ones to look different from each other, not as four takes on the same smear:

Comet draws a glowing streak that tapers toward where the cursor came from.
Sparks throws sparks along the jump, and they fall as they fade.
Afterimage leaves a few fading copies of the cursor along the way.
Lightning is a quick bolt from the old spot to the new one.

All of them skip short moves, so typing doesn't set them off. Ripple, Comet, Sparks, and Lightning are now drawn in your theme's accent color, so they fit whatever theme you use.

Every jump can leave a little magic behind.

How does the live preview work?

Open Settings → Terminal → Screen Effect and click an effect. Under the list is a real terminal, not a recording: same engine as your Terminals, with your font, cursor, and theme. It types a few lines of code and jumps around them the way vim does, $, %, G, w, so you see the effect on the moves you actually make.

Ripple only reacts when the cursor changes shape, so for Ripple the preview switches between insert and normal mode instead. That's also why Ripple got bigger and longer in this release: it used to be a faint gray ring that was easy to miss on dark themes. If Reduce Motion is on, the preview waits for you to press play.

The setting is the default for new Terminals. Each Terminal can still have its own effect from its action menu.

Why six ponies?

Until now PonyMux shipped one pet, Mochi. Without ChatGPT or your own pets in ~/.codex/pets/, every Terminal got Mochi, and a row of identical ponies over the window doesn't tell you which session is which.

Now there are six: Mochi, Nyx, Opal, Pixel, Rex, and Mocha. New Terminals pick one at random, or the one you choose in Settings → General → Pets.

Settings → General → Pets in PonyMux 0.12: pick one of six ponies for new Terminals, or Random.

What else is smoother?

A lot of small waits moved off the main thread, so the window doesn't pause on them:

Waking a sleeping Terminal, resuming, forking, and handing off used to read the conversation file while you waited. On long Codex sessions that took up to 0.3 s.
Startup does its setup work in the background, and a lock held by another PonyMux can no longer hang the launch.
Markdown files with large images render in the background. Changing the column width or the theme re-renders up to 20× faster.

Reopening a Markdown file now picks up images that changed on disk, and VoiceOver reads the name of every switch in Settings.

Repetitive work doesn't have to feel repetitive. A bit of play in every move goes a long way.

For every effect and pet setting, see Personalize PonyMux.

Originally published on ponymux.com, where the demos are interactive.