# Kennel 1.0.0 – Native Desktop App for Managing AI CLI Agents

> Source: <https://github.com/eranif/kennel>
> Published: 2026-07-07 17:22:46+00:00

Kennel is a fast, native desktop app that lets you run and manage many interactive
AI CLI agents — like **Claude Code**, **Kiro CLI**, **OpenAI Codex**, or any tool of
your own — side by side in a single window. Organize them into groups, keep them
running between tasks, and jump between conversations without juggling terminal tabs.
**Most importantly: restart your app or reboot your machine, and every session comes
back exactly where it left off, using the agent's native resume flag** (e.g., Claude's
`--continue`

or Kiro's `--resume`

).

| Platform | Download | Notes |
|---|---|---|
Windows 11 |
|

**macOS ARM**[kennel-macOS_26.5.1_arm64.zip](https://github.com/eranif/kennel/releases/download/1.0.0/kennel-macOS_26.5.1_arm64.zip)See [Releases](https://github.com/eranif/kennel/releases) for other platforms and versions.

If you use AI coding agents from the terminal, you already know the pain: a dozen terminal tabs, no idea which agent is waiting for you, and lost context every time you close a window. Kennel fixes that.

- 🗂️
**Everything in one place**— every agent session lives in a single window, in a tidy sidebar you can organize however you like. - 📁
**Group your work**— bucket sessions into groups such as*Work*,*Customer Tickets*, or*Experiments*. Collapse a group to get it out of the way; reopen it when you're back. - 🔄
**Never lose your place**— sessions persist between app restarts and resume with their native`--resume`

/`--continue`

flags, so your agent picks up where it left off. - ⚡
**Runs everything, natively**— each session is a real terminal (full PTY) backed by OpenGL on macOS & Windows, so any interactive CLI works exactly as it does in your shell — colors, prompts, and all. - 🧩
**Add any agent, no code required**— define new agents through a simple dialog or JSON. Local or over SSH. - 🌈
**Make it yours**— built-in color themes, custom fonts, and per-agent icons.

| Start an agent | Manage groups |
|---|---|

Define a new agent in three guided steps:

| Step 1 — Local or Remote? | Step 2 — What to launch |
|---|---|

| Step 2 — Filled in | Step 3 — Shell & Environment |
|---|---|

Kennel has just three things to understand:

| Concept | What it is |
|---|---|
Agent |
A definition of how to launch an AI CLI — its executable, arguments, environment, icon, and (optionally) a remote host. Kennel ships with Claude Code, Kiro CLI, and OpenAI Codex predefined. |
Session |
A single, named, running instance of an agent in a working directory. Each session is a live terminal. |
Group |
A folder in the sidebar that holds related sessions. There's always a Default group; create as many others as you want. |

The sidebar on the left is a tree of **Groups → Sessions**. The large area on the
right is the terminal for the currently selected session.

Press ** Ctrl/Cmd+T**, choose

**File → Start Agent…**, or click the

**➕** button in the toolbar. The

**Start Agent** dialog lets you set:

**Agent**— which CLI to launch (defaults to your configured default agent).** Session Name**— a unique, human-friendly label for this session.** Session Group**— pick an existing group or type a new name to create one on the fly.** Working Directory**— where the agent runs. Browse locally, or browse a** remote host over SSH**for remote agents.*Create an inner folder within the working directory*— automatically nests a folder named after the session.*Resume the Latest Session in This Folder*— relaunch the most recent agent run from that directory instead of starting fresh.

Click **OK** and your agent launches in a new session under the chosen group.

Selecting a session in the sidebar brings its terminal to the front. Type and interact exactly as you would in any terminal. While an agent is busy, its sidebar icon shows a spinner; when it's done, it returns to the agent's icon — so you can tell at a glance which agents are working and which are waiting for you. If a background session finishes while the window is inactive, Kennel gently requests your attention.

Right-click a session for the context menu:

**Move to Group ▸**— send the session to another group, or** New Group…**to create one. Moving the last session out of a group removes the empty group (except** Default**, which always stays).** Close**— permanently remove the session.

Right-click a **group** header for:

**Start Agent…**— launch a new agent pre-assigned to that group.** Rename Group…**— rename the group (Default can't be renamed).** Close Group**— close every session in the group at once.** Refresh**— restart every session in the group.

Beyond the three built-ins, you can define your own agents — a locally-installed CLI,
an internal tool, or an agent that runs on a **remote machine over SSH**.

Open **File → Create New Agent…** (** Ctrl/Cmd+N**) to launch the

**New Agent Wizard**, which walks you through three steps:

Choose whether the agent runs on your local machine or on a remote host over SSH.
If remote, provide the host address and (optionally) a username. You can browse your
saved SSH hosts with the **…** button.

Configure the agent's identity and command:

| Field | Purpose |
|---|---|
Name |
Display name shown in menus and the sidebar. |
Executable |
The command to run — the wizard auto-discovers known CLIs (`claude` , `kiro-cli` , `codex` ) locally or on the remote host. |
Launch Args |
Arguments passed on every launch (e.g. `--agent my-agent` ). |
Resume Args |
Flag(s) used to resume a prior session (e.g. `--resume` , `--continue` ). Pick from suggestions via …. |
Image |
An SVG icon to represent the agent in the UI. Browse shipped assets via …. |

| Field | Purpose |
|---|---|
Login Shell |
Override the shell used to spawn the agent (e.g. `/bin/zsh` , `wsl.exe` ). |
Environment Variables |
Extra name/value pairs passed to the agent process. Add or remove with the New / Delete buttons. |

Click **Finish** and the new agent appears immediately in the toolbar and the
**Start Agent** dialog.

| Action | Shortcut |
|---|---|
| Start Agent | `Ctrl` /`Cmd` + `T` |
| New Terminal | `Ctrl` /`Cmd` + `E` |
| Create New Agent | `Ctrl` /`Cmd` + `N` |
| Restart Current Session | `F5` |
| Select Next Session | `Ctrl` /`Alt` + `→` |
| Select Previous Session | `Ctrl` /`Alt` + `←` |

Kennel remembers your sessions between runs. On restart it restores each session and,
where the agent supports it, resumes the underlying conversation using that agent's
native resume flag (configured as **Resume Args**). This means closing Kennel — or
rebooting — doesn't cost you your agent's context.

Sessions that self-exit (via `Ctrl-D`

or `exit`

) are automatically removed from the
sidebar.

**Themes**— pick a terminal color theme from** Settings → Theme**(Cobalt2, Monokai, One Dark, One Light, and more).** Font**— set the terminal font and size from** Settings → Change Terminal Font…**.** Remote hosts**— manage reusable SSH hosts from** Settings → Manage Remote Hosts…**.** Plain terminals**— open a terminal without an agent via** File → New Terminal**(`Ctrl`

/`Cmd`

+`E`

).

All settings live under `~/.kennel/`

and are editable in the app.

For build prerequisites, per-platform instructions, and the developer guide, see
** BUILDING.md**.

Everything lives under `~/.kennel/`

:

```
~/.kennel/
├── config.json      # Your agent definitions
├── workspace.json   # Your sessions and their groups
├── .persist.json    # UI preferences (window size, theme, fonts) — safe to delete
└── logs/kennel.log  # Application log
```

Corrupt `config.json`

or `workspace.json`

files self-recover: Kennel backs up the bad
file (`*.bak-<timestamp>`

) and falls back to safe defaults, so the app always launches.

Agents are stored in `config.json`

under the `agents`

array. The **Edit / New Agent**
dialog is the friendly front-end for this, but you can edit the file directly:

```
{
  "version": 1,
  "global": {},
  "agents": [
    {
      "name": "Claude Code",
      "executable": "claude",
      "baseArgs": [],
      "resumeArg": "--continue",
      "iconPath": "claude-code.svg",
      "extraArgs": [],
      "env": {}
    },
    {
      "name": "Kiro CLI",
      "executable": "kiro-cli",
      "baseArgs": ["chat"],
      "resumeArg": "--resume",
      "iconPath": "kiro.svg",
      "extraArgs": [],
      "env": {}
    },
    {
      "name": "Remote Builder",
      "executable": "kiro-cli",
      "baseArgs": ["chat"],
      "resumeArg": "--resume",
      "iconPath": "builder.svg",
      "extraArgs": [],
      "remoteHost": "dev-box.example.com",
      "remoteUser": "user",
      "env": { 
        "PATH": "/home/user/python3/bin:$PATH" 
      }
    }
  ]
}
```

Set `remoteHost`

/`remoteUser`

to run an agent over SSH.

**A session won't launch.** Make sure the agent's **Executable** is on your `PATH`

(or use an absolute path). Check `~/.kennel/logs/kennel.log`

for the exact command and
error.

**Remote (SSH) agent fails to connect.** Confirm you can `ssh <user>@<host>`

non-interactively (key-based auth). Kennel uploads a small helper and runs the agent
over an interactive SSH session.

**Sessions didn't come back after restart.** Verify `~/.kennel/workspace.json`

exists
and is readable; if it was corrupt, look for a `workspace.json.bak-<timestamp>`

backup.

**Theme colors look off.** Pick a built-in theme from **Settings → Theme** and check the
log for theme-loading errors.

Kennel is licensed under the **BSD 3-Clause License**. See [ LICENSE](/eranif/kennel/blob/main/LICENSE).

**Eran Ifrah** — [GitHub](https://github.com/eranif)

[CodeLite IDE](https://codelite.org)— the cross-platform, OpenSource IDE.[wxTerminalEmulator](https://github.com/eranif/wxTerminalEmulator)— the embedded terminal control that powers Kennel's sessions (fetched automatically at build time).[wxWidgets](https://www.wxwidgets.org)— the cross-platform GUI toolkit Kennel is built on.