Theo did not spend six weeks trying to win one benchmark. He gave GPT-5.6 access to real repositories, simulators, browsers, remote machines, CI pipelines, deployment systems, and long-running Codex threads. The reported result was work across 67 projects and an estimated $180K-$240K of equivalent inference.
The number is spectacular. The useful part is messier: some projects moved toward production, some became working prototypes, some produced an impressive but narrow verified core, and some were discarded, superseded, or had not even been reviewed when Theo recorded the video.
Video credit: Theo - t3.gg. Follow Theo on X.
Source Note
This is a field-report analysis, not an independent audit of Theo's private repositories or billing. Project status, run duration, token counts, memory use, speed, and equivalent inference cost are attributed to Theo's video and attached transcript. Public repositories and official documentation are used to verify what the named systems are, not to claim access to private branches or unmerged work.
Theo explicitly says this video is not his GPT-5.6 review. It does not evaluate every model tier, ChatGPT behavior, benchmarks, pricing, or usage limits. OpenAI's official GPT-5.6 launch page remains the source of record for current availability and pricing. The deployment safety report and Codex safety guidance matter especially here because several experiments involved external services, remote machines, account creation, and boot repair.
Browserbase appears in a sponsored segment of the video. It is included in the Link Map as sponsor context, not as an independent endorsement by this article.
Link Map
| Resource | Status | Why it matters |
|---|---|---|
| Theo's GPT-5.6 field report | Primary commentary | The creator-reported project history, outcomes, costs, failures, and lessons organized below. |
| OpenAI: GPT-5.6 | Official | Current model family, availability, pricing, reasoning modes, tools, and published capability claims. |
| GPT-5.6 deployment safety | Official safety source | Documents autonomy risks, including the possibility of going beyond user intent and taking destructive or externally visible actions. |
| Running Codex safely | Official guidance | Sandboxing, approvals, network policy, credentials, managed configuration, and telemetry for agentic work. |
| T3 Code / GitHub | Public project | The open-source control plane for coding agents that Theo used for native rewrites, computer use, UI work, and PR workflows. |
| Lakebed docs / npm | Public project | The agent-native TypeScript runtime where GPT-5.6 reportedly handled CI, deploys, auth, storage, files, and database work. |
| Microsoft TypeScript-Go | Official repository | The staging native TypeScript port that Theo asked GPT-5.6 to reimplement in Rust. |
| NousResearch Hermes Agent | Official repository | The open agent platform behind the Rust rewrite experiment and the recurring PR-triage automation. |
| SwiftUI, AppKit, and Xcode simulation | Official Apple docs | The native frameworks and target feedback loop relevant to the two T3 Code rewrites. |
| Browserbase / docs | Video sponsor | Cloud browser infrastructure shown during the sponsored segment. Use sponsor claims as product context, not neutral evaluation. |
| PlanetScale and Railway | External services | Examples of infrastructure an agent touched or considered, which makes approval and credential boundaries concrete. |
What the Experiment Actually Was
Theo describes about six weeks of early access, 67 project directories, and an estimated $180K-$240K of equivalent inference. That range is not a normal invoice. It is his estimate of what the usage would have represented, and he repeatedly warns viewers not to reproduce the spend.
The operating environment matters more than the headline. GPT-5.6 was not answering isolated chat questions. It could inspect code, edit repositories, run commands, use simulators and browsers, connect to machines over SSH, control a remote KVM, interact with CI, and continue some threads for more than 20 hours.
That makes the report valuable, but it also makes simple model comparisons difficult. The outcome came from a system: model plus Codex plus repository context plus tools plus target feedback plus Theo's judgment. A weaker harness or vague objective would produce a different result.
The Project Ledger
The video mentions more work than it can examine deeply, so this table does not pretend to list all 67 projects. It organizes the projects Theo actually discusses and labels the evidence level.
| Project | What GPT-5.6 reportedly did | Status in the video | Builder read |
|---|---|---|---|
| Lakebed | TypeScript restructuring, CI, preview and release workflows, auth, deploy refreshes, object storage, file contracts, database reactivity, PR recovery, and launch review. | Kept / moving toward production | The clearest evidence of useful integrated engineering work because the output touched real product systems and many changes were being retained. |
| T3 Code native rewrites | Rebuilt the React Native application twice, once with AppKit and Swift and once with SwiftUI, with reported simulator checks and end-to-end operation. | Working prototypes | Impressive speed and breadth, but working in a simulator is not the same as merged, maintained, production software. |
| T3 Code computer use | Built a full computer-use loop. | Superseded | Theo did not merge it because another implementation was better. Rejecting competent work is part of good engineering. |
| T3 Code marketing site | Rebuilt the public marketing experience. | Kept / active | A smaller but stronger signal than an unreviewed giant rewrite because the work remained in use. |
| Hermes Agent in Rust | Used archived histories to identify the subset Theo and Ben actually used, then rebuilt responses, threads, skills, model calls, and a goal run with a reported 15 MB memory footprint. | Working reduced-scope prototype | Good product scoping: reproduce the useful surface first. It was not a feature-complete replacement for Hermes Agent. |
| TypeScript-Go in Rust | Generated roughly 195K-200K lines across 29 crates and a reported no-check transpiler that ran up to 18x faster than Go on a five-file corpus. | Narrow verified slice | Type checking did not get far and tests were failing. Theo's later review reportedly placed it far from a usable replacement. |
| FS2 dev-folder sync | A one-goal run reportedly consumed 71.2 billion tokens, created infrastructure, and registered for PlanetScale. | Unverified | Theo had not opened the output. This is a governance warning, not a success story. |
| Bootable Codex recovery drive | Built a Linux recovery environment with Codex, Claude, remote access, and network setup. | Working | A concrete operations tool with a clear use case and testable outcome. |
| Autonomous boot repair | Used remote KVM access to navigate broken GRUB, reach a shell, and repair boot partitions after first hallucinating BIOS options. | Creator-reported success, high risk | Powerful computer use, but exactly the kind of workflow that needs snapshots, narrow permissions, logs, and approval checkpoints. |
| Machine fleet repository | Documented machines, purposes, and configurations so the model could help configure additional systems. | Operational | Context infrastructure is a durable asset. It makes future runs faster without depending on model memory. |
| Skatebench overhaul | Improved the benchmark system, with a token-spend reporting issue still outstanding. | Kept with known gap | Honest known-issue tracking is more credible than calling a partially correct system finished. |
| Fish Slop game experiments | Generated 2D and 3D game work, art, textures, environments, and controls. | Prototype, not shippable | Theo called out poor UI, controls, monsters, and weak spatial understanding despite visible progress. |
| Prime Day verification | Used browser actions to verify deals and build country-aware links. | Useful automation; copy discarded | The research workflow survived; the generated marketing copy did not. |
| Terminal token tracker | Built a functioning tracker. | Function kept; UI replaced | Capability and design quality should be evaluated separately. Theo rebuilt the weak interface with another model. |
| Presence tracker and plan-service work | Built a MAC-address office/home presence tool and overhauled an internal plan service. | Useful internal tools | Small, bounded utilities may create more reliable value than giant speculative rewrites. |
Status key: kept / operational means Theo says the work remained in use or was heading to production; working prototype means behavior was demonstrated or reported but not independently verified as production-ready; narrow verified slice means a small core worked while the broader system remained unproven; unverified means output existed but Theo had not reviewed it; discarded / superseded means it was not shipped or another implementation won.
What Theo Did Well
1. He used real systems, not only toy prompts
Lakebed, T3 Code, Hermes Agent, TypeScript-Go, remote machines, CI, and deployment infrastructure expose dependency edges that a one-file demo hides. The work had to compile, run, connect, authenticate, deploy, or survive contact with an existing codebase.
2. He gave the agent target-environment feedback
The model could use simulators, browsers, shells, and remote KVM access. That closes the gap between "the code looks plausible" and "the application actually launches." For native work, Apple's own guidance centers testing on simulated and physical devices; the same principle applies to web, infrastructure, and operating-system work.
3. He scoped one rewrite from actual usage history
Before the Hermes rewrite, the process examined archived usage and identified the smaller feature set Theo and Ben relied on. This is much better than blindly recreating every feature. Historical behavior became a product specification.
4. He used independent review
The TypeScript-Go rewrite is most useful because Theo did not stop at the line count. He asked another frontier model to review it and shared the uncomfortable conclusion: a broad prototype with a tiny verified slice, not a replacement. That review turned a hype artifact into an engineering lesson.
5. He converted one-off success into a recurring system
Subagents helped triage T3 Code pull requests. Theo then turned that workflow into a daily Hermes automation. The compounding move is not "run a clever prompt again." It is saving the successful process, inputs, checks, and schedule.
6. He was willing to throw work away
Computer use was superseded, weak copy was discarded, the token tracker's UI was replaced, and some large prototypes were not called finished. Taste and rejection remain part of the human job.
Lakebed: The Strongest Production Signal
The Lakebed segment is less dramatic than 200,000 lines of Rust, but it may be the most important. Lakebed is a public agent-native TypeScript runtime for small full-stack applications. Its documentation exposes real operational concerns: authentication, storage, CI deploys, server-authoritative mutations, and private inspection.
Theo reports GPT-5.6 helping move a large JavaScript surface into structured TypeScript, build preview and release workflows, connect artifact storage, refresh deployments from database events, shape CLI authentication, harden database reactivity, define developer-file contracts, and audit the project for an open-source launch.
This is what high-value agentic coding looks like: many medium-sized changes that fit the architecture and survive integration. It is harder to summarize in one screenshot, but more likely to matter to users.
T3 Code: Native Rewrites and Target Feedback
T3 Code is an open-source desktop control plane for coding agents. Theo says GPT-5.6 rebuilt its React Native application twice: an AppKit/Swift version and a SwiftUI version. Each reportedly took roughly two to four hours and reached an end-to-end state that the model checked in a simulator.
That is a meaningful result because native rewrites require more than translating syntax. The app has lifecycle behavior, window management, state, platform APIs, packaging, and target-specific UI. Simulator access gave the model a feedback loop that pure code generation would not have.
The status still needs discipline: Theo showed working experiments, not proof that both rewrites were merged, distributed, or maintained. The right statement is "GPT-5.6 produced two functioning native prototypes," not "GPT-5.6 replaced the production app."
Other T3 Code work reinforces the same pattern. The marketing site stayed in use. A computer-use implementation was not merged because a better one existed. A route-backed machine switcher looked promising but remained unshipped. PR triage became recurring automation. Useful outcomes had different destinations, and the model did not deserve credit for production until the human accepted the work.
Rust Rewrites: Built Is Not the Same as Proven
Hermes Agent: reduce scope before rewriting
The Hermes experiment started with a smart question: which features do the users actually use? GPT-5.6 reportedly analyzed archived histories, identified roughly half the surface as relevant, and built a Rust version with responses, threads, skills, model calls, and a functioning goal run. Theo reported about 15 MB of memory use.
That is a credible reduced-scope prototype. It is not a feature-complete rewrite of the public Hermes Agent. The win is the scoping method, not the language change by itself.
TypeScript-Go: 200,000 lines can still be 5 percent done
Microsoft's TypeScript-Go repository is itself a staging native port with explicit feature-status warnings. Reimplementing it in Rust is a serious compiler project, not a normal app rewrite.
Theo reports that GPT-5.6 generated about 195K-200K lines across 29 crates. A no-check transpilation path reportedly worked and reached up to 18x the Go speed on a five-file corpus. But type checking had barely progressed and the test suite was failing. A later review reportedly assessed the result as perhaps 15-20 percent toward a usable tool and around 5 percent toward a proper replacement.
This is the cleanest lesson in the entire video: code volume is not completion. For a compiler rewrite, the evidence should be compatibility suites, semantic parity, conformance fixtures, performance across representative corpora, memory behavior, error recovery, editor integration, and reproducible passing tests.
Computer Use and the Machine Fleet
Theo also connected GPT-5.6 to physical and virtual machines through SSH, computer use, and remote KVM. A fleet repository documented each machine, its purpose, and configuration so the agent could reason from written infrastructure context rather than rediscovering everything.
The most striking example was a broken Linux boot. Theo says the model first hallucinated BIOS options. After receiving direct visual control, it navigated GRUB, rebooted, reached a shell, and repaired boot partitions. The recovery worked, but the initial hallucination matters as much as the ending.
Computer use is strongest when the environment answers back. It is also dangerous because the model can act on disks, credentials, accounts, and external systems. OpenAI's own safety material recommends sandboxing, approval boundaries, network controls, scoped identity, managed configuration, and telemetry. For boot repair, add disk images, snapshots, verified backups, and a human checkpoint before writes.
What Failed or Stayed Unverified
The most expensive run may be the least informative. Theo describes an FS2 Dropbox-like development-folder sync task that consumed a reported 71.2 billion tokens and around $91K in fast-mode equivalent value. The agent also registered for PlanetScale. Theo had not opened or reviewed the result when recording.
That means the valid status is not "built." It is "output exists." Without review, tests, target demonstration, security inspection, and a deployment decision, the token count says nothing about usefulness.
Other misses were smaller and more relatable. Generated marketing copy was poor. A functioning terminal tool had an interface Theo disliked. The 3D game had visible assets but weak controls, UI, monsters, and spatial decisions. One minimal replacement was abandoned because an existing tool was better. These are healthy outcomes when they are found early.
The failure pattern was not that GPT-5.6 could do nothing. It was that persistence can amplify the wrong objective. A model that works for 20 hours can produce more value, or simply travel farther before a human notices the route was wrong.
The Repeatable Playbook
- Start with a real repository and one measurable outcome. Avoid "rewrite this system" without compatibility, performance, and acceptance targets.
- Write a definition of done. Include behavior, tests, supported environments, non-goals, security constraints, and what evidence the final report must contain.
- Give the agent the target feedback loop. Connect the simulator, browser, test runner, staging environment, or isolated machine it needs to verify the work.
- Stage large work. Require architecture, a thin vertical slice, compatibility tests, implementation batches, and a final audit instead of one unlimited run.
- Save checkpoints. Every stage should leave a diff, test report, known-gaps list, cost summary, and next decision.
- Use independent review. A second model or human reviewer should challenge tests, scope, security, performance claims, and hidden regressions.
- Promote only accepted workflows. When a one-off run works, convert it into a skill, scheduled job, or documented automation with the same controls.
Permission and Cost Boundaries
Extreme agent experiments need hard constraints before the first tool call, not after the bill or incident.
| Boundary | Minimum control | Why |
|---|---|---|
| Time and tokens | Per-stage budget, wall-clock limit, idle timeout, and explicit continuation approval. | Persistence should not become an unbounded objective function. |
| Filesystem | Workspace sandbox, protected paths, version control, snapshots, and tested restore. | Prevents one mistaken command from becoming irreversible. |
| Network | Domain allowlist, blocked unknown uploads, and logged outbound requests. | Reduces accidental data disclosure and surprise service use. |
| Credentials | Short-lived, task-scoped keys stored outside prompts and repository files. | Limits damage if a tool, log, or generated file exposes a secret. |
| External actions | Human approval before account creation, purchases, production deploys, messages, or public changes. | The PlanetScale example shows why "helpful" autonomy can cross an operational boundary. |
| Machine control | Isolated test host, KVM recording, snapshots, console fallback, and approval before disk or firmware changes. | Boot repair can become data loss or downtime without recovery controls. |
| Completion claims | Acceptance suite plus human or independent-model review. | Prevents 200,000 generated lines from masquerading as a finished compiler. |
Bottom Line
Theo's six-week run is strong evidence that GPT-5.6 can remain useful across long, tool-heavy engineering work. It appears capable of integrating product systems, producing functioning native prototypes, operating browsers and machines, and sustaining large implementation plans longer than earlier coding models.
It is also evidence against judging agents by spectacle. The biggest run was unreviewed. The largest rewrite was far from feature complete. Some UI and copy were thrown away. Some good work lost to a better implementation. The most convincing wins were the ones connected to a real product, a target environment, and an acceptance decision.
The durable advantage is not access to one expensive model. It is the engineering system around it: context, permissions, verification, review, and the judgment to know what deserves to ship.
Sources
- Theo - t3.gg: So I have been using GPT-5.6 for a while
- Theo on YouTube and X
- OpenAI: GPT-5.6
- OpenAI Deployment Safety: GPT-5.6 preview
- OpenAI: Running Codex safely at scale
- T3 Code and pingdotgg/t3code on GitHub
- Lakebed documentation and Lakebed on npm
- Microsoft TypeScript-Go on GitHub
- NousResearch Hermes Agent on GitHub
- Apple SwiftUI, AppKit, and Xcode device testing
- Browserbase and Browserbase docs - video sponsor context
- PlanetScale and Railway