Orchestration Tool Deep Dive

TSK
Agent Task Manager

A Rust CLI tool that lets you delegate development tasks to AI agents running in sandboxed Docker or Podman environments. Get back git branches for human review.

Rust Built with

2 Supported agents

7 Built-in stacks

dtormoen Creator

Overview

What Is TSK?

TSK enables a "lead engineer + AI team" model. You assign tasks using templates, agents run autonomously in parallel isolated containers, and you get back git branches containing their work for review.

The Core Idea

Instead of running a single AI coding agent in your terminal and watching it work, TSK lets you fire off multiple tasks to multiple agents simultaneously. Each agent works inside its own Docker or Podman container with filesystem and network isolation. When it finishes, the result appears as a git branch in your repository — ready for standard code review.

Supported Agents

Claude Code (Anthropic) — default agent
Codex (OpenAI) — via --agent codex flag

You can even run both agents on the same task simultaneously for comparison: --agent codex,claude

How It Works

Architecture

TSK builds multi-layered container images and manages the full lifecycle from task assignment to branch creation.

Container Image (4 layers): 1. Base OS + basic dev tools (git, etc.) 2. Stack Language-specific: go, rust, python, node, java, lua 3. Agent Installs Claude Code or Codex 4. Project Custom setup commands (optional) Network Isolation: Squid Proxy controls internet access per container Tasks with different proxy configs get separate proxies Identical configs share a single proxy container Data Flow: Your Repo → Copy to Container → Agent Works → Git Branch Created → Review & Merge

Isolation

Filesystem Sandboxing

Each agent gets a copy of your repo inside a container. No agent can access your host filesystem or interfere with other agents.

Network

Squid Proxy Control

Network access is routed through a Squid forward proxy. You can allow specific domains or deny all internet access entirely.

Git-Native

Branch-Based Output

Results come back as git branches. Review with your normal tools — GitHub PRs, git diff, whatever you already use.

Getting Started

Installation & Setup

Requirements

Rust (via rustup.rs) + Cargo
Docker or Podman
Git
A supported coding agent installed (Claude Code or Codex)

# Install from crates.io
cargo install tsk-ai

# Or build from source
gh repo clone dtormoen/tsk
cd tsk
cargo install --path .

# Build the container images for your project
tsk docker build

# (Optional) Preview the generated Dockerfile
tsk docker build --dry-run
    

Claude Code Skills (Optional)

TSK publishes skills to the Claude Code marketplace following the Agent Skills open standard:

/plugin marketplace add dtormoen/tsk
/plugin install tsk-help@dtormoen/tsk
/plugin install tsk-config@dtormoen/tsk
/plugin install tsk-add@dtormoen/tsk
      

Capabilities

Key Features

TSK is one of the most feature-complete agent orchestration tools available, with deep support for task templating, chaining, queuing, and multi-agent comparison.

Core

Task Templating

Markdown templates with {{PROMPT}} placeholders. Encode repetitive instructions once, reuse across tasks. Built-in feat and doc templates.

Core

Task Chaining

Sequential agent pipelines via --parent. Child tasks wait for parents, then start from the parent's final commit. Chains of any length.

Core

Parallel Server Mode

Run tsk server start --workers 4 to queue tasks from another terminal. TUI dashboard with split-pane view: task list + log viewer.

Power

Multi-Agent Comparison

--agent codex,claude runs both agents on the same task. Compare approaches side-by-side. Or use --agent claude,claude for exploration.

Power

Interactive Shell

tsk shell drops you into a sandboxed container with your repo. Work interactively with full isolation. Perfect with tmux or zellij.

Power

Custom Stacks

7 built-in language stacks plus the ability to define entirely new ones via stack_config.<name>.setup in your config.

Config

Three Config Levels

Project .tsk/tsk.toml (checked in), user ~/.config/tsk/tsk.toml, and built-in defaults. Clear priority chain.

Config

Volume Mounts

Bind mounts, named volumes, and read-only mounts. Share caches, forward host ports, inject environment variables.

Reference

Usage & Commands

Task Commands

Command	Description
tsk run	Execute a task immediately in a sandboxed container
tsk shell	Start an interactive sandbox shell
tsk add	Queue a task (supports `--parent` for chaining)
tsk list	View task status and branches
tsk cancel	Cancel running or queued tasks
tsk retry	Retry failed tasks
tsk delete	Delete completed/failed tasks
tsk clean	Clean up completed tasks

Server Commands

Command	Description
tsk server start	Start the TSK daemon (with optional `--workers N`)
tsk server stop	Stop the running daemon

Configuration Commands

