If you have a Claude sub, watch this

Overview: “Agent maxing” for more discounted tokens and less manual work

This video is a highly technical guide for “agent maxing.” It focuses on:

• Getting more discounted model tokens (primarily via personal subscriptions)
• Routing and managing those tokens reliably at scale
• Using agents so you need less hands-on attention while coding and reviewing PRs

The speaker repeatedly frames parts of the strategy as possibly against Terms of Service, warning that misuse could lead to bans.

---

Core premise: “agent threads” + token capacity

• The video begins by asking how many “agent threads” the viewer already runs concurrently (i.e., parallelism).
• It argues that even if you already run many threads, you’ll benefit from additional “edges and solutions.”
• If you’re running fewer than five, it suggests you’re not taking advantage of available opportunities.

---

Sponsorship: Parallel search as an agent dependency (fast search + APIs)

The sponsor (Parallel) is positioned against OpenAI’s search latency.

Speed claims

• Parallel: ~1 second search results time
• OpenAI: >6 seconds (as claimed in the video)

Mentioned features

• A monitor that notifies agents when pages change
• A response API for synthesized results
• “extract endpoints” that take a URL and return structured data
• MCP support to expose Parallel to existing agent toolchains

Pricing / limits

• 5,000 requests/month free
• $80 credit if you sign up that day

---

Controversial token acquisition: subscription token subsidization

The main technical “how-to” centers on using Anthropic/Claude and OpenAI-type subscriptions (especially Claude and Codeex/Codex-related subs) to obtain large token quotas far cheaper than API pricing.

The video suggests the pricing model is intentionally structured to undercut competitors, while noting there may be ToS risk.

Approximate numbers mentioned (from subtitles)

• $200 Claude subscription
  • ~8,000 tokens/month
  • ~4,000 labeled “Fable” due to a separate 50% limit
• $100 tier
  • described as worse due to “hourly” constraint behavior, making efficient quota “burning” harder
• $200 Codeex subscription
  • ~12,000 inference tokens
  • “no distinction” between usage across model types (as claimed)

“Reset” behavior

• Codeex resets
  • described as weekly-ish, with examples implying multiple resets/month
  • example given: 14 resets in 30 days (≈ resets every 2–3 days)
• Claude resets
  • described as “limit resets” where percentages reset to 100% while date/time behavior stays the same

“Turn off data sharing / training” setting

A compliance-related detail for the Codeex personal subscription:

• The speaker instructs turning off:
  • “improve the model for everyone / data controls”
• The claim is that with this setting disabled, personal terms become effectively identical to team terms.
• They also argue that paying API prices purely to avoid training is not meaningful if personal data controls are disabled.

---

Warning: don’t use subsidized accounts for public users

Even while explaining abuse potential, the speaker emphasizes:

• Do not use accounts to serve public user traffic
• Building public-facing inference services using these subsidized accounts could result in bans and is described as against rules.

---

Accessing lots of tokens reliably: routing + proxy + account management

The video warns that simply running many local sessions breaks down at “insanity”-scale usage. The solution is access/routing management.

VPS / IP risk guidance

The speaker recommends:

• Avoid signing in on Claude/Codeex/Cloud Code from a VPS if it serves others’ traffic
• Avoid VPN/cloud egress that looks like server infrastructure
• Prefer a consistent “residential IP”
• Keep traffic coming from one place when possible

---

CLI proxy / API proxy for subscriptions

A routing layer is introduced via a CLI proxy (also mentioned as a lineage/fork name: “Vibe proxy”).

What the proxy is used for

• Sign into Claude/Codeex accounts through the proxy
• Maintain account availability / keep an “off” state current so calls continue
• Provide an API endpoint that tools (Cloud Code / Codeex / Codex-style workflows) can target instead of direct platform endpoints

Networking and setup

• Recommended to run the proxy at home
• Use Tailscale so other machines can reach the proxy securely
• Claim: the proxy endpoint is only reachable inside the Tailscale network, not the public internet

---

Proxy performance/correctness pro tips

1) Account prioritization

• Default behavior routes accounts evenly
• The speaker wants routing toward accounts that expire/renew soonest to “burn” soon-to-die quota
• Discusses how “burning” interacts with hourly/weekly caps

