next level nerdingTheo on token-maxing

Theo on token-maxing

Theo holds nine Claude and Codex subscriptions, uses every limit before it refills, and keeps ten or more agents working at once without watching any of them. This page says what each piece is and how he does it.

You don't need to watch the video. He says himself this can get you banned: his warnings are part of the page. Here for the prompts? Jump to them.

Original sources

Theo · If you have a Claude sub, watch this youtu.be CLIProxyAPI github.com T3 Code github.com

Prompt like Theo on Opus 5.5

fakenerd.ai/theo-token-maxing · Video: youtu.be/D8PikZ1KhUo · Small times are minutes into the video.

The video

66 minutes, posted Oct 1, 2026. Filmed before Opus 5.5 shipped, with one note added after. The small times on this page are receipts: each opens the video at that moment.

0:01 How many threads do you have running right now?
2:43 The plan
4:00 Objections, answered early
5:22 Getting more tokens: the math
11:07 Data sharing off. What the API is still for
12:42 Getting at them: his warnings
15:14 The proxy
18:24 Which account burns first
19:35 Added later: Opus 5.5 changes the count
22:07 Tailscale and the fleet repo
26:18 How resets work
29:08 Using tokens well: both sides of merge
33:06 Agent first, thinking second
38:51 Threads as an inbox
41:17 Prompts, live
47:59 Worktrees, snooze, don't watch
50:05 Using tokens “poorly”
59:05 Using tokens while you sleep
1:04:14 Why this is fun again

Theo · If you have a Claude sub, watch this. Prompts, agent replies and the runbook are read from the video frames. Quotes and numbers are from its captions.
CLIProxyAPI, the proxy, and VibeProxy, the fork he started from.
T3 Code, Theo's open-source app for running agent threads across machines.
Tailscale, the private network between his machines.
t3.gg

Eight signals

The whole hour in eight boxes. Each one links to the part of this page that explains it.

01
A subscription is the discount
$200 on the API buys $200 of tokens. A $200 Claude subscription buys about $8,000 worth. So he stacks subscriptions instead of paying per token.
How
02
Unused limit is money lost
Whatever is left on a limit when it refills is gone. He treats it as a gift that expires every week, and makes sure it's spent.
How
03
One home box, everything through it
One computer at home holds every account login. All his other machines talk to it over a private network.
How
04
Most tokens go to checking, not coding
His guess: 10–15% of his tokens write code. The other 85–90% test and review it, so the work is ready by the time he looks.
How
05
Bring the agent in when you start thinking
Hand over the problem the moment you hear about it, not your solution a day later. If the agent fails, you've learned the problem is hard.
How
06
Threads are tasks. The sidebar is an inbox.
A finished thread leaves the list. He only opens threads that say done or need an answer, and aims to end the day with the list empty.
How
07
Never watch an agent work
“Agents can be multi-threaded. Humans are single-threaded.” Send the prompt, then go write the next one.
How
08
Move the work off your laptop
An old PC running Linux, at home, always on. Start threads on it, close the laptop, check from your phone.
How

Words on this page

Twelve terms, in plain words. Skip this if you already run coding agents.

Token: The unit AI models count and charge in. Roughly a piece of a word. Everything you send and everything the model writes back costs tokens.
API vs subscription: API: you pay for each token. Subscription: you pay a flat $100 or $200 a month and get usage limits instead of a bill.
Limit: How much a subscription lets you use. A Claude sub has a 5-hour limit and a 7-day limit, plus a separate 7-day limit for Fable. Codex has a weekly limit.
Reset: The moment a limit refills to 100%. It happens on a schedule, and sometimes the company hands out an extra one.
Token-maxing: Theo's word for using up every limit before it resets, and getting more limits by holding more than one subscription.
Claude Code, Codex: The coding agents from Anthropic and OpenAI. They run on your computer, read and edit your code, and run commands.
Thread: One conversation with an agent, working on one task.
Proxy: A small program that sits between the agent and the AI company. It holds your logins and passes each request along using one of them.
Tailscale: A private network between your own devices, wherever they are. Only devices signed in to your Tailscale account can reach each other.
PR: Pull request. A proposed code change on GitHub, waiting to be checked and merged.
Worktree: A second working copy of the same repo on its own branch. Each agent gets one, so two agents never edit the same files.
Babysit: His skill (babysit-pr on screen) that keeps watching a PR: reads what the review bots say, fixes it, pushes, waits, checks again.