Command	Description
tsk docker build	Build required container images
tsk template list	View available task templates
tsk template show	Display a template's content
tsk template edit	Edit a template in $EDITOR

In Practice

Example Workflow

A realistic scenario: you need a new API endpoint, tests for it, and documentation — all built by agents.

Start the server

tsk server start --workers 3 — launches the TUI dashboard with 3 worker slots.

Queue the API task

tsk add -t feat -n add-users-api -p "Add a REST API endpoint for users with CRUD operations"

Chain the tests

tsk add -t feat -n add-users-tests -p "Add integration tests for the users API" --parent <task-id> — waits for the API task to finish, then starts from its final commit.

Queue docs in parallel

tsk add -t doc -n users-api-docs -p "Document the new users API endpoints" — runs immediately alongside the first task since it has no parent.

Monitor in the TUI

Watch all three tasks in the split-pane dashboard. Navigate with arrow keys, view logs in real-time, cancel with c if needed.

Review the branches

tsk list shows the resulting branches. Check them out, review the diffs, and merge via your normal workflow.

The GitHub Issues integration is particularly powerful: pipe issue content directly to TSK via gh issue view <number> | tsk add -t issue-bot -n fix-my-issue

— TSK documentation

Configuration

Configuration Deep Dive

Priority Chain

CLI flags > user project overrides > project .tsk/tsk.toml > user defaults > auto-detection > built-in defaults

# ~/.config/tsk/tsk.toml (user-level)
container_engine = "docker"  # or "podman"

[server]
auto_clean_enabled = true
auto_clean_age_days = 7.0

[defaults]
agent = "claude"
stack = "default"
memory_gb = 12.0
cpu = 8

[project.my-go-service]
stack = "go"
memory_gb = 24.0
cpu = 16
host_ports = [5432, 6379]
volumes = [
  { host = "~/.cache/go-mod", container = "/go/pkg/mod" },
]
    

# .tsk/tsk.toml (project-level, checked into version control)
stack = "rust"
memory_gb = 16.0
host_ports = [5432]

[stack_config.rust]
setup = '''
RUN cargo install cargo-nextest
'''
    

Network Control via Squid

Custom proxy configuration can be defined inline or via a file path:

[defaults]
squid_conf = '''
http_port 3128
acl allowed_domains dstdomain .example.com .myapi.dev
http_access allow allowed_domains
http_access deny all
'''
      

Trade-offs

Limitations & Considerations

Rust Dependency

Requires a Rust toolchain to install. Not as simple as brew install or npm install -g for developers not already in the Rust ecosystem.

Container Overhead

Each task runs in its own container with a full copy of your repo. Resource-intensive for large repositories or many parallel workers.

Two Agents Only

Currently supports Claude Code and Codex. No support for Cursor, Aider, Gemini CLI, or other coding agents yet.

No Cloud Mode

Runs entirely locally. No remote execution, no shared dashboards, no team coordination beyond the git branches it produces.

Docker/Podman Required

Container runtime is mandatory. No lightweight mode for quick tasks that don't need full isolation.

Build Time

Initial tsk docker build can be slow as it builds multi-layered images. Subsequent runs benefit from layer caching.

Resources

Links & Resources

Official

GitHub Repository — github.com/dtormoen/tsk
Crates.io Package — cargo install tsk-ai
Agent Skills Marketplace — Claude Code skills standard

Mentioned In

awesome-claude-code — curated list of Claude Code tools
Awesome Claude AI — visual directory

Data Storage

Path	Purpose
~/.local/share/tsk/tasks.db	SQLite database for task queue
~/.local/share/tsk/tasks/	Task working directories
~/.config/tsk/tsk.toml	User configuration
~/.config/tsk/templates/	Custom task templates

TSKAgent Task Manager

What Is TSK?

The Core Idea

Supported Agents

Architecture

Filesystem Sandboxing

Squid Proxy Control

Branch-Based Output

Installation & Setup

Requirements

Claude Code Skills (Optional)

Key Features

Task Templating

Task Chaining

Parallel Server Mode

Multi-Agent Comparison

Interactive Shell

Custom Stacks

Three Config Levels

Volume Mounts

Usage & Commands

Task Commands

Server Commands

Configuration Commands

Example Workflow

Start the server

Queue the API task

Chain the tests

Queue docs in parallel

Monitor in the TUI

Review the branches

Configuration Deep Dive

Priority Chain

Network Control via Squid

Limitations & Considerations

Rust Dependency

Container Overhead

Two Agents Only

No Cloud Mode

Docker/Podman Required

Build Time

Links & Resources

Official

Mentioned In

Data Storage

TSK
Agent Task Manager