YardletBlog

What desktop apps for coding agents add to Claude Code and Codex

An app that runs several agents has to know when each one is working, waiting or done. Nine apps solve it with global hooks, command wrappers, a terminal signal or the agent's own protocol, and some add their own text to the prompt. What each does as of November 13, what it leaves on your Mac, and its memory at rest.

I make Yardlet, a free, open-source Mac app that runs coding agents like Claude Code and Codex in one window. So I make one of the apps in this post, and you should read it with that in mind. I've linked every claim to the app's own code at a fixed commit or to its documentation, as of November 13, 2026. Where I couldn't find out, I say so.

An app that runs several agents at once has to know what each one is doing: working, waiting for you, or done. Claude Code and Codex were built to be used directly, so each desktop app picks its own way to find out. That choice decides what the app adds to the agent and what stays on your Mac after you stop using it.

Apart from Yardlet, each app here is a commercial product or part of an open-source project with at least 10,000 stars on GitHub.

How an app finds out what the agent is doing

Hooks in the agent's own settings. Claude Code and Codex both run commands you register at points in a session: when a turn ends, when the agent needs permission, when it sends a notification. Both document this as an extension point. Claude Code reads hooks from ~/.claude/settings.json for every project, from a project's .claude/settings.json and a few other places (docs); Codex reads them from ~/.codex/hooks.json or a [hooks] table in ~/.codex/config.toml, and asks you to review and trust a hook before it runs (docs). A hook registered there tells the app exactly when a turn ends or a permission prompt appears, even when the agent runs as its normal terminal UI, and it works for any agent that has hooks. The catch is where it lives. A hook in your global settings runs in every session of that agent, including the ones you start in Terminal with the app closed, and it stays after you drag the app to the Trash unless something removes it. Orca and Paradev (Superset until October) work this way, and both make their hooks exit at once outside their own terminals.

Hooks for one process. A terminal app can put its own claude and codex in front of the real ones in the shells it opens, as a shell function or a script early on PATH. The wrapper then hands the agent hooks for that process only: Claude Code takes extra settings with --settings <file> (CLI reference), and Codex takes config overrides with -c. cmux does this, and leaves your settings files alone. The cost is that the command you type isn't quite the command that runs. In May a cmux release added --allow-dangerously-skip-permissions to every claude launch so a button could switch to bypass mode later. The flag doesn't turn bypass on by itself (Yardlet passes it too; see note 25 below), but in the terminal UI it sent ordinary claude starts down Claude Code's dangerous-mode path, as the fix describes. A user reported it about an hour after the release, and the maintainer removed it the same day.

A signal from the terminal. Claude Code 2.1.295 added the Program Status Protocol, an escape sequence (OSC 7501) that tells a terminal whether it's working, waiting on you, or done, and Codex reports it too since a change merged in October. A terminal app that reads it needs nothing installed anywhere. The Herdr app relies on it alone; cmux and Orca read it alongside their hooks (cmux, Orca). It only works with recent versions of the agents, and it says less than a hook: Claude Code sends the state and one short line, such as what it wants approved, and Codex so far sends the state alone (Orca's notes).

The agent's own protocol. Claude Code can run as a process that reads and writes JSON events (-p --input-format stream-json --output-format stream-json), which is also how the Claude Agent SDK drives it. Codex has an App Server that speaks JSON-RPC, the interface its VS Code extension uses. Many other agents speak the Agent Client Protocol. An app that drives the agent this way gets turns, tool calls and approval requests as data, so it needs no hook and no wrapper. T3 Code, Paseo, Vibe Kanban and Yardlet work this way, and Orca and Paradev use it for their chat views. The cost is on the app's side: it draws the conversation itself instead of showing the agent's own terminal UI, it supports only agents that have such a protocol, and it waits on whatever the protocol doesn't expose yet.

What else comes along

Knowing the agent's state is only part of it. Some apps also add their own text to the system prompt, so the agent knows it's inside the app: how to link a pull request, how to hand work to another agent. It works, and it means the agent you talk to isn't quite the one in its own app. Some install skills into the agent's global skills folder. Some mark their folders as trusted in the agent's config.

Nine apps, as of November 13

The table is about Claude Code and Codex; most of these apps run other agents too.

