# Show HN: Lazychat – A lazygit-style TUI for running Claude Code and Codex

> Source: <https://github.com/Perpeer/lazychat>
> Published: 2026-10-05 11:56:57+00:00

**One terminal for all your AI coding agents.**

  Run Claude Code and Codex sessions side by side, see at a glance which one needs you,

  and keep Git and a shell for every project one key away.

[Website](https://perpeer.github.io/lazychat/) ·
  [Install](#install) ·
  [Quick start](#quick-start) ·
  [Features](#features) ·
  [Sponsor Lazy ♥](#sponsor-lazy) ·
  [Contributing](#contributing)

You need a Mac (Apple silicon or Intel, macOS 12 or newer) and an AI coding
agent you are logged in to: [Claude Code](https://code.claude.com/docs) or
[Codex](https://github.com/openai/codex).

```
brew install perpeer/tap/lazychat
```

Homebrew builds lazychat on your Mac, along with Lazy's menu bar app, so
macOS opens both without a warning. Then run `lazychat`; `lazychat doctor`
says what else is ready. Lazy starts with lazychat; `brew services start lazychat` keeps it in the menu bar from every login. `brew upgrade lazychat` takes a new release; lazychat tells you in green, beside its
version, when one is out.

lazychat comes from our own tap for now. Homebrew's own list takes it at
225 stars, and then it is just `brew install lazychat`. If it saves you a
few tabs, [star it](https://github.com/perpeer/lazychat/stargazers): every
star helps lazychat reach more people.

```
git clone https://github.com/perpeer/lazychat
cd lazychat
./install.sh
```

The script checks your Mac first and tells you what is missing and how to
get it; `./install.sh --check` does only that. It installs Go with Homebrew
if you don't have it (an older Go fetches the one lazychat needs by
itself), builds `~/.local/bin/lazychat` and adds Lazy's menu bar app to
Applications.

To remove lazychat, run `brew uninstall lazychat`, or `./uninstall.sh` for
a source install. Your settings and workspaces stay (`./uninstall.sh --purge` takes them too); your projects and the agents' own files are
never touched.

1. Run `lazychat` and name a workspace, the set of projects you work on.
2. Press `o` and pick a project folder.
3. Press `n` to start Claude Code or Codex in it,`Enter` to type to it,
and`ctrl+q` to come back.
4. `Tab` moves between the tabs, and`?` lists every key where you are.

`lazychat doctor` tells you which agents are ready, and why not.

Every session sits under its project with its terminal next to it. You can
see which one works, which one waits for you and how long the last prompt
took. `n` starts one, `r` resumes an old one, and `w` lets you draft the
next prompt while the agent is still busy. `i`, or
a click on Lazy while several wait, opens the inbox: the sessions asking
you something or finished, Enter opens one. Press `3` for the details. At
the top is the prompt's flow, drawn like `git log --graph`: each tool it
called in order with the file it touched or the command it ran, a
subagent as a branch that forks off and joins back when it returns, a
question to you, and what each step added to the context. Beside it is the session's context, drawn like Claude
Code's `/context`: how full the window is, what fills it, which tool's
results took the most, and how many more prompts fit at this pace. At the
bottom are your last ten prompts as a table with their state, duration,
tokens and API cost. Lazy says hello when lazychat opens, and plays a
sound when a session starts on a prompt, asks you something, finishes or
fails; you can turn the sounds off in Settings.

```
┌ [1] projects ──────────┐┌ [2] session │ [3] details ───────────┐
│ garden-shed            ││ ❯ paint the shed blue                │
│ main                   ││                                      │
│   │                    ││ ● Starting with the north wall.      │
│   ├─ ● ivy             ││   Reading paint.go…                  │
│   │    claude · 42s    ││                                      │
│   │                    ││ > ▌                                  │
│   └─ ○ oak             ││                                      │
│        codex · 3m 18s  ││                                      │
└────────────────────────┘└──────────────────────────────────────┘
session: (enter) continue · (n) new · (r) resume · (w) draft · (?) help
```

Changes as a folder tree, a diff you can walk line by line with the code
in its language's colours — `v` selects lines, `space` stages just
those — your last commits and the repository's worktrees. `Suggest` asks the agent for a
commit message written from what you staged.

```
┌ [1] projects ──┐┌ [2] Unstaged · 1 ────┐┌ [5] diff ──────────────────┐
│ garden-shed    ││ M paint.go           ││ @@ -3,2 +3,2 @@            │
│ main ↑1        │└──────────────────────┘│ - color := "red"           │
│                │┌ [3] Staged · 1 ──────┐│ + color := "blue"          │
│ blue-door      ││ + door.go            ││                            │
│ worktree       │└──────────────────────┘└────────────────────────────┘
│                │┌ [4] commits ─────────┐┌ [6] commit ────────────────┐
│                ││ ↑ a1b2c3d first coat ││ Paint the door blue        │
│                ││   9f8e7d6 sand it    ││────────────────────────────│
│                ││                      ││      [ Suggest ] [ Commit ]│
│                ││                      ││                            │
└────────────────┘└──────────────────────┘└────────────────────────────┘
branch: (c) commit · (p) pull · (shift+p) push · (b) branches · (w) worktrees
```

Plain shells in your projects' folders, for the things the agents don't do.

```
┌ [1] projects ──────┐┌ [2] sh 1 ──────────────────────────────┐
│ garden-shed        ││ $ go test ./...                        │
│ main               ││ ok   shed/paint   0.4s                 │
│   │                ││ $ ▌                                    │
│  ├─ ● sh 1         ││                                        │
│  │                 ││                                        │
│  └─ ○ server       ││                                        │
└────────────────────┘└────────────────────────────────────────┘
terminal: (enter) continue · (n) new · (e) rename · (v) copy · (d) close
```

Settings holds the theme, which tabs show and which agent writes your
commit messages. Every key and screen is in the
[reference](https://github.com/Perpeer/lazychat/blob/main/docs/REFERENCE.md).

Lazy watches your agents all day and has never asked for anything. lazychat is free and stays free; if it saves you time, keep Lazy going:

  ☕ **$3** a coffee · 🍩 **$10** a snack · 🛋️ **$50** a comfy cushion · 🚀 **$100+** super sponsor

lazychat follows [lazygit](https://github.com/jesseduffield/lazygit) and
[lazydocker](https://github.com/jesseduffield/lazydocker) by Jesse
Duffield: terminal UIs where everything is one key away. lazychat does the
same for AI coding agents.

AGPL-3.0, see `LICENSE`. lazychat is free to use, change and share; a
changed copy that is shipped, sold or run as a service has to stay open
source too, and keeps the credit in `NOTICE`.

Bug reports, ideas and pull requests are welcome: open an
[issue](https://github.com/perpeer/lazychat/issues) and tell us which agent
lazychat should support next. [CONTRIBUTING.md](https://github.com/Perpeer/lazychat/blob/main/CONTRIBUTING.md) explains
how the code fits together and how it is tested.
