DEV Community: magicletur

Improving Agentic Workflow

magicletur — Tue, 08 Sep 2026 22:21:17 +0000

Short summary of my journey towards agentic orchestration with Thurbox and Fleet.

I wanted to handle multiple Claude code sessions in parallel so I created Thurbox based on tmux, I created it way before herdr or alternatives that are nowadays very popular.

With Thurbox I could clearly increase my productivity and reduce the overhead of having multiple Claude Code sessions running in parallel for multiple project on dedicated worktrees.

Next challenge was keeping in mind and orchestrating cleanly those multiple tasks without getting confused or forgetting what I started. Having some kind of agentic ticket manager (like beads) did not work very well for me. And orchestration like Gastown seemed too complex for what I want. So I quickly realized that I needed a dedicated agent that I first called "fleet" with all the context of my project and that could create sessions and send tasks via Thurbox CLI. I have then discovered very good projects with very similar approach (like firstmate). Mine was tied to my custom setup. It was not as clean as firstmate, but it was already working very nicely with Thurbox.

That is why I started few days ago this Fleet repo, that I am planning to use on a daily basis and make evolve! Goal is not like firstmate and fit with different backends, I want to create something that perfectly match Thurbox features. Feel free to try and helping me improving it!

By the way I am still trying to add proper support for Thurbox to some popular orchestration framework (Gascity, Firstmate...)

Thurbox

magicletur — Wed, 26 Aug 2026 12:07:14 +0000

Can Thurbox run Doom?

Yes.

Now that the important question is out of the way: Thurbox exists to orchestrate coding agents and give you an efficient way to work with them. On top of that, it fills in features some agents are missing — and it does so in an agent-agnostic way. Sending and receiving messages between agents, for instance.

Website: https://thurbox.thurbeen.eu/
Repo: https://github.com/Thurbeen/thurbox (Rust, MIT)

Why a CLI and a TUI instead of an app

Most of us worked this out a while ago: a plain UI application isn't enough once you're orchestrating multiple tasks every day. What developers and power users actually want is a CLI that can set up and automate agentic sessions.

But once those sessions exist, you still need somewhere to watch them and step in. Hence the Thurbox TUI.

A terminal interface doesn't have to mean keyboard-only, either. Thurbox supports the mouse — click a session to select it, click into a pane, scroll — and more generally it tries to do as much as it can to stay usable for everyone, whatever way you prefer to drive it.

Why I built it

I'm a DevOps engineer, and I work across a lot of projects at once — many repos, many contexts.

I built Thurbox to cut the mental overhead of managing several agentic sessions at the same time: remembering to claude --resume in the right repo, juggling worktrees, keeping track of what's running where.

How I work with it today

My workflow keeps evolving toward multi-agent orchestration. Right now it looks like this:

One fleet agent handles all my tasks from a single session.
It communicates through Thurbox tasks and messages with a dispatch agent.
The dispatcher spawns new sessions with the right context to resolve each issue.

I pair that with a custom Thurbox layout and panes, so I can monitor progress on each topic at a glance.

The part I find most satisfying

Closing the UI doesn't kill anything. Sessions are backed by tmux, so I can quit Thurbox, go do something else, and every agent keeps working in the background.

Same story across a reboot. I restart my machine, run thurbox, and I'm back where I left off — the session list, the repos and worktrees they're attached to, and my customizations too. The panes, the layout, the theme: they're plain files in a directory I own, so nothing to set up again.

It also means Thurbox itself gets out of the way. I can upgrade it — or roll back to an older version — while my agents keep running underneath. And I can keep tinkering with my custom UI, moving panes around and rewriting layouts, without interrupting a single session.

That all sounds like a small thing. In practice it's the difference between a tool you open when you need it and one you just leave running.

What Thurbox is not

Thurbox is not another tmux reimplementation, the way something like herdr is. It's also not a heavy web app running in the background, like VS Code agents, Cursor or Orca.

Thurbox runs on battle-tested software as its core dependencies. Which means that if Thurbox breaks, your sessions are still there — and you can go back to raw tmux to handle them.

Install it

You'll need tmux 3.2+, git, and at least one coding-agent CLI (Claude Code, Codex, opencode, aider, Copilot CLI, and others are supported out of the box).

On Linux and macOS:

curl -fsSL https://raw.githubusercontent.com/Thurbeen/thurbox/main/scripts/install.sh | sh

On Windows:

irm https://raw.githubusercontent.com/Thurbeen/thurbox/main/scripts/install.ps1 | iex

If you'd rather use a package manager: brew install thurbeen/thurbox/thurbox, winget install Thurbeen.thurbox, choco install thurbox, or paru -S thurbox-bin on Arch.

Then just run it:

thurbox

That's the whole setup — sessions, agents, themes and the interface itself are seeded on first launch. From there, Ctrl+N creates a session: pick your repos, name it, choose an agent, and optionally spin it up on a fresh git worktree.

Thurbox v1.2.3

magicletur — Thu, 23 Jul 2026 21:30:12 +0000

Funny version number have been released.
What about trying Thurbox? A TUI equivalent of Orca, 1Code, conduct, cursor... List is long but only a few provides a stable tmux backend and a powerful CLI to automate your agentic dev setup.
TUI allows a very lightweight development environment.
I have been using it for multiple hours daily and evolving it for now few months, most features I want are now working juste fine!

Thurbox

magicletur — Mon, 22 Jun 2026 14:59:32 +0000

Overview

Check out the Thurbox GitHub Repository and the Website.

A few months ago — before herdr, before orca, before multi-agent orchestration became a trend — I built Thurbox. The initial goal was simple: make Claude Code session management less painful. It grew from there into a full orchestration layer, agent-agnostic at its core, powered by thurbox-cli. The thurbox TUI sits on top: lightweight, low-resource, and a clean way to interact with all your sessions.

