Termic Runs CLI Coding Agents

Termic is an open source desktop app from the developer who posted it to Hacker News for managing CLI coding-agent sessions. It deals with a very specific annoyance: running Claude Code, Anthropic’s coding agent, OpenAI Codex, OpenAI’s coding agent, and similar tools across a main checkout or git worktrees without losing track of terminals. The useful takeaway is simple: Termic treats the OpenAI Codex CLI and other agent CLIs as the real product surface, then gives you a calmer desktop shell around them. For the common codex github path, the important split is that Codex lives in the openai/codex project while Termic manages the local sessions you run against your repositories.

Termic is a desktop session manager for terminal-first coding agents. It does not try to replace the agent with a custom SDK wrapper. That is the interesting part.

See why the PTY choice got attention

The maintainer’s July 2026 Hacker News note framed Termic as a reaction to pricing and packaging risk around programmatic agent APIs. Instead of building on an agent SDK, Termic runs the existing CLI binaries inside PTY terminals. A PTY is the pseudo-terminal interface that makes a program behave like it is sitting in a normal interactive shell.

That choice sounds low-level, but it is the whole bet. If your agent improves through its official CLI, Termic gets the behavior without chasing every API shape. If your agent auth, prompt UI, or permission prompt changes, the CLI is still the path the maker is likely testing hardest.

The trap is assuming “desktop app” means “new agent.” Here, the desktop is closer to a cockpit. The engines are still Claude Code, Codex CLI, AGT, or whatever binary you already trust enough to run in a repo.

Use worktrees as the safety rail

Termic’s most practical idea is not fancy orchestration. It is keeping agent sessions visible while they run in either a main checkout or a worktree.

That matters because coding agents are noisy collaborators. One session might refactor a React hook. Another might update tests. A third might be blocked on a failing migration. If all three are just terminal tabs with similar prompts, you will eventually review the wrong diff.

A clean Codex workflow starts with a disposable branch and a disposable worktree:

git worktree add ../shop-agent-smoke -b agent/smoke-check
cd ../shop-agent-smoke
codex
npm test
git diff --stat

Inside Termic, that worktree becomes a named session instead of “that terminal somewhere.” The agent can still use the codex cli exactly as it would in your shell. You get a better handle on where the session is running and what branch it is touching.

The trap is letting the desktop view create false confidence. A named session is not a review. You still need the boring loop: inspect the diff, run the tests, read the changed files, and decide whether the agent’s reasoning matches the code.

Keep repository instructions close to the code

For Codex users, the first durable artifact should be AGENTS.md. OpenAI’s Codex docs describe AGENTS.md as the place for custom instructions, and it fits this style of tool especially well because Termic is not hiding the repository from the CLI.

A small repo rule is enough to change the shape of an agent session:

# AGENTS.md

- Keep changes inside this worktree unless the task says otherwise.
- Before handing off, run `npm test` and include the failing output if it fails.
- Do not modify auth, billing, deployment, or secret-loading code without an explicit request.
- Prefer small commits that keep behavior changes and test changes easy to review.

That file travels with the repo, not with your memory of how today’s Termic session was started. It also helps when you move from a single terminal to multiple worktrees, because the agent sees the same constraints wherever it lands.

The trap is turning AGENTS.md into a policy novel. Put rules there that should survive many tasks. Put task-specific intent in the prompt you give the Codex agent.

For more patterns in this lane, the broader Codex CLI workflows topic is the right shelf. Termic also sits near projects such as Argus Manages VS Code Worktree Agents, where the interesting move is not “AI writes code,” but “give parallel agent work a body you can inspect.”

Try Termic when terminals are the bottleneck

Termic is worth trying when your real problem is session shape. If you already run the openai codex cli in several repos, switch branches often, and keep losing track of which agent touched which files, a desktop manager can remove friction.

It is also a good fit if you are wary of SDK-based wrappers. The maintainer’s argument is that PTY-backed CLI sessions are more likely to stay current with upstream agent behavior. That is a reasonable engineering instinct: run the thing the vendor ships, then organize around it.

Termic is overkill if you run one agent in one repo once a day. It may also be a poor fit if your workflow depends on deep IDE state, custom editor actions, or a very specific terminal multiplexer setup that already works.

For codex cli github work, keep the chain boring: install the CLI from the official project, run it in a clean worktree, and use Termic only to manage the session. Do not treat any wrapper as a substitute for knowing what binary is running, what repository it can edit, and what verification command proves the change.

Try it safely checklist

Use this as a small experiment, not a ceremony. The goal is to learn whether Termic reduces session confusion without adding review risk.

• Start with a non-critical repository or a throwaway worktree.
• Confirm your normal CLI binary works outside Termic first, including login and permission prompts.
• Add a short AGENTS.md with one verification command and one boundary rule.
• Create one task that should touch three to six files, not thirty.
• Run the session in Termic and keep the worktree name visible.
• After the agent stops, inspect git diff --stat before reading the explanation.
• Run the repo’s test command yourself, even if the agent says it already did.
• Delete the worktree after the test if the workflow felt noisy or unclear.

A tiny permission table helps too:

MCP is useful when an agent needs GitHub, docs, issues, databases, or design context. The first Termic experiment should not also be your first broad MCP experiment. Add one moving part at a time.

One methodology lens

One useful way to read this through our methodology is the Plan step: delegate first-pass decomposition and dependency mapping, review the sequencing and assumptions, and keep ownership of scope and priorities. If that split is still fuzzy, the workflow usually is too.

Practical starter checklist

- [ ] Name the Codex artifact first: an AGENTS.md instruction, a Codex CLI verification loop, an MCP boundary note, or a skills handoff.
- [ ] Write the review checklist before generation starts: scope, owner, tests, rollback.
- [ ] Keep the first step small enough that a reviewer can inspect the receipt without replaying the whole chat.

Common questions

• What should teams know about codex cli?

  Start by writing down one visible team rule for Codex, not a loose preference. That is the practical core of codex cli. That usually means a short repository convention, a review checklist, and one owner who can reject agent output when the evidence is missing.

• Which Codex artifact should teams standardize first?

  Standardize the smallest artifact that reviewers already touch: a AGENTS.md instruction, MCP note, or verification checklist. The point is not documentation volume; it is a shared place where scope, allowed tools, expected tests, and rollback notes are visible before generated code reaches review.

• How do teams know the convention is working?

  The convention is working when reviewers can approve or reject agent output from the artifact and evidence alone. Track whether pull requests name the rule used, include the promised checks, and avoid replaying long sessions just to understand what changed.

Best ways to use this research

• Best for: Codex teams deciding which AGENTS.md instruction, CLI workflow, MCP boundary, or verification loop to standardize next around “Termic Runs CLI Coding Agents.”
• Best first artifact: turn the named fix into an AGENTS.md rule, verification checklist, MCP note, or review receipt before the next automated run.
• Best comparison angle: compare the workflow against the current Codex CLI review loop, shell boundary, and evidence trail; keep the path that leaves the shortest auditable trail.

Further reading

• Termic — source
• OpenAI Developers — AGENTS.md guide
• GitHub — openai/codex
• OpenAI developers: codex quickstart

Next move

Take this into the related training topic and test whether a new reviewer can defend the merge without replaying the chat.