Overview
Ben Davis reverses his earlier take on GPT 5.5: while low reasoning remains his default for most tasks, xHigh reasoning in the Codex desktop app unlocks an entirely new tier of agent workflows — especially when combined with computer use. He demonstrates the model controlling a browser to test frontend UI, discusses the growing tension between agent autonomy and security, reveals Peter Steinberger's staggering $1.3M monthly API spend on OpenClaw, and shares his evolving setup: worktrees for parallel development, daily automations to clean his dev directory, remote Codex from mobile, and a vision for always-on Mac Mini agents. His core message: push these models harder — the workflows they enable are completely unrecognizable from 3 months ago.
1 xHigh Reasoning Changes Everything
Ben opens by clarifying his position: he's not taking back his recommendation to use GPT 5.5 on low reasoning — he still uses that the vast majority of the time. But over the past week, he's been pushing GPT 5.5 on xHigh reasoning specifically in the Codex desktop app, and the results are fundamentally different from what he experienced with older models.
- GPT 5.4 on high — his previous default; never felt the need to change reasoning levels
- GPT 5.5 on low — still his daily driver for most coding tasks
- GPT 5.5 on xHigh + Codex desktop — a different beast entirely. Combined with the new features in Codex desktop (computer use, worktrees, automations), it unlocks workflows that weren't possible before
2 Computer Use — Live Demo
Ben demonstrates the computer use skill in the Codex desktop app. His prompt asks the agent to:
- Go through and test the actual chat stream experience of his app (Helium)
- Put in a message, have it stream in, verify formatting and content look correct
- Double-check functionality: retry button, edit button, copy button
- Give a report on current functionality plus proposed fixes
What happens in practice
The agent opens the app in a browser via Helium, and a cursor moves around the screen autonomously — Ben isn't touching anything. The agent:
- Asked for a TypeScript code snippet to test the chat stream
- Ran a copy test on the output
- Attempted to test the stop button — but failed because the agent is too slow to click stop before the fast model finishes generating
- Started figuring out how to create a better test for the stop functionality
Real-world fix example
Earlier, Ben had Clerk component styling issues — gross little boxes around icons. He told the agent to use computer use to verify the fix. The agent made its CSS fixes, then opened the browser, took a screenshot of the actual app state, and confirmed the boxes were gone.
3 Feedback Loops Rooted in Reality
Ben hammers home his recurring thesis — the single best thing you can do to get better outputs from agents is to give them a feedback loop rooted in reality:
- Schema checks — make sure outputs are in the right shape
- Compile/check commands — verify code actually compiles and is syntactically correct
- Computer use (new) — instead of just checking syntax (which still misses logic errors), the agent can now run the app and see the actual result
The progression is clear: syntax checking → type checking → runtime testing → visual verification via computer use. Each level catches a deeper class of errors that the previous one misses.
4 Environment Variables & Cloud Dashboard Pain
Ben rants about the growing pain of environment variables and cloud console configurations as you scale up agent usage:
- The parallelization problem — you want multiple agents running simultaneously on the same project (frontend + backend), but each needs its own worktree, which needs its own
.envfile, and if you're using something like Convex, each worktree needs its own instance to avoid conflicts - The deployment problem — getting something working locally is great, but deploying means stitching together random env vars, setting up preview deploys, configuring hosting — "why can I not just run one command to actually do the thing?"
- AgentMail — Ben highlights this as an example of the right approach: it gives AI agents email inboxes entirely over API and SDK. Create inboxes, read threads, update threads — no dashboards, no clicking, everything programmatic
His hope: in the long term, everything can be interacted with over API, eliminating the need for humans to click through dashboards.
5 Agents Using the Browser for Cloud Setup
In the meantime, computer use fills the gap. Ben describes using it to navigate the Google Cloud Console — not because he's using Google Cloud for hosting, but because he needs YouTube API, Gmail API, and Google Drive API access for internal tooling at work.
The tedious process of setting OAuth scopes, authorizing emails, and clicking through dashboards is something he now delegates to the agent. Specifically, he mentions using it to set up Gogg CLI (by Peter Steinberger, creator of OpenClaw) — a tool that lets agents access your Gmail inbox. The agent handles:
- Creating the GCP project
- Setting up credentials and OAuth configuration
- Copy-pasting credentials into the right places
- Then letting the human do the actual login (the only manual step)
6 The Security Dilemma — Letting Go
This section is the most philosophically interesting part of the video. Ben is brutally honest about his evolving relationship with agent permissions:
Where he is now
- He's had full root access ("dangerously run all permissions") turned on in Codex for 4 months
- He doesn't watch what the agents are doing most of the time — "half the time, probably more than half the time"
- He runs 5-6 agents in the background simultaneously, just letting them do their thing
- 4 months ago he thought this was insane — "I never in a million years could have imagined letting an agent have full root access to my computer at all times"
Where he's not yet
- Giving agents access to sensitive credentials in cloud dashboards (GCP, YouTube API, Gmail API) — "still kind of terrifying"
- Same concern with Hermes Agent and OpenClaw — the idea of read/write access to YouTube or Gmail API is a bridge he hasn't fully crossed
The parsability problem
Ben raises a critical observation about command approval: agents now generate gigantic bash commands or Python scripts for approval. Even though Hermes Agent has a good permission system, the approval requests are increasingly unparseable — "are you going to closely read this entire thing while lying in bed looking at it on your phone?"
7 Peter's $1.3M Monthly API Spend
Ben shares a jaw-dropping data point from Peter Steinberger, the creator of OpenClaw (who currently works at OpenAI, so he gets tokens for free):
- $1.3 million worth of API credit spend in the last 30 days
- Turning off fast mode (which Ben currently uses — GPT 5.5 xHigh on fast) would bring it down to ~$300K/month
- Peter is running an experiment: what would a product look like if tokens were free and unlimited?
What Peter's setup looks like
- A "bajillion" sub-agents running on the OpenClaw project
- Every commit, change, and issue gets processed through multiple OpenClaw instances
- When a PR lands, agents scan thousands of issues to find any that might be related and auto-close them
- Duplicate PRs are automatically identified and closed
- AI autonomously manages the entire gigantic open-source project
Ben's own usage
In contrast, Ben has 98-99% of his $200/month ChatGPT Pro remaining — but that's partly because he has 10x rate limits from the OpenAI "5.5 party" event. Normalized, he estimates he'd be at ~80-90% used, but acknowledges he's "burning thousands of dollars worth of tokens" at actual API rates.
8 Codex Desktop App & Worktrees
Ben dives into the Codex desktop app's worktree support, which enables parallel development:
- Creating a new thread with "new worktree" option branches off main
- The app automatically copies
.env.localfrom the main branch into the new worktree - It sets up a new Convex instance specifically for that worktree to avoid conflicts
- Each worktree can run its own dev server independently
Built-in browser
The Codex desktop app includes an embedded browser that connects to your running dev server. Features:
- Screenshots → automatically put on clipboard, pasteable into chat
- Element selection → click an element, add a comment that gets passed into the next prompt
- Run the dev server inside the worktree and interact with the app directly from within Codex
Ben notes: "The Codex desktop app has gotten really good and I'm pretty much using it for everything."
9 Automations, Mobile App & Dream Setup
Codex automations
Ben has set up a daily automation at 5 PM that runs a Codex session to:
- Clean up his developer directory (which gets bloated with experimental projects)
- Get rid of stale stuff he's no longer working on
- Keep notes on what he is and isn't working on
- Save memories about the state of his projects
He calls it "a nice little babysitter for that directory."
Remote Codex via ChatGPT mobile
OpenAI added a Codex section to the ChatGPT mobile app that links to your desktop Codex instance. This means:
- Your computer can be running at home with Codex active
- From your phone, you can create and manage threads remotely
- The experience is "pretty seamless" and "feels really good"
Mac Mini dream setup
Ben's dream setup (work in progress): a Mac Mini in his network closet running permanently with:
- Hermes Agent and other always-on agents
- A Codex instance so he can send prompts from anywhere and have work happen in the background
- The blocker: security — giving always-on agents persistent access is "a nightmare"
Cursor Cloud Agents
As an alternative to dedicated hardware, Ben praises Cursor's cloud agents as "really, really good" — though he has issues with the current Cursor desktop experience ("Glass is not where it needs to be").
10 Reducing Dependencies & Supply Chain Risk
Ben closes with an observation about how agent-friendly project architecture is evolving:
Zero env var setup
He praises Julius's work on T3 Code: the entire project can run with no .env files. You only need an OpenRouter API key for model inference, but booting, viewing, and signing in can all be simulated without any environment variables. This makes worktree parallelization trivial.
Fewer npm dependencies
Ben is actively working to minimize package.json dependencies across all his projects. His reasoning:
- Supply chain attacks are "getting very real and very bad very fast"
- Instead of installing a package, he has the agent recreate the package's functionality inside the project
- Agents are now good enough to replicate most library functionality inline: "they kind of just can at this point"
🎯 Key Takeaways
🔑 Key Takeaways
- GPT 5.5 on xHigh + Codex desktop is a different tier — low reasoning is still the daily driver, but xHigh with computer use enables workflows that were impossible before
- Computer use closes the feedback loop — agents can now test their own frontend work by running the app and seeing the actual visual result, catching logic errors that syntax/type checking misses
- Agents should navigate cloud dashboards — tedious GCP/AWS/Cloudflare console clicking is a perfect use case for computer use while we wait for everything to become API-driven
- The permission escalation is inevitable — Ben went from "never in a million years" to full root access in 4 months. He runs 5-6 unsupervised agents daily. The trajectory is clear
- Approval requests are becoming unparseable — agents generate giant bash scripts or Python code for approval. Meaningful human review of every command is increasingly impractical
- $1.3M/month is the frontier — Peter Steinberger's OpenClaw experiment shows what's possible when tokens are free: fully autonomous open-source project management with thousands of issues processed per PR
- Worktrees enable parallel agent development — with proper env var isolation and per-worktree service instances, you can run multiple agents on the same codebase simultaneously
- Daily automations are babysitters — a simple 5 PM cron that cleans a dev directory and saves project state is the low-hanging fruit of agent automation
- Minimize dependencies for agent-friendliness — fewer env vars, fewer npm packages, zero-config boot. Supply chain attacks make this a security concern too, not just a DX preference
- Push harder — the free ride won't last forever — OpenAI's generous rate limits and the ChatGPT Pro $200/month value are unusually good right now. Experiment while the economics favor it
🔗 Resources & Links
- Ben Davis's X post — source thread about GPT 5.5 xHigh workflows
- Peter Steinberger's $1.3M API spend post — OpenClaw usage stats and autonomous project management