Burning $200K Testing GPT-5.6: Where Are the Real Limits of Agent Capability?

A tech creator gained early access to GPT-5.6 for a full month and a half before its official release. During that time, he did something few could imagine: based on fast-mode pricing estimates, he burned through roughly $180,000 to $240,000 in inference costs, spanning 67 projects, pushing the model to unprecedented limits.

This isn't a standard review—the author deliberately emphasizes that before recording his video, he hadn't read any media coverage, benchmarks, or community feedback about GPT-5.6. He simply wanted to share his most authentic hands-on experience. That's exactly why this "$200K burn" field report carries extra weight.

An AI Agent That Can Work Continuously for 20 Hours

The author's most immediate impression of GPT-5.6 is this: it no longer "gets lost."

He candidly admits that the biggest problem with the previous generation, GPT-5.5, was its tendency to lose direction during long tasks—once bad information crept into the context, you had to tear it all down, start over, and open a new thread. GPT-5.6 completely changed that: "I can let a thread run indefinitely, no problem at all."

Even more striking is the task duration. The author states that he once let the model run continuously for over 20 hours to complete a massive task without setting any goal anchors whatsoever, and the model stayed locked on the objective the entire time, right up to completion. This "workhorse"-like focus made him reconsider automation features he'd previously found gimmicky.

He specifically noted that even calculated at fast-mode pricing, his spend on a single project reached tens of thousands of dollars. But he also clarified that fast mode isn't mandatory—regular mode costs nearly half of fast mode, and the $200/month subscription plan already includes about $14,000 worth of inference credits. In other words, some of his extreme usage could actually be covered by a standard subscription.

Real Engineering Deployment: From Lakebed to T3 Code

One of the projects the author invested the most effort in was a cloud platform called Lakebed. GPT-5.6 handled a great deal of hardcore work here:

• Refactoring the giant monolithic JavaScript files written by GPT-5.5 into a well-organized TypeScript project;
• Building brand-new CI pipelines, preview and release workflows;
• Implementing complex systems like artifact storage, whitelist access control, and CLI login authentication;
• Hardening the reactive logic of the database layer and designing a complete contract for file object storage.

He emphasized that the "vast majority of these changes were written by GPT-5.6," and he's about to open-source this platform, which evolved from a "weird little side project."

Another key project was T3 Code—a platform for unified management of various AI agents, covering desktop, web, and mobile. The author had struggled badly with mobile in the past, where various high-end models all performed poorly. But GPT-5.6's performance on mobile development convinced him to "increase the dosage": he had the model rewrite the entire React Native app from scratch, once using AppKit and Swift, and once using SwiftUI—amounting to two complete native rewrites.

The results stunned him—both versions were end-to-end fully functional, feature-aligned finished products, and each rewrite took just 2 to 4 hours. Combined with the model's excellent "computer use" capability (it could directly launch a simulator to verify results), the entire development workflow formed a complete loop.

A Bold Port: Rewriting the TypeScript Compiler in Rust

Inspired by "bun being rewritten in Rust," the author attempted a series of bold porting experiments.

He first fully rewrote his own Hermes Agent in Rust, having GPT-5.6 comb through the entire history, identify the roughly 50% of features actually in use, and implement them one by one. The resulting Rust version used only about 15MB of memory—far leaner than the original Python version.

What excited him most was rewriting the TypeScript compiler. He successfully produced a 100% functional transpiler (responsible for converting TS to JS), written entirely in Rust, running up to 18x faster than the equivalent Go version. The entire codebase eventually swelled to nearly 200,000 lines of Rust code, spanning 29 crates.

That said, the author faithfully presented the limitations: after analyzing this code, Fable concluded it was "a broad prototype with only a tiny verified slice, far from deliverable state"—achieving roughly 15-20% of a usable tool, but only about 5% of a complete TS-Go replacement, with limited progress on type checking and many tests still failing. This honest self-assessment reflects exactly the professional attitude of a power user.

"We've Really Arrived": A Highlight Moment for Computer Use

If this piece has a climax, it's the author's experience fixing a broken machine.

At the time, he damaged the boot partition while swapping out an SSD, leaving the machine only able to boot into a broken GRUB interface. When he asked GPT-5.6 for help, the model initially "hallucinated" some BIOS options that didn't exist—but once the author granted it direct control access to a remote KVM, the situation reversed.

The model autonomously rebooted several times, entered the GRUB shell, correctly booted the system, and then used its computer-use capability to remotely operate the machine, open a terminal, and automatically repair the boot partition—all without any human intervention.

The author described it as one of the most "holy crap, we've really arrived" moments he'd ever encountered. Tasks like this used to give him nightmares—he could roughly do them, but they required a lot of research, patience, and risk tolerance. GPT-5.6 handled it effortlessly. This experience directly pushed him to explore the boundaries of computer use more aggressively.

Afterward, he also used the model to build a bootable Linux recovery USB drive (with Codex and Claude built in), along with a repository managing the configuration of all his machines—so that with each new machine, he simply tells the model what it's for, and it configures everything automatically.

Stay Grounded: Frontend Capability Is Still a Clear Weakness

The author didn't blindly heap praise. He explicitly points out that GPT-5.6 is not a magically perfect frontend model. It's more "steerable" than other models and its default aesthetics are less error-prone, but "it's by no means an outstanding frontend model."

While building a 3D game demo, he observed that the model's understanding of 3D was "weird"—it could generate environments, rocks, and textures on its own, with some textures even better than Grok's output, but the monster and fish models were "absurdly ugly," and the control logic frequently went wrong. Still, he acknowledged that progress in this area is fast enough to warrant ongoing attention.

For UI development, his approach is to have GPT-5.6 build out the functional skeleton, then hand it off to Opus to polish the interface—this play-to-strengths combo may well be the most pragmatic usage posture at the current stage.

Conclusion: A Model That Makes Engineers "Think Bigger"

All things considered, the author's core verdict on GPT-5.6 is "workhorse":

It no longer needs the fine-grained steering that GPT-5.5 required. You just say "go do it," and it keeps working, autonomously manages context, doesn't get lost, and doesn't give up halfway. This qualitative leap in agent capability directly shaped the direction of the author's recent talks—because simple tasks are too easy for it, he's had to give it harder, grander challenges.

Of course, $200K worth of inference is by no means reasonable usage for the average person, and the author himself stresses that "no one should do this every month." But this extreme-stress-test field report gives us an early glimpse of how rapidly the capability ceiling of AI agents is rising in real engineering scenarios. As the author puts it: "This model genuinely excites me—it makes me want to build more and think bigger."