Video summary

Mythos is here, it’s time to start tokenmaxxing

Main summary

Key takeaways

Technology

Tech/Product Concepts and Key Takeaways

1) “Fable / Mythos” model availability + cost limits (Claude Code)

  • Fable (aka Mythos) with safeguards is available on Claude Code Pro and Max tiers only until June 22.
    • It is removed starting June 23.
  • Why: the model is described as too expensive / compute-heavy for the subsidized subscription tiers.
  • The speaker shares “extreme economics” during the window:
    • Up to roughly $8,000/month of inference for ~$200 (or similar).
    • Personal measurement: about $4,358 inference in 10 days on Claude Code subscription.
    • Additional inference on a Mac Mini: ~$1,120+.
  • Core intent: it’s not about best value per token, but about exploiting generous short-term limits while they last.

2) “Token maxxing” strategy: understanding and exploiting rate-limit timers

Claude Code throttles with multiple constraints:

  1. A 5-hour session limit (timer behavior depends on activity).
  2. A weekly limit across all models.

Key mechanism described:

  • The timers (especially the 5-hour window) are said to begin counting after the first message.
  • A tactic to “kick” the timer without meaningful work:
    • Send a lightweight request (e.g., “say hi”), then stop—so the reset cycle progresses sooner.

Additional constraint highlighted:

  • The weekly limit also starts counting after the first message, functioning as a gating mechanism.

3) Automation via agents/cron to keep limits “counting down”

To keep the subscription “warm,” they propose automation:

  • Use a Hermes agent running in Discord plus cron to run claude-p about every ~5 hours in an empty directory.
  • Purpose: keep Claude Code accounts prompted so session timers keep ticking toward reset.
  • Platform nuance:
    • Using Claude Code inside generic “tools” is described as constrained by Anthropic expectations.
    • Workaround: run Claude Code compliantly through the agent setup.

4) Dual accounts + account swapping mid-workflow

They rotate between:

  • Two Claude Code $200 plans to avoid hitting caps.

Practical warnings/implementation details:

  • Desktop app account switching can lose history/sessions.
    • Recommendation: prefer CLI over desktop.
  • “Complex” switching procedure (Cloud Code CLI):
    1. Run /login
    2. Copy the URL
    3. Authorize in a specific browser profile
    4. CLI switches accounts

Workflow routing behavior:

  • After a tool call / workflow step, routing may shift to the newly active logged-in account’s quota.

Limitations:

  • If workflows hit rate limits, recovery can be poor.
    • Large workflows (e.g., 100+ sub-agents) may require rerunning from earlier steps when caps are reached.

Overage strategy:

  • They sometimes enable/observe overage credits to avoid stalling.
  • Then swap accounts once they see overage burn.

5) Workflow orchestration: using Mythos/Fable for large judge/audit pipelines

They use Claude Code “workflows” to orchestrate bulk review across many PRs.

Example: Lakebed PRs (35/37/39)

  • Multiple PRs implement similar file/object storage features.
  • Goal:
    • Delegate review to agents
    • Choose best approach
  • Structure:
    • An “audit” stage with many agents (e.g., ~13 separate agents)
    • Followed by a “judge” stage with additional agents

Token burn claim:

  • Very high burn rates:
    • Workflows running 8 in parallel can reach hundreds of thousands to millions of tokens quickly (e.g., approaching ~1.8M in a short time).

Cost-control guidance:

  • To control cost, explicitly instruct Fable about which model sub-agents should use.
    • Example: prefer Opus/Sonnet for sub-agents instead of accepting defaults.
  • They claim Fable may “prefer itself” for sub-agent roles unless directed.

6) Practical PR-review acceleration using agent-produced ranked summaries

More grounded example: handling many PRs/issues in real repos (T3 Chat / T3 code).

Daily agent task:

  • For each PR:
    • Estimate status
    • Rank by:
      • “ease to merge”
      • “attention worthiness”

Example outcome:

  • A simple bugfix PR (“disable external git diffs”) was surfaced by the agent and merged quickly—within ~5 minutes after sharing.

Recommendation for presenting plans:

  • Use HTML plans rather than markdown:
    • Build/host a service that serves HTML “plan descriptions”
    • Humans click a URL to see what an agent is thinking
  • They also pass HTML plans between agents for review/iteration.

7) “Skills” to audit projects + tool chaining for more efficient prompting

They recommend using community “skills” to audit code/projects, such as:

  • “Shad CN improve skill”
  • Versel skills/plugins

Notes:

  • Skills are mostly markdown, so content can be copied and run through workflows/Claude if desired.

Operational recommendation:

  • Maintain a library of reusable tasks/prompts to run when you near the end of a quota window.

8) Remote execution to avoid “sleep-loss token vampirism”

They connect “token maxxing” to sleep deprivation—staying at a laptop to run “one more run.”

Their approach:

  • Use a Mac Mini on the same network to keep agents running while you close your laptop.

Access methods mentioned:

  • SSH
  • Tailscale (instead of raw networking; they mention past WireGuard preference)
  • Terminal multiplexer organization (e.g., tmux/cmux-style)
  • Mac screen sharing
  • A T3 Code remote system:
    • Julius/T3 Code remote controls via links / tailscale / app.t3.code
    • “T3 connect” as an upcoming method, including plans for mobile access

9) Multi-agent loops for continuous maintenance

They describe maintenance patterns such as:

  • Agents creating PRs and watching comments (“babysitting loops”)
  • Another agent watching pushes and leaving reviews automatically
  • Computer-use agents generating screen recordings/screenshots as evidence of working changes

Orchestration tool comparison:

  • Codeex highlighted for spawning threads and managing parallel work trees.
  • Claude Code/Fable highlighted for orchestrating effective “judge/audit” structures.

Reviews / Guides / Tutorials Explicitly Included

  • Rate-limit hacking guide
    • How to start the reset timer using a minimal message (e.g., “say hi”) and stopping immediately.
  • Cron-based automation guide
    • Run claude-p every ~5 hours in an empty directory to keep timers advancing.
  • Dual-account workflow guide
    • Log into a second account via /login
    • Swap browser authorization profiles
    • Understand how workflows route after swapping
  • PR triage tutorial
    • Use an agent to generate ranked PR lists
    • Includes an HTML-plan workflow to reduce manual review time
  • Remote-running setup guide
    • Use SSH/Tailscale/screen share to run agents on a Mac Mini and avoid being tied to your laptop

Main Speakers / Sources

  • Primary speaker: the video’s creator (narrator/host, repeatedly referenced; mentions “Pete” and “Julius” plus references to “Ben” and “Sawyer”).
  • Other referenced people
    • Julius: T3 Code remote system, “T3 connect,” and infrastructure
    • Pete: referenced as “far ahead of the game”
    • Sawyer: framing advice about being more ambitious
    • Ben: pro tip about using OpenClaw + Hermes in Discord threads
    • Anthropic: mentioned regarding desktop app account-switching behavior
  • Sponsor
    • Render: described as enterprise/agent-ready cloud with blueprints/workflows (via Render promo)

Note: Render/Anthropic/Julius/etc. are referenced as described above; the summary focuses on the operational techniques demonstrated.

Original video