How one task moves through his setup

From Theo, through his thread app and the agents, to the proxy and the subscriptions, and back to him. Darker boxes are where he has to do something: three of the six. Click any box for what it is, how he uses it and the warning that goes with it, or press Start and follow one real task.

One task, start to finish · darker boxes need him

Underneath every task

Follow one task through the setup

Eight beats, using a change he makes on camera: replies in his app that should stream in sooner. Count how many beats need him.

One task · step 1 of 6 · him

Watch at 33:30

Theo

voice dictation
a screenshot
How he works now

What it is

Where every task starts. He brings the agent in the moment he hears about a problem, not once he has worked out a fix.

How he uses it

He dictates the problem out loud or pastes a screenshot. He gives the problem, not his solution, and asks for the whole trip in one message: build it, open the PR, give me a link to try, watch the PR.

In his words

“How can I use more tokens to care less about this?” 30:03

His warning

Don't stack subs before you earn. “If you're not employed as a dev, don't stack subs until you're making money.”

All his warnings

01 · One task · him · 33:30
Theo
What: Where every task starts. He brings the agent in the moment he hears about a problem, not once he has worked out a fix.
How: He dictates the problem out loud or pastes a screenshot. He gives the problem, not his solution, and asks for the whole trip in one message: build it, open the PR, give me a link to try, watch the PR.
His warning: Don't stack subs before you earn. “If you're not employed as a dev, don't stack subs until you're making money.”
02 · One task · him · a few seconds · 38:51
T3 Code inbox
What: His own open-source app for agent threads. Threads from his laptops, home boxes and cloud servers sit in one sidebar, and in the phone app.
How: He opens a new thread, picks a machine that stays on (not the laptop), and sends with Cmd + Enter so he stays on the empty screen and writes the next prompt. Finished threads get settled so they leave the list.
Watch out: He makes this app, so weigh the pitch. The inbox loop works in any tool that lets you archive finished threads.
03 · One task · agents · 57:13
Ten threads at once
What: The agents doing the work. At any moment ten or more are running and five or more are finished and waiting for him. Some take 30 minutes, some 18 hours.
How: Every new thread gets a fresh worktree so agents never edit the same files. They run with full access. He doesn't open a running thread: it's not his problem until it says done or needs input.
Watch out: Unwatched work has to be checked by something. A PR that's wrong 5% of the time needs your full attention, so most of his tokens go to testing and review. His bar for undo: under 15 seconds, or you shouldn't be vibe coding yet.
04 · One task · on the home hub · 15:14
The proxy
What: A small program on one computer at home. Every account is signed in to it once. It keeps those logins alive and gives the agents one address that behaves like an API.
How: Each machine's Claude Code and Codex point at the hub instead of straight at Anthropic or OpenAI. He had an agent change the proxy to drain the account that resets soonest, and it keeps each thread on one account so the cached conversation isn't re-read.
His warning: Claude models only inside Claude Code. Using a Claude sub in any other tool through the proxy: “You will be banned. You will be upset.”
05 · One task · Anthropic · OpenAI · 6:16
5 Claude · 4 Codex subs
What: Where the tokens come from. By his numbers a $200 Claude sub buys about $8,000 of usage at API prices, and a $200 Codex sub about $12,000.
How: The proxy spends them one at a time, starting with the one that refills soonest. The dashboard shows three bars per account and when each refills. His note added after filming: on Opus 5.5 you might not need 5 to 10 Claude subs anymore.
His warning: It can get you banned: two temporary bans across 30+ accounts among his friends, both reinstated. Never serve your users from a sub, don't use a Google account, and turn off data sharing first.
06 · One task · him · 44:38
Done or input
What: The only point where the task needs him again. In the morning, or between other things, he goes through finished threads one at a time.
How: For each one he decides: merge, send a follow-up, or drop it. Then he settles it so it leaves the list. Once he trusts the checks, the agent merges on his conditions and the thread closes itself. About half are archived without him reading the last message.
Watch out: Letting the agent merge only works once the checks are good. Tell it exactly what must be true before it presses merge.
Where it runs · home · always on · 59:05
The always-on box
What: A spare computer at home that runs the agents and holds the proxy. His is a desktop called bb-1. Threads also run on cloud servers, which reach the accounts through it.
How: Any old laptop or desktop with at least 8 GB of memory and four cores, not a Mac. He starts threads on it, closes the laptop, and checks from his phone. It runs code, not the AI model, so it needs very little power.
His warning: Don't sign in on a rented server or over a VPN: a rented server's address is the kind that gets a sub banned. Also, heavy builds swamp it. Five Rust compiles at once will.
The wires · every machine · 22:21
Tailscale
What: The private network. His laptops, servers and phone all sign in to one Tailscale account, so they can reach the hub and nobody else can.
How: Installed on the hub and on every machine. The proxy runs with no password because only his own devices can see it. Agents also use it to send him a private link to try a change.
His warning: One place, one home address. Requests arriving from many computers at once is what looks wrong, so every machine goes through the one hub at home.
Timing · on a schedule · 26:18
Resets
What: The moment a limit refills to 100%. Codex resets restart the weekly clock and can be banked. Claude resets refill the percent but the dates don't move.
How: He spends what's left before a reset lands, starting with the account that refills soonest. When a limit is about to refill with plenty left, he hands an agent a big loose job to use it.
Watch out: On the top plan, using all of a 5-hour limit uses 40% of the 7-day Fable limit. If you keep hitting the 5-hour wall across several accounts, he says “slow down a little.”