Thurbox is built around stability and efficiency. Rather than reinventing the wheel, it delegates the heavy lifting to tmux — battle-tested, reliable, and already excellent at what it does. This means hot-reload style updates work out of the box, and closing the thurbox TUI never kills your sessions.

Comparison

Already using a session orchestrator? Here's how Thurbox stacks up.

vs Orca

Orca is polished — fancy UI, mobile app, split panes, an embedded browser, a design mode. It first appeared on GitHub in March (Thurbox launched in February). Feature-for-feature, Orca has more.

That said, most of those extras already exist as standalone tools. Need a browser? Firefox or Chromium with a Playwright driver handles AI integrations without the overhead. More critically, Orca replaces tmux with a custom reimplementation that introduces real bugs: new sessions take ~10 extra seconds to start, and display issues are common — not just Claude Code ones.

vs herdr

herdr felt to me like an overengineered solution to a non-problem. It reimplements tmux with a custom Unix socket layer so agents can report their current status — idle, working, blocked, done.

Thurbox solves the same thing differently: pre-configured agent hooks that call thurbox-cli to push status updates. Slightly slower to propagate, yes — but it runs on top of actual tmux, not a reimplementation of it. The rest of herdr is essentially the same stack: Rust + Ratatui TUI.

The Power of thurbox-cli

(Orca and herdr offer similar capabilities here)

My first instinct was to build a Thurbox MCP server for agentic workflows. But MCP consumes more tokens and is always slower than a well-designed CLI — just look at how gh or glab handle daily PR/MR creation. MCP also rules out simple shell scripts for orchestration.

Here's a practical example for a monorepo with a production app:

Start one or more operator sessions in worktrees with a custom MCP config — read/write access to the prod backoffice
Start one or more developer sessions in worktrees with a custom MCP config — read-only access to the prod backoffice
Start one or more security/quality reviewer sessions running continuous code review across the monorepo

A single shell script. No glue code, no overhead.

set -euo pipefail
REPO="${REPO:-/home/me/code/monorepo}"   # path to the monorepo
BASE="${BASE:-main}"                      # branch worktrees fork from
N_OPERATORS="${N_OPERATORS:-1}"
N_DEVELOPERS="${N_DEVELOPERS:-2}"
N_REVIEWERS="${N_REVIEWERS:-1}"
STAMP="$(date +%y%m%d-%H%M)"
cli() { thurbox-cli "$@"; }

# 1) Operator sessions — RW backoffice, each on its own worktree branch.
for i in $(seq 1 "$N_OPERATORS"); do
  cli session create \
    --name "operator-$i" \
    --repo-path "$REPO" \
    --agent operator \
    --worktree-branch "ops/$STAMP-$i"
done

# 2) Developer sessions — RO backoffice, each on its own worktree branch.
for i in $(seq 1 "$N_DEVELOPERS"); do
  cli session create \
    --name "developer-$i" \
    --repo-path "$REPO" \
    --agent developer \
    --worktree-branch "dev/$STAMP-$i"
done

# 3) Security/quality reviewer sessions — continuous review across the monorepo.
#    No worktree: review the repo as-is (read-only stance comes from the prompt).
for i in $(seq 1 "$N_REVIEWERS"); do
  id="$(cli session create \
        --name "reviewer-$i" \
        --repo-path "$REPO" \
        --agent reviewer \
        --json | jq -r '.id')"
  # Seed the reviewer with its standing instructions.
  cli session send --to "$id" --no-wake --body \
"You are a continuous security & code-quality reviewer for this monorepo.
Loop: pick the most recently changed files, review for security issues, correctness bugs,
and quality regressions. Report findings concisely, then move to the next changed area.
Do not modify code — review only."
done

cli session list

And configure the agents in your ~/.config/thurbox/agents.toml:

[[agents]]
name = "operator"                 # prod backoffice: read/write
command = "claude"
args = ["--mcp-config", "/home/me/.config/thurbox/mcp/backoffice-rw.json"]
new_session_args = ["--session-id", "{id}"]
resume_args     = ["--resume", "{id}"]
fork_args       = ["--resume", "{id}", "--fork-session"]

[[agents]]
name = "developer"                # prod backoffice: read-only
command = "claude"
args = ["--mcp-config", "/home/me/.config/thurbox/mcp/backoffice-ro.json"]
new_session_args = ["--session-id", "{id}"]
resume_args     = ["--resume", "{id}"]
fork_args       = ["--resume", "{id}", "--fork-session"]

[[agents]]
name = "reviewer"                 # continuous code review, no backoffice access
command = "claude"
args = []
new_session_args = ["--session-id", "{id}"]
resume_args     = ["--resume", "{id}"]
fork_args       = ["--resume", "{id}", "--fork-session"]

Notable Features

Multi-repo context, handled cleanly. Thurbox can create multiple worktrees, place them in the same directory via symlinks, and spin up a session with exactly the context you want — frontend + backend, app + infra, whatever combination makes sense. No manual setup per session.

Remote sessions over SSH. As long as tmux is installed on the remote host, Thurbox handles the rest. Simple config, powerful result.

Windows support. Thurbox runs natively on Windows via psmux.

Give It a Try

If any of this resonates, the best next step is to just try it:

curl -fsSL https://raw.githubusercontent.com/Thurbeen/thurbox/main/scripts/install.sh | sh

Full setup instructions are in the GitHub repository. The website covers the main concepts if you want a guided intro first.

If you run into something broken, something missing, or just have an idea — issues and PRs are very welcome. Thurbox is a side project built out of a real need, and contributions from people using it in the wild are what make it actually useful.