Tallow is a terminal coding agent that starts minimal and scales up. Install only the extensions, themes, and agent templates your project needs, or enable everything. It drops into existing Claude Code projects via .claude/ bridging, so nothing breaks when you switch. Ships with 53 extensions, 34 themes, and 9 bundled agent templates.

Quick start

bun add -g @dungle-scrubs/tallow
tallow install          # pick extensions, themes, agent templates
tallow                  # start coding

Requires Node.js ≥ 22 and an API key for at least one LLM provider (Anthropic, OpenAI, Google, etc.)

git clone https://github.com/dungle-scrubs/tallow.git
cd tallow
bun install
bun run build
node dist/install.js

The installer walks you through selecting extensions, themes, and agent templates, then writes config and starter templates into ~/.tallow/.

Highlights

Multi-model routing — Route tasks by intent and cost across providers. auto-cheap for boilerplate, auto-balanced for everyday work, auto-premium when accuracy matters.

Multi-agent teams — Spawn specialized agents that share a task board with dependencies, messaging, and archive/resume. Coordinate complex work across multiple models in parallel.

Context fork — Branch into an isolated subprocess with its own tools and model, then merge results back into the main session.

Workspace rewind — Every conversation turn snapshots tracked and unignored file changes. Roll back to any earlier turn when something goes wrong.

Background tasks — Kick off long-running work without blocking the session. Track task lifecycle explicitly and check back when ready.

LSP — Jump to definitions, find references, inspect types, and search workspace symbols — no editor required.

Claude Code compatible — Projects with .claude/ directories (skills, agents, commands) work without changes. Both .tallow/ and .claude/ are scanned; .tallow/ takes precedence.

User-owned config — Agents, commands, and extensions install to ~/.tallow/ where you own them. Edit, remove, or add your own.

Usage

# Interactive session
tallow

# Single-shot prompt
tallow -p "Fix the failing tests"

# Pipe in context
git diff | tallow -p "Review these changes"
cat src/main.ts | tallow -p "Find bugs in this code"

# Continue the last session
tallow --continue

# Pick a model and thinking level
tallow -m anthropic/claude-sonnet-4-20250514 --thinking high

# List saved sessions
tallow --list

# Restrict available tools
tallow --tools readonly            # read, grep, find, ls only
tallow --tools none                # chat only, no tools

Extension catalog + least-privilege startup

Use the extension catalog to inspect what each extension does:

tallow extensions          # table view (default)
tallow extensions --json   # machine-readable catalog
tallow extensions tasks    # details for one extension ID

For least-privilege sessions, start from an explicit allowlist:

tallow --extensions-only --extension tasks --extension lsp
tallow --extensions-only --extension read-tool-enhanced --extension write-tool-enhanced

Repeat --extension <selector> to add only what the task needs.

See the full CLI reference for all flags and modes (RPC, JSON, piped stdin, shell interpolation, etc.)

Configuration

Tallow stores its configuration in ~/.tallow/:

| Path | Purpose | |------|---------| | settings.json | Global settings (theme, icons, keybindings) | | .env | Environment variables loaded at startup (supports op:// refs) | | auth.json | Provider auth references (see SECURITY.md) | | models.json | Model configuration | | agents/ | Agent profiles — yours to edit | | commands/ | Slash commands — yours to edit | | extensions/ | User extensions (override bundled ones by name) | | sessions/ | Persisted conversation sessions |

Project-level overrides live in .tallow/ within your repo.

Extending Tallow

Themes

Switch themes in-session with /theme, or set a default:

{ "theme": "tokyo-night" }

Icons

Override any TUI glyph in settings.json — only the keys you set change:

{ "icons": { "success": "✔", "error": "✘" } }

See the icon reference for all keys.

Writing extensions

Extensions are TypeScript files that receive the pi ExtensionAPI:

import type { ExtensionAPI } from "tallow";

export default function myExtension(api: ExtensionAPI): void {
  api.registerCommand("greet", {
    description: "Say hello",
    handler: async (_args, ctx) => {
      ctx.ui.notify("Hello from my extension!", "info");
    },
  });
}

Place it in ~/.tallow/extensions/my-extension/index.ts. If it shares a name with a bundled extension, yours takes precedence.

SDK

Embed Tallow in your own scripts:

import { createTallowSession } from "tallow";

const { session } = await createTallowSession({
  provider: "anthropic",
  modelId: "claude-sonnet-4-20250514",
});

session.subscribe((event) => {
  if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
    process.stdout.write(event.assistantMessageEvent.delta);
  }
});

await session.prompt("What files are in this directory?");
session.dispose();

OpenTelemetry tracing

Opt-in distributed tracing for SDK consumers (e.g. marrow):

import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import { createTallowSession } from "tallow";

const provider = new NodeTracerProvider();
const { session } = await createTallowSession({
  telemetry: { tracerProvider: provider },
});
// Spans: tallow.session.create, tallow.prompt, tallow.tool.call, ...

CLI subprocesses propagate TRACEPARENT/TRACESTATE automatically when telemetry is enabled. Zero overhead when disabled.

See the SDK docs for all options.

tmux

Tallow works in tmux, but set -g mouse on captures all mouse events, which affects scrolling, text selection, and link clicking.

Recommended tmux config

Add to ~/.tmux.conf:

# Scroll down past the bottom auto-exits copy-mode (natural flow:
# scroll up to read history, scroll down to return to the prompt)
bind -T copy-mode-vi WheelDownPane \
  if-shell -F "#{==:#{scroll_position},0}" \
    "send-keys -X cancel" \
    "send-keys -X scroll-down"

# Double-click selects word without leaving copy-mode
# (default tmux behavior copies + exits, jumping back to the prompt)
bind -T copy-mode-vi DoubleClick1Pane select-pane \; send-keys -X select-word

# Triple-click selects line without leaving copy-mode
bind -T copy-mode-vi TripleClick1Pane select-pane \; send-keys -X select-line

After editing, reload with tmux source-file ~/.tmux.conf.

Mouse tips inside tmux

| Action | How | |--------|-----| | Scroll up | Trackpad/wheel — enters tmux copy-mode (shows scrollback) | | Return to prompt | Scroll back down to bottom (auto-exits with config above), or press q | | Select text in copy-mode | Double-click (word) or click + drag (with config above, stays in copy-mode) | | Select text (native) | Hold Shift + drag — bypasses tmux, terminal handles selection | | Click a link | Hold Shift + click (or Cmd + click in Ghostty) | | Copy to system clipboard | Hold Shift + drag to select, then copy normally |

Without Shift, mouse events go to tmux instead of the terminal emulator. This is standard tmux behavior, not tallow-specific.

Known limitations

• Requires Node.js 22+ (uses modern ESM features)
• Session persistence is local — no cloud sync
• web_fetch is plain HTTP by default; for bot-guarded or JS-heavy pages it can opt in to the published dendrite-scraper package when dendrite-scraper or uvx is available

Contributing

See CONTRIBUTING.md for development setup and guidelines.

This is a personal project I build in my spare time — please be patient with issue and PR response times.

License

MIT © Kevin Frilot