A modular coding agent for your terminal. Built on pi.

Docs · GitHub

CI · npm · Docs · MIT

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 52 extensions, 34 themes, and 9 bundled agent templates.

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

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.

# 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

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.)

Tallow stores its configuration in ~/.tallow/:

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

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

{ "theme": "tokyo-night" }

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

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

See the icon reference for all keys.

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.

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();

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.

• 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

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.

MIT © Kevin Frilot