Theo never draws his setup as one picture. The boxes come from what he shows and says across the video, and the layout is ours. Boxes marked “His warning” quote a line from his warnings; “Watch out” is a caution he gives elsewhere in the video.

The math

What your money buys, by Theo's numbers. “Worth” means what the same usage would cost at API prices. These are his figures, said on camera. We haven't checked them.

Claude API or Codex API
$200 $200
What you pay is what you get.
5:29
Claude $200 sub
$200 / month ≈ $8,000
Only about $4,000 of it can be Fable: Fable has its own 50% limit.
6:16
Claude $100 sub
$100 / month ≈ $4,000
Half the total, but a quarter of the 5-hour limit, so it's hard to use it all. He says skip it and save for the $200 plan.
6:36
Codex $200 sub
$200 / month ≈ $12,000
No split between Astra and cheaper models. Closer to $24,000 if you use every extra reset. New $200 sign-ups were paused when he filmed.
7:00
Cursor, OpenCode, T3 Chat subs
— 30–50% off at best
These companies buy tokens at a much smaller discount than you get. Only Claude and Codex subs are worth stacking.
15:53

Why the gap exists, by his account: API prices carry a rumored 95% margin (his source is “napkin math” from people he knows), so the companies can afford to give subscribers far more. 8:28
Fable on the API is $10 in, $50 out per million tokens. Mythos Preview was quoted to companies at $25 in, $125 out. He calls that “almost 70% cheaper” (the numbers work out to 60%). 7:43
Codex handed out 14 extra resets in 30 days, about one every 2–3 days. That's what doubles the Codex figure. 10:06
His own ratio: about $1,000 in for every $50,000 of tokens out, “worst case”. “Every dollar you spend on API is 80 to 90 cents you've thrown away.” 4:47
What the API is still for: anything your users trigger. Subs are for your own prompts and your own agents. 11:55

