v0.5 · works with Pro · Max 5× · Max 20×

Same plan.
More turns.

Built for solo devs on Claude Pro and Max. Lathe gives Claude Code a smaller, smarter toolset — search edit edit_glob read. ~46% fewer tool calls per task, so your subscription stretches further before you hit your 5-hour cap. Same model. Same workflow. Same plan. 

$curl -LsSf https://beaglelathe.dev/install.sh | sh
macOS & Linux Free: 200 calls / month Other install methods →
BeagleLathe mascot
TASKS PER 5h WINDOW · PRO PLAN
stock ~40 tasks / window
lathe ~49 tasks / window
+24% more code per 5h window
BENCHMARKS / 9 FIXTURES · n=5 · CLAUDE CODE

What you get back.

Same task list, same model, same Claude subscription. Stock Claude Code on the left bar; Lathe on the right.

−46% #01
fewer tool calls
7.4 → 4.0 calls per task. Every round-trip chews your usage cap.
CALLS PER TASK
stock
lathe
−42% #02
lighter cache footprint
~20.4k → ~11.8k cache-creation tokens — what rate limits actually meter.
TOKENS PER TASK
stock
lathe
−29% #03
faster wall time
25.1s → 17.9s end-to-end. Your loop feels snappier.
SECONDS PER TASK
stock
lathe
Run with and without Lathe on Claude Code. Same model, same plan, same task list. Methodology & raw numbers →
02 / HOW IT WORKS

A simple “find and edit three files” task isn’t three tool calls.

It’s twelve. Find, read, edit, verify-read, repeated per file. Lathe collapses the whole sequence into one fused call.

stock
$ find . -name "*.ts"
$ grep -rl "useAuth"
$ read login.ts
$ read session.ts
$ read auth.ts
$ edit login.ts /* attempt 1 */
$ read login.ts /* verify */
$ edit session.ts
$ read session.ts
$ edit auth.ts
$ read auth.ts
$ read auth.ts /* still wrong */
12 calls · 14.2s
lathe
$ search "useAuth" in src/
→ 3 files, ranked snippets
$ edit edits=[login, session, auth]
→ 3 files patched, validated
2 calls · 10.8s
▰▰▰▰▰▰▰▰▱▱ 83% fewer · typical: −46%
12 calls → 2 calls −83%
03 / WHY LATHE

Two things change.
Nothing else does.

01

Less context per turn

Every tool call your agent makes feeds its output back as input tokens on the next turn. Lathe’s collapsed tools return more useful structure per call, so the running context stays lighter — and each turn fits more of your actual code.

▸ ~42% lighter cache-creation footprint
02

More turns per window

Find-and-edit across three files goes from a dozen round-trips to two, because search fuses glob, grep, and snippet-read into one call and edit applies an array of cross-file edits atomically. Across the nine bench fixtures the average task drops from 7.4 calls to 4.0, so your Claude Pro or Max session lasts way longer before the 5-hour cap.

▸ ~46% fewer tool calls
04 / INSTALL

Two steps. Two minutes.

01
One line. Picks uv, pipx, or pip automatically.
Installs the package, registers the plugin, signs you in.
$curl -LsSf https://beaglelathe.dev/install.sh | sh
02
Open Claude Code and run /mcp
You should see lathe listed as one active tool (it exposes four actions: search edit edit_glob read).
claude code
> /mcp
lathe ✓ active
actions: search, edit, edit_glob, read

Requires Python 3.10+ and the Claude Code CLI. Prefer to install manually? See the docs for the uv / pipx / pip one-liners and the marketplace alternative.

05 / PRICING

Free to start.
$9/mo to keep going.

Pairs with your existing Claude Pro or Max plan — Lathe doesn’t replace it, it stretches it. No API key, no per-token billing. Cancel from /lathe-status.

TIER 01 Free
$0 forever
  • ✓200 tool calls per month
  • ✓All actions: search, edit, edit_glob, read
  • ✓Works with your Claude Pro or Max plan
  • ✓Resets on the 1st
Get started
TIER 02 Pro
$9 / month
  • ✓Unlimited tool calls
  • ✓All actions, no caps
  • ✓Stretches Pro or Max plans further
  • ✓Cancel anytime
Get Pro →
06 / FAQ

Answers.

Don’t see yours? Open an issue on GitHub or email hello@beaglelathe.dev.

Q01

Do I need an API key or pay per token?

No. BeagleLathe runs on top of your existing Claude Code login — the same Pro or Max plan you already pay for monthly. There’s no separate API key to manage, no per-token billing, no usage surprises. The product is built for solo devs on a flat subscription.
Q02

Does BeagleLathe see my code?

No. BeagleLathe runs locally on your machine; source files, search queries, and edit content never leave it. Every Anthropic request still goes directly from your machine through the same route stock Claude Code uses.
Q03

Will this break my existing Claude Code workflow?

No. BeagleLathe is just an MCP server. It adds one tool (with four actions) and changes nothing else. Same model, same plan, same IDE integrations. The agent picks it up automatically.
Q04

How does it stretch my 5-hour Max window?

Every tool call your agent makes counts against your usage. Stock Claude Code chains 3–5 calls per task — find, read, edit, verify, repeat. Lathe collapses that into one fused call, so the bench average drops from 7.4 calls to 4.0 (−46%) and cache-creation tokens — what the rate limit actually meters against — drop ~42%. The throughput math: at −19% cost per task, you fit 1 / (1 − 0.19) ≈ 1.235× more tasks in the same window. On Pro that’s ~9 extra tasks (≈40 → 49). On Max 5×, ~47. On Max 20×, ~188.
Q05

Does it work offline?

Yes, with a 48-hour cap. Tool calls succeed locally even when the backend is unreachable, so a flaky connection never blocks your work. If more than two days pass with no successful server contact, the next tool call asks you to run beaglelathe login or check your network.
Q06

How are the numbers measured?

Locally. Every tool call is recorded to ~/.beaglelathe/state.db with its actual output size in bytes. Each action (search, edit, edit_glob, read) has a per-action multiplier calibrated against the stock Claude Code sequences from the bench fixtures, plus a 1.5× cache-amplification factor that accounts for re-reads across cached turns. Run /lathe-savings to see calls saved, tokens saved (priced at both Sonnet and Opus output rates), and estimated wall time reclaimed. Nothing is sent to a server.
Q07

What languages does the AST reader support?

Twelve at last count: Python, TypeScript, TSX, JavaScript, Rust, Go, Java, C#, Ruby, PHP, C, and C++ all get full AST-aware truncation — read keeps signatures, types, imports, and module-level declarations while stubbing function bodies. Other languages still read fine; they fall back to mode=full (verbatim) or mode=skeleton (cheap fallback), you just don’t get the stub-bodies/keep-signatures optimization. The list grows over time — see the repo.
ONE LAST THING

Outlast your
rate limit.

Built for solo devs on Claude Pro or Max. Two-minute install, 200 free tool calls a month, drops in alongside your existing Claude Code setup. Same subscription, way more code per window. 

$curl -LsSf beaglelathe.dev/install.sh | sh
Get started → Read the docs