Deep Dive
From Token Maxing to Value Maxing
Charlie opens by defining token maxing as the now-outdated practice of measuring AI adoption by consumption—how many tokens burned, prompts sent, or agents running. Some companies even built internal leaderboards to track daily token usage. By mid-2024, reality hit: enterprises accidentally torched annual budgets in months and started throttling spend. CEOs admitted the token leaderboards were misguided. Value maxing flips this entirely: measure AI by what it accomplishes—work completed, time saved, quality improved—not raw consumption. The pivot hinges on a single question: if you doubled token spend tomorrow, how would you know it was worth it? This requires defining outcomes first, identifying workflows that lead to good outputs, and building evals to prove quality is actually improving. Without evals—clear definitions of what good looks like—you're flying blind.
Coding Value Maxing and GPT-5.6 Models
Charlie walks through value maxing for developers using Codex. The GPT-5.6 family includes three models: Soul (flagship for complex tasks), Terra (balanced intelligence and cost), and Luna (high-volume, cost-focused). Deep Suey benchmarks show 5.6 delivers the most performance per token spent. Charlie's rule: start with Soul on medium reasoning, not extra high. Most daily work runs fine there; only tune up for sophisticated workloads. The demo shows a visual matrix comparing models and reasoning levels side-by-side. Luna at default looks crude; Luna with more reasoning becomes respectable. Sol starts high-fidelity and gets better with more reasoning. The key insight: sometimes a less intelligent model with more reasoning tokens matches a smarter model's performance at lower total cost. Think in terms of cost per task to completion, not cost per token. Charlie also covers three tactical tips: consider trading tokens for time via fast mode, use auto approval to avoid friction while staying safe, and audit agent instructions—models have gotten so capable that six-month-old prompts are often bloated and need trimming.
API Features for Value Maxing
Charlie introduces five API features designed to save tokens and time. Programmatic tool calling gives models a JavaScript sandbox to execute code, eliminating reasoning overhead and round trips—saves 24% of input tokens by cutting one full model turn. Prompt caching specifies which parts of your prompts stay static; demo showed 90% input cost reduction on a 5,500-token prompt, though latency hit a couple seconds. Smart prompt design places dynamic info (like today's date) at the end to preserve cache hits on the static bulk. Persistent reasoning exposes the ability to save reasoning turns across messages, boosting both performance and cache efficiency. Context compaction runs automatically or manually to reduce long conversation histories—the demo showed 82% input token savings (24K down to 4K) for the same output, though compaction itself took 30 seconds. Charlie's emphasis: these aren't silver bullets; they work best on clear use cases.
Ploy's Production Wins with Caching and Tool Design
Lorenzo from Ploy dives deep into caching strategy, the most impactful but overlooked optimization. When agents loop through tool calls, context accumulates: ten tools across ten steps creates quadratic token processing. Prompt caching reduces that by 10x because embeddings from processed tokens are stored. But caching breaks if you modify the context window mid-loop—e.g., dynamically updating tool schemas. Ploy solved this by splitting tools into always-on (used 70% of sessions) and on-demand (niche tools appended only when needed), achieving 45% tool schema reduction and a 33% cost drop in evals. Ploy also sets cache breakpoints: after system prompt and tools, and after workspace memory. This let them achieve 89% cost reduction on first messages in new chats, cutting overall production token spend by 5%. Lorenzo shares three more wins: batching independent tool calls into one step saves reprocessing tokens; designing tools to do multiple actions per call saves output tokens (14% cost reduction with same pass rate); and switching to Exa's highlights feature in web search dropped output by 70%, saving ~$37K annually. The core lesson: audit traces first to find bloated tool outputs and unnecessary work, then apply caching on top.
Founder Perspective and Q&A Insights
Bryant from Ploy explains why startups must stress-test every new model against real evals reflecting actual use cases—marketing strategy, long instructions, page redesign, WordPress imports. As a second-time founder, he admits his prior experiences need unlearning; AI moves so fast that best practices from last year are stale. The Q&A covers critical nuances: Ultra mode in ChatGPT/Codex is Max reasoning plus system prompt modifications that push models toward sub-agents; it's extremely token-intensive and only makes sense for heavy-hitter tasks, not checking email. Sub-agents receive only context they need, not the full chat history. On agent depth, both speakers prefer staying shallow—two layers max—because delegation gets lossy; newer models like GPT-5.6 Soul have much better orchestration abilities than prior versions. Compaction versus new chats: Lorenzo no longer thinks about compaction for routine work and stays in one thread for weeks; new chats only make sense when your setup is heavily pre-loaded with context that's irrelevant to the new task. Overly relying on caching backfires if you haven't first audited traces and eliminated redundant tool calls and outputs—do the 80% of basic work first, then layer in caching.