Added after filming

Opus 5.5 came out between filming and posting. His note: “you might not need 5 to 10 Claude subs anymore”, because one sub on Opus 5.5 is hard to run dry. You might not need the proxy either. The rest of the advice still holds. 19:35 More on that model: Prompt like Theo on Opus 5.5.

His warnings

Theo opens by calling this “the video that Anthropic does not want you to watch.” Holding several accounts and passing them through a proxy is not what the plans are sold for. These are the lines he draws himself.

It can get you banned
“This might get you banned. This might be against terms of service… Do not hold me accountable.” Across 30+ Claude accounts among his friends, he counts two temporary bans, both reinstated.
14:43
Never serve users from a sub
Your own prompts and your own agents are fine. Public traffic running on a sub is against the rules: use the API. “You deserve your ban.”
11:55
Claude models only inside Claude Code
Don't use a Claude sub in any other tool through the proxy. “You will be banned. You will be upset.”
25:51
Don't sign in on a rented server or over a VPN
Anthropic watches sign-ins and requests from server addresses closely, because people resell subs from them.
13:30
One place, one home address
Requests arriving from many computers at once is what looks wrong. He routes it all through one machine at home.
14:30
Not with a Google account
Lose a Google account and you lose much more than a model.
15:00
Turn off data sharing first
Codex: Settings → Data controls → “Improve the model for everyone”, off. Claude Code has a similar setting. His claim: the terms are then about the same as a team account.
11:07
Don't stack subs before you earn
“If you're not employed as a dev, don't stack subs until you're making money.”
35:56

The setup

Five Claude accounts and four Codex accounts, all behind one computer at home. Five pieces. For each: what it is, and how he does it. He gives no install commands for the proxy, so neither do we; its own page has them.

Anywhere

His machines

Laptops, Linux boxes, cloud servers. Claude Code and Codex on each, pointed at the hub.

TailscaleTailscale

At home

The hub

One computer running the proxy. It keeps every login alive and picks which account takes each request.

The accounts

5 Claude · 4 Codex

Each on the $200 plan. The one that refills soonest gets used first.