2) Websocket enabled for Codeex

• Claim: Codeex subscriptions may not default to websocket routing via the proxy
• Enabling websocket allegedly reduces “time passing messages back and forth,” improving performance

3) Session affinity / account affinity

• Thread continuity matters because caching is account-specific
• If prompts alternate accounts within a thread, caches must be recreated, increasing cache read/write load
• The proxy should keep subsequent prompts in the same thread pinned to the same account as much as possible

---

Fleet management: repository-driven provisioning

To keep multi-machine setups maintainable:

• The speaker uses a “fleet management repo” on GitHub describing steps like:
  • install tools
  • configure Cloud Code/Codex to use the proxy
  • install dependencies
• Workflow:
  • Add new machine via SSH
  • Use T3 Code/agent to set it up using repo-defined steps
  • Approve a Tailcale device connection via a web approval prompt

---

Using tokens: agent workflow strategy to reduce human attention

A major theme is using agent time effectively rather than watching it work.

De-risking PRs: before and after merge

• Before merge (“derisk merge”)
  • Run agents earlier so PRs are already handled for common issues by the time you check them
  • Claim: much token spending goes into verification, not raw coding
• After merge (“derisk after”)
  • Make it easy to revert broken changes
  • If undo takes longer than ~15 seconds, you likely need stronger systems before heavy “vibe coding”

“Know the problem, not the solution”

• Provide agents the problem (plus context/screenshots), not a proposed patch
• If the agent can’t solve it autonomously, the problem may be too hard without more thinking or engineering/system changes

Let agents run unattended multi-step pipelines

Agents can:

• generate PRs
• wait for reviews
• fix and re-request review
• iterate until ready

Tactic: start long-running threads, do other tasks, then check when “done” or when input is required.

---

T3 Code workflow mechanics: thread management to reduce context switching

The video treats T3 Code like “inbox zero.”

Thread model: tasks/to-dos, not histories

• Emphasis:
  • When finished, use Settle (thread disappears) to clear the sidebar
  • Use Snooze for deferral

Attention model

• Don’t constantly switch between threads
• Instead, let agents run and return when needed

Multi-machine execution + load balancing

• Choose which machine executes a thread via computer selection
• Enable auto load balancing to distribute threads
• User role becomes triage when done, not constant babysitting

Thread conflict avoidance via isolated work trees

• Claim: T3 Code defaults to starting a thread in a new work tree
• Goal: prevent parallel agents from colliding on git branches

Auto-settling

• T3 Code auto-settles threads not touched for a few days (configurable)
• Speaker mentions increasing from 3 to 7 in their case

---

“Using tokens poorly”: offload chores to agents

The speaker argues for waste-free “agent outsourcing,” including tasks like:

• triaging poll requests
• summarizing/collecting updated project info
• searching for lost info (e.g., keys/email)
• collecting medical records from browsers/dashboards

The framing: run agents while you do other work, rather than doing everything manually.

---

Running tokens while sleeping: remote compute + low-hardware requirements

Final major recommendation: keep agents running without using your laptop.

Suggested home setup

• A small Linux box at home (or old computer)
• Ubuntu, Tailscale, and CLI proxy

This purportedly keeps inference traffic consistently routed through a residential IP.

Hardware caveats

• Strong discouragement of VPS use due to IP ban reasons
• The claim: you don’t need heavy hardware since it’s “doing code, not inference”
• Linux preferred:
  • Mac OS described as a bottleneck due to filesystem/security overhead

CI/build note

• For CI/build workloads, you may need to queue or relocate compilation
• References to tooling/partners like Blacksmith/Depot-style tooling

---

Main speakers / sources

Main speaker

• Theo (the creator; repeatedly referenced as “Theo from the future” and “drunk future Theo”)

Mentioned third parties / systems

• Anthropic (Claude / Fable / Opus discussions)
• OpenAI (search latency comparison and pricing approach)
• Parallel (sponsor: search + APIs + MCP)
• T3 Code / T3 Connect and the T3 team (named: “Maria”)
• Tailscale (networking layer)
• CLI Proxy (and a fork lineage: “Vibe proxy”)
• Blacksmith / Depot (CI/infrastructure-related references)
• Julius / Orchestrator V2 (team member referenced)