devpit

devpit

devpit · Coding · Productivity

devpit is a desktop app that keeps your Claude Code agents in one window: a terminal per project, a board that starts real work, a cost figure on every call, and an orchestrator across projects.

Interface preview of devpit

About devpit

What Is devpit

devpit is a coding agent control room for developers who run several Claude Code sessions at the same time. Instead of six terminal tabs and a vague sense that something is burning tokens, you get one attached terminal per project, a board that shows where each piece of work stands, and a running cost on every agent call.

The app is built in Rust with Tauri, so terminals are real ptys behind tmux rather than a browser pretending to be a shell. On Windows the same job goes to psmux. Projects, boards, conversations and terminal history live in ~/.devpit on your machine, and a repository stays untouched. An account is optional, and today it only signs you in.

The limits are worth knowing before you install. Full agent driving works with Claude Code, since that is the CLI devpit knows how to run. Other tools can report status through a hook, but the board steps still call Claude Code. Sync between machines is not built yet, and the Plus tier that covers remote access is planned rather than shipped.

Getting Started

  1. Install devpit with the one line installer from the site or the GitHub releases page. On Linux you get a .deb or an AppImage, on macOS a universal .app, on Windows a per-user installer.
  2. Open the app. Your existing claude CLI on the PATH is what it drives, so no new API key is needed and your Claude Code plan keeps paying for usage.
  3. Create a project and point it at a folder. Each project gets its own terminal, board, and workspace in ~/.devpit.
  4. Give a column a step: pick an agent, a model, the slice of the card context it receives, and a spending cap.
  5. Move a card into that column. The step runs in the terminal you already have open and writes its output, exit code and real cost back on the card.

Product Information

A quick look at devpit's pricing, supported platforms, and performance.

Free PlanYes
Paid Plans$0 - $4/mo
PlatformLinux, macOS, Windows
Developerdevpit
CategoryCoding · Productivity
Release DateSep 2026
Latest UpdatedOct 2026
Website VisitsN/A
Website Global RankN/A
API AvailabilityN/A

Best for

The users, tasks, and scenarios where this tool fits best.

Users

  • Developers running two or more Claude Code sessions a day
  • Solo builders shipping side projects
  • Small teams that share a repo

Tasks

  • Moving work through review and verification stages
  • Running tests, builds and lints next to an agent
  • Checking what an agent changed
  • Watching several projects at once

Scenarios

  • You come back after lunch and cannot tell which of five terminals is still working
  • A long refactor needs its own checkout

Key features

One target terminal per project

Each project has a single terminal that receives attention. Switch to another project and the previous session keeps running in the background, out of sight but not stopped. You stop juggling tabs and start watching one thing at a time.

Sessions that outlive the window

Terminals are tmux panes, or psmux panes on Windows. Close devpit, reopen it later, and the processes are still there with their scrollback. The same applies during an update, so a running agent does not die because the app restarted.

A board that runs real work

Every project gets a Kanban board with columns you name, reorder and extend. A column either does nothing or holds one step of three kinds: an agent call, a session that takes over the target terminal, or a shell command. Moving a card resolves the step into one invocation with a fixed agent, model, context slice and expected answer shape.

A spending cap on every agent call

Each step carries its own ceiling in dollars, and the card shows the real cost when the step finishes. That combination makes an agent workflow auditable: you know what was allowed before it ran and what it actually cost afterwards.

Files, diffs and a browser beside the terminal

A file tree and diff view sit next to the terminal, so reviewing an agent's change does not mean switching apps. A browser pane opens the project's localhost server, keeps sessions separate per pane, and can pull a signed-in session from Chrome, Firefox or Safari for a specific domain.

Agents as files on your machine

Agent definitions are markdown files with frontmatter in ~/.devpit/agents/, plus whatever your tooling already installed. devpit references them instead of copying them, so the catalogue stays where it belongs. Nothing needs recompiling or registering.

An orchestrator across projects

The orchestrator is a chat you drive. It reads every board you link, lists the sessions running on your Claude Code account, and can start a new session on a card in that card's own worktree. It never moves a card into a lane that runs a step, never acts on a timer, and cannot approve anything in another session.

Pros and cons

Pros

  • Cost per agent call is visible on the card, which turns token spending into something you can budget instead of guess.
  • The board is optional, so a plain terminal session works exactly as it did before you installed anything.
  • Local-first storage in `~/.devpit` keeps repositories clean and avoids a gitignore entry.
  • The spending cap and the context slice per column cut the usual waste of loading every agent and every document into each call.
  • Sessions survive window closes and app updates because tmux holds the processes.

Cons

  • Full board automation assumes Claude Code. If your team runs Codex, Cursor or Gemini CLI as the main driver, the agent steps are not for you yet.
  • The macOS build is not signed or notarised, so Gatekeeper refuses the first launch until you open it from the context menu or clear the quarantine flag yourself.
  • Setup takes real thought. A new project starts with empty lanes, and every column needs an agent, model and cap before it does anything useful.
  • Machines do not sync. An account signs you in and nothing more, so two computers mean two separate workspaces.

Frequently asked questions

Not for board steps. Agent and session steps go through the claude CLI on your PATH. Other tools can report status to the board through the devpit-agent hook, and Gemini CLI does that with no configuration, but the work itself still runs on Claude Code.