AppHow it learns the agent's stateWrites to the agent's own configIts own text in the system promptIdle memory1
cmux 0.65.2.2Hooks its wrappers pass to each process2, and OSC 7501Nothing by default3No4193 MiB
ConductorNot documentedNot documented5Yes6153 MiB
Herdr app 0.1.15OSC 7501Nothing7No77 MiB
Orca 1.4.257Hooks in your global config, and OSC 7501Hooks, a status line and trust entries8No9675 MiB
Paradev 2.0.8 (formerly Superset)Hooks in your global configHooks and skills10No11259 MiB
Paseo 0.15.4Agent SDK and App Server eventsSkills, if you keep the onboarding default12No13537 MiB
T3 Code 0.1.9Agent SDK and App Server eventsNothing14Yes, every session15532 MiB
Vibe Kanban 0.1.44stream-json and App Server eventsNothing by default16No17not measured
Yardlet 0.11.11stream-json and App Server eventsNothingIts MCP server's instructions1853 MiB
  1. Memory at rest on first launch, from my measurement on November 9 and 10 on one MacBook Pro (M1 Pro, 16 GB), with the versions current then: cmux 0.65.2, Herdr 0.1.14, Orca 1.4.254, Superset 2.0.6, Paseo 0.15.3, T3 Code 0.1.7 and Yardlet 0.11.10. Conductor and Superset stopped at their sign-in screens. More below.
  2. In cmux's terminals claude is a shell function and codex a shim early on PATH (function, shims). The Claude wrapper writes a settings file under ~/.cmuxterm/claude-settings/ and passes it with --settings (folder, launch); the Codex wrapper passes each hook with -c, plus --dangerously-bypass-hook-trust, which skips Codex's review of those hooks, not command approvals (source). Outside cmux the wrappers pass straight through.
  3. cmux hooks codex install writes ~/.codex/hooks.json and turns hooks on in config.toml, only if you run it (source). Claude and Codex launches also get cmux's Computer Use MCP server unless you set CMUX_COMPUTER_USE_MCP_DISABLED=1 (Claude, Codex). Settings › Automation turns the Claude and Codex integrations off.
  4. Only the cmux claude-teams command appends a short note (source).
  5. Conductor is closed source. Its docs don't say it writes to ~/.claude or ~/.codex; its own settings live in ~/.conductor/ (settings). It bundles its own copies of Claude Code and Codex and can use yours instead (harnesses).
  6. "Conductor injects system prompts that explain to the agent that it's running inside Conductor" (FAQ). A repository can add its own with prompts.general.
  7. Its core "does not guess from screen text or recognize agent brands. A program that does not report status has none" (herdr-core), so Claude Code needs 2.1.295 or later. It sets a few variables of its own in each terminal (source). The separate Herdr TUI offers an optional integration that adds one SessionStart hook, with an uninstall command (docs).
  8. Hooks in ~/.claude/settings.json and ~/.codex/hooks.json (Claude, Codex); a Claude statusLine when you have none (source); trust entries for its hook in ~/.codex/config.toml, so Codex doesn't ask you to review it (source); and folder trust for its workspaces in ~/.claude.json and Codex's config (Claude, Codex). The hooks also run outside Orca and exit there at once (script). Turning off Settings › Agents › Agent status hooks removes them (docs).
  9. Its chat view keeps Claude Code's own system prompt and sends Codex no developer instructions (Claude, Codex).
  10. At every launch it writes hooks into ~/.claude/settings.json and ~/.codex/hooks.json, and into the files of the other agents it supports (setup, hooks), and skills into ~/.claude/skills/superset/ and ~/.agents/ (source). Each hook does nothing unless SUPERSET_HOME_DIR is set, and only its terminals set it (guard), and a per-agent "Paradev hooks" switch in Settings › Agents removes them (switch). Claude's hooks already had that guard; the switch, and the guard for the agents that still lacked it, came in August after a user saw the hooks run in a plain terminal. Skills have their own switches in its Plugins view. Its claude and codex wrappers live in ~/.paradev/bin, first on PATH only in its own shells (source).
  11. I found no appended system prompt. Inside Paradev's terminals, a Claude hook blocks the first Artifact publish of a session and suggests a Paradev Page instead (source).
  12. Its onboarding starts with everything on, and Continue copies Paseo's skills into ~/.claude/skills and ~/.agents/skills (onboarding, paths). Hooks for agents you run in its terminal are off by default, do nothing outside it, and are removed when you turn them off (default, guard, removal).
  13. Its own prompt setting is empty by default (source); voice mode adds a block when you turn it on. With the onboarding default it also attaches its MCP server to each session (source).
  14. Everything goes per session: SDK options for Claude, thread config for Codex (Claude, Codex).
  15. Claude sessions get runtime notes and pull-request rules, and with T3's MCP server attached, as it is in normal use, delegation rules (source, text). Codex gets the same as context with each turn, and an ACP agent's prompt is wrapped in <t3_code_instructions> (Codex, ACP). I found no setting that turns it off.
  16. Its hooks are callbacks inside the process (source). Its MCP settings page rewrites ~/.claude.json or ~/.codex/config.toml when you save it (source). It runs pinned versions through npx rather than the CLIs you installed (Claude, Codex). The company behind it shut down in April and the community maintains it.
  17. A setting that's on by default sends the agent a reminder to commit when a turn leaves uncommitted changes, and another asks it to write the pull request's description when you open one (text, defaults).
  18. About 900 characters that Claude Code and Codex show the model, with the descriptions of its tools, plus whatever you write in Yardlet instructions, which is empty by default. See the next section.