01One always-on computer at home
22:07
What it is
The hub. His is called bb-1, a desktop in another room. Because it's on his home internet, every request leaves from a normal home address.
How
Any spare computer works. It only passes requests along, so it needs very little power.
02CLIProxyAPI on that computer
15:14
What it is
The proxy. You sign each Claude and Codex account in to it once. It keeps those logins alive (Claude Code's breaks every 2–3 days), and gives you one address that behaves like an API.
How
Install it on the hub and sign in each account through its web page. It has a dashboard that shows every account's limits. He started from a fork called VibeProxy.
03Tailscale on every machine
22:21
What it is
The private network. His laptop, servers and phone all sign in to the same Tailscale account, so they can reach the hub and nobody else can.
How
Install Tailscale on the hub and on each machine, signed in to one account. He runs the proxy with no password, because only his own devices can see it.
04Point Claude Code and Codex at the hub
24:56
What it is
Each machine's agent sends requests to the hub instead of straight to Anthropic or OpenAI. The agent doesn't know the difference.
How
He gives no steps: “I'm going to tell you to tell your agent to do it. It will swap two variables in the configs and you're done.” Want your normal login too? Keep a second install with its own home folder and its own command.
05A “fleet” repo that describes it all
23:22
What it is
One private repo that lists every machine and how each should be set up. It lives on one machine only: the one he manages the others from.
How
When he gets a new machine: turn on SSH, open the fleet repo, and tell the agent to set the machine up from the runbook below.

His runbook for a new machine

The fleet repo has a file called HOW_TO_SET_UP_A_BOX.md. It doesn't list commands. It describes what a finished machine looks like, and the agent works out the steps. This part was on screen:

# How to Set Up a Theo Box

## Target State

A finished box should have:

- Stable hostname and SSH target.
- Tailscale installed, reachable, and preferably using MagicDNS.
- Public-key SSH from the primary Mac with `BatchMode` working.
- A `main` tmux session with the machine's identity color.
- Git, GitHub CLI, `rg`, `fd`, `jq`, `tmux`, `btop`, Node/Bun, Python, and build tools.
- Codex and Claude Code installed.
- `~/.claude/CLAUDE.md` and the `skills/universal/` skills synced from this repo into both harnesses.
- `ccusage` installed at the path recorded in `COMPUTERS.md`.
- The machine added to `COMPUTERS.md`, `bin/ccusage-fleet`, and the dashboard.

## Identity

Choose the identity before installing tools.
(a table follows: one row per box, with its user, shell and color)

What's in the fleet repo

fleet/
  snapshots/
  tests/
  theo-boxes/
  vibeproxy/
  .env
  AGENTS.md
  CLAUDE.md
  complete-setup.sh
  COMPUTERS.md
  HOW_TO_SET_UP_A_BOX.md
  README.md
  THREADS.md
  TODO.md
  VIBEPROXY.md

Read off the screen; a few files left out. COMPUTERS.md is the list of machines. It gets updated each time he adds one. 23:39

In plain words, a finished box: has a fixed name, is on Tailscale, lets his main Mac log in without a password, has the usual command-line tools, has Codex and Claude Code installed with his shared CLAUDE.md and skills copied in, reports its usage, and is written into the machine list.

Three changes he made to the proxy

He didn't write these by hand. He had an agent make them. His version started from a fork called VibeProxy and has changed a lot since.

A
Use the soonest reset first
Out of the box, the proxy spreads requests evenly across accounts. That wastes limit on accounts about to refill. He had an agent change it: always drain the account whose reset comes next.
18:24
B
Turn on WebSockets for Codex
A faster way for the agent and the server to pass messages. Off by default for Codex subs through the proxy. He calls the speed-up huge.
20:51
C
Keep each thread on one account
The AI company remembers a long conversation for five minutes so it doesn't re-read it each time (a cache). That memory belongs to one account. If the proxy hops accounts mid-thread, the whole conversation gets re-read and you pay for it. The proxy handles this by default; he checks by asking the agent (prompt below).
20:59

What the dashboard shows: one row per account with three bars (7-day Fable, 5-hour limit, 7-day limit) and when each refills. One number he's sure of: on the top plan, using all of a 5-hour limit uses 40% of the 7-day Fable limit. If you keep hitting the 5-hour wall across several accounts, “slow down a little.” 19:15

Resets, and what to do about them

A reset refills your limit. The two companies do it in opposite ways, and that changes when you should spend.

Codex

26:18

A reset refills the weekly limit and restarts the clock. Your next scheduled reset moves to 7 days from now.

Two kinds. Immediate ones just happen, usually when companies are offline, like Friday nights. Banked ones are saved to your account and you click them when you want. He had 10 saved up.

What to do

Use what's left before a promised reset lands: the refill wipes it either way. Banked ones wait until you click them.

Claude

27:48

One kind. The percent goes back to 100, but the dates don't move.

So if your scheduled refill is tomorrow and a surprise reset arrives today, you have one day to use a full limit.

What to do

“Turn on the furnace”: spend it right away, on the account that refills soonest.

The mindset he wants you in: “You've been generously gifted $4,000, but every week where you don't spend a thousand of it, it disappears forever.” On the API you try to use as few tokens as you can. On a sub, anything left at refill time is money you lost. 28:35

Why Friday nights: free resets cost the companies least when the customers paying API prices are offline. He expects subs to get pushed toward off-hours, and says he'd shift his sleep to keep the deal. 27:34

How he works now

He says he does 100+ PRs a day, part-time. The idea: let the agent run from “I just heard about this problem” all the way to the merge button, and only step in where it can't.

Ask one question about every task
30:03
What it is
“How can I use more tokens to care less about this?” How early can the agent start, and how far can it go before you need to look?
How
Before you start anything yourself, try handing it over first.
Spend most tokens on checking
30:46
What it is
A PR that's wrong 5% of the time needs your full attention. One that's wrong 1% of the time doesn't. Checking is what buys that.
How
Have the agent test its own work, open the PR, wait for the AI review bots, fix what they find, and wait for the next review. He describes one task as 30 minutes of building, then two rounds of 15 minutes waiting and 10 minutes fixing.
Make undo fast
31:31
What it is
The other side of the merge button. If a bad change is cheap to undo, you can merge with less worry.
How
Have something that catches problems before users see them, or a one-step way to roll back. His bar: “If undoing a bad change takes more than 15 seconds, you probably shouldn't be vibe coding at all yet.”
Start with the agent, not after
33:30
What it is
He used to bring the agent in once he knew what he wanted. Now he brings it in when he first hears about the problem.
How
Ask: “Is there a stupid simple solution I'm not thinking of here?” He once thought about a problem for three weeks. The agent had a simple answer.
Give the problem, not your solution
34:34
What it is
If you hand over your fix, the agent builds your fix, even when it's wrong. If you hand over the problem, it may find a better one.
How
For a bug report: paste the screenshot and say “fix it”. If that fails a few times, the problem is hard. That's the one worth your thinking.
Don't outsource thinking, scale it
37:33
What it is
A viewer's line; Theo: “Yes, exactly.” He isn't saying think less. He's saying find out whether something needs your thinking before you spend days on it.
How
Spend your own time on what the agent couldn't solve, and on reading what it did solve.
Put the whole trip in one prompt
47:11
What it is
Every step you leave out is one more time you have to come back, read, and reply.
How
In the same message: build it, open the PR, start a link you can test, watch the PR. Aim for this: the next time you open the thread, the only thing left is to press merge.
Let it merge on your conditions
47:28
What it is
Once you trust the checks, the agent can press merge itself.
How
Tell it what must be true before merging. In his app a merged PR closes the thread. About half his threads are archived without him reading the last message.
New thread, new worktree
47:59
What it is
Each thread gets its own copy of the code, so agents don't overwrite each other.
How
Make it the default. Git sometimes complains when two worktrees want the same branch. He doesn't step in: the models now find a way around it.
Don't watch it work
49:47
What it is
“There are few worse uses of your time than watching an agent as it works.”
How
If it worked, merge. If it failed, ask the agent why, or read its reasoning. Then send the next prompt.

Ten threads at once

“Threads are not histories that you actively go back to all the time. Threads are tasks.” Treat the list like an email inbox you're trying to empty.

The loop

01
Notice a problem. Open a new thread and say it out loud (he dictates) or paste a screenshot.
02
Pick a machine that stays on. Not the laptop: it gets closed.
03
Send it in the background and stay where you are. Write the next prompt.
04
Leave running threads alone. Open one only when it says Done or asks for input.
05
For each finished thread, decide: merge it, send a follow-up, or drop it.
06
Settle what's finished so it leaves the list. Snooze what can wait.
07
Before bed, start a batch. In the morning, go through them one at a time.

What a normal day looks like

At any moment: ten or more threads running, five or more finished and waiting for him. He shows a real screenshot with over a dozen running at once, started in the 20 minutes before bed. Some took 30 minutes. Some took 18 hours. 57:13

The rule that makes it work: “I do not check my threads until they say done or input.” A running thread is not his problem. 44:38

It doesn't remove the cost of switching between tasks. It makes it easy to see which task needs you. “We are the bottleneck. So how can you get the agents to unblock themselves as much as possible?” 45:23

The tools he uses for it

All of these are features of T3 Code, his own free, open-source app, so weigh the pitch. The loop above works in any tool that lets you archive finished threads.