MCP servers an app attaches also put text in front of the agent, their tool descriptions and sometimes instructions: cmux's Computer Use server, T3 Code's, Paseo's when you keep its onboarding default, and Yardlet's.

Links to code point at the release named, or, for T3 Code, Paseo and Vibe Kanban, at main on November 12; I checked that the defaults, launch flags and prompt text cited there are the same in the release named.

A few things stood out. The apps that put hooks in your global settings have also built ways to undo it: Paradev added its switch, and the guard where it was missing, after a user report, Orca removes its hooks when you turn them off, and Paseo's terminal hooks are off until you turn them on. cmux shows that hooks don't have to live in your settings at all.

Yardlet, the same way

Yardlet runs Claude Code with --print --input-format stream-json --output-format stream-json and Codex as app-server --stdio; OpenCode, Antigravity, Kimi Code, Grok Build and Hermes go over ACP (Claude, Codex). It registers no hooks and writes nothing into ~/.claude, ~/.claude.json or ~/.codex. Its terminal panel starts your login shell with four variables (TERM, COLORTERM, and cat as PAGER and GIT_PAGER) and nothing in front of the agent commands (source).

Here is what Yardlet adds:

  • Its MCP server. Each Codex, Claude Code and ACP session Yardlet starts gets yardlet-mcp through that session's own option, which I wrote about in an earlier post. The agent then sees the server's instructions, about 900 characters on how to use the browser and task tools (text), and the descriptions of up to 46 tools of its own, 21 of them for the browser (list), plus the tools of any connectors you've signed in to.
  • Turning the tools off. Settings › General › Agent browser tools takes the browser tools (20, or 21 with a saved password) out of sessions started afterwards (setting), Share the terminal with agents removes one more, and a connector can be turned off for a task. The other 24 tools and the instruction text stay: there is no switch yet that starts a session without the server (source).
  • Claude Code's launch options. Its own task, session and settings tools are pre-approved with --allowedTools, so Claude Code doesn't ask before them (source). The claude.ai account's own connectors are off unless you turn them on in Settings, because Yardlet's connectors are shared by every account (source). And when a Yardlet connector serves the same address as one of your own MCP servers, that server is left out of the process with --settings (source).
  • Permission modes. Yardlet sets the mode on each Codex thread, Ask for approval unless you pick another, so a default in your config.toml applies only if you pick Custom (thread, values). To Claude Code it passes --allow-dangerously-skip-permissions, so you can switch a session to Bypass later; sessions start in Claude Code's default mode (source).
  • Yardlet instructions. Text you write in Settings goes to the agents that take extra instructions for one session (Claude Code, Codex, Grok Build, Pi and Antigravity), appended to Claude Code's system prompt and as Codex's developer instructions. It's empty unless you write something, and Yardlet adds no words of its own to it (source). One exception: an optional daily routing evaluation, off by default, adds a short note on which agent and model to use for which kind of work when you turn it on (default).

The protocol route has its costs here too. Cursor Agent, Pi and Muse Code have no way to take an MCP server for one session, so their tasks in Yardlet run without its tools. Yardlet shows a conversation it draws itself, not Claude Code's or Codex's terminal UI.

Memory at rest

The last column of the table comes from the post I published on November 11, measured on November 9 and 10 on one MacBook Pro (M1 Pro, 16 GB, macOS 15.6.1). Each app was opened for the first time in an empty home folder, left alone for a minute and sampled for two; memory is the phys_footprint sum of every process macOS charges to the app, the number Activity Monitor shows. The agent CLIs were stand-ins and aren't counted, which leaves out the Codex App Server Yardlet starts at launch. Conductor and Superset (now Paradev) were measured at their sign-in screens, and cmux was playing its welcome video; on a second launch it used 168 MiB. Vibe Kanban wasn't in that run.

With ten tasks streaming at once, Yardlet used 214 MiB, T3 Code 867 MiB and Paseo 987 MiB; the others weren't run under load. That post has the per-run data, where Yardlet does worse, and what the numbers leave out.

Checking your own Mac

If you've tried a few of these apps, this shows what they left behind:

Shell
# Hooks every session runs
grep -n '"command"' ~/.claude/settings.json
cat ~/.codex/hooks.json
grep -n -A3 '^\[hooks' ~/.codex/config.toml

# Skills every session loads
ls ~/.claude/skills ~/.agents/skills

# Run in an app's terminal
type claude codex

# A running agent's flags
ps -o args= -p "$(pgrep -nx claude)"

An app's own hook usually checks a variable that only its terminals set, so finding one doesn't mean it does anything in your other sessions. If you want it gone, the app's own switch is the safer way to remove it, where there is one.

What this doesn't cover

I read code and documentation; I didn't run each app and watch what it wrote, except for the hands-on notes behind the memory post. I couldn't check Conductor's code, and what happens to these files when you delete each app isn't documented anywhere I found, so I've left it out of the table. All of these apps ship every few days. If something here is wrong or out of date, open an issue and I'll correct it in the post with the date.