Skip to content

Nate B Jones AI DevOps Career

Codex: Your First Personal AI Agent Delegation Loop

Nate B Jones makes the case that OpenAI's Codex is much more than a coding tool: it turns your whole computer into something you can hand jobs to in plain English, routing your files, browser, documents, and terminal through an agent in a loop. He maps a year of his own token usage to show the real shift, from asking AI for answers to delegating whole jobs, which pushed him past 500 million tokens in a single day. He frames it as the first computing paradigm change in 40 years, from an application-first world where the human is the router to an agent-first world where the human delegates, and explains the building blocks: chief of staff threads, subagents, computer use, plugins, and skills. The practical payload is a repeatable delegation loop, give Codex a goal, sources, a standard, a permission boundary, and proof that it is done, plus a worked example of a custom heads-up dashboard for your work day. He closes on boundaries and receipts, keep secrets in a .env file, withhold write and spend access, and always make the agent show its work.

Published Jun 12, 2026 19:36 video 26 min read Added Jun 16, 2026 Open on YouTube →

At a glance

Nate B Jones is obsessed with Codex the way a kid is obsessed with a new PlayStation, and this video is his attempt to explain why before people bounce off the tool for the wrong reason, namely that the name sounds like it is only for coders. His claim is bigger than code. Codex changed how his computer feels, because his files, browser, folders, drafts, and screenshots now belong to an agent he can hand work to in plain English, not just an app he operates by hand. He maps a year of his own token usage and shows that the biggest jump came in the last month, when computer use plus a Codex 5.5 model unlocked a pile of his workflows at once, pushing him to 300 to 500 million tokens on an ordinary day. The throughline is that we are living through the first change in the computing paradigm in roughly forty years, from an application-first world where the human is the router to an agent-first world where the human sits above the machine and delegates. The practical payload is a repeatable delegation loop you can run today: pick one annoying, valuable job and give Codex five things, a goal, sources, a standard, a permission boundary, and the proof that it is done.

Codex makes the computer feel different

Jones opens with the feeling, not the feature list. He keeps wanting to grab people and say "no, no, no, you have to see what this thing just did," because Codex is not just giving him better AI answers, it is making his computer feel different. His files, his browser, his folders, his drafts and screenshots all belong to Codex now. The weird little personal systems he used to wire together by hand, Codex moves across all of them. That is why his token dashboard has gotten ridiculous lately. Not because he is chatting more, but because he is handing Codex bigger jobs.

He draws the line precisely. Before Codex, most of his AI work still ended up looking like chat unless it was code: draft this, summarize this, clean this up, help me think through this. Useful, but it was still him asking for help. With Codex he started doing something else. He started giving his computer jobs. Find the transcript, read the folder, compare the versions, render the Word file, check that it opens, open the browser, use the site, keep going until there is something real for me to inspect. That is the shift that blows his mind. Not that Codex writes code, but that it makes the computer feel like something you can hand work to.

Then the disclaimer he wants out of the way early, stated as a refusal rather than a hedge: this is not a take-a-side video, he is not asking you to join team OpenAI, it is just a deep dive into why Codex works for him. And if you have avoided it because the word Codex sounds like code, that is exactly why you should stay. The name is bad, honestly. It sounds like a developer tool. Developers see it first only because coding has a clean working environment, clean tests, files, diffs, logs, that made it easy for an agent to engage. But the habit Codex teaches is much bigger than code. If you write, research, make documents or Excel spreadsheets, run a tiny business, organize projects, manage content, or just spend your day switching apps and opening a dozen Chrome tabs, the point is not that Codex can write software. The point is that Codex helps you get all of that done on the computer you already use. And yes, it is on Windows now too.

He previews the whole tour: the Chief of Staff thread, goals, multiple threads, computer use, plugins, skills, drafting several artifacts at once, using websites, checking work, and turning repeated corrections into reusable workflows. He also frames the video as a learning thread, an invitation to people already pushing the tool to tell him what he is missing in the comments, because the real playbook is still being written by the people who use it hard.

The token dashboard as a work receipt

On May 20th his local Codex log showed 510 million tokens in one day. He knows that sounds insane, so he heads off the wrong conclusions immediately. This is not all of his AI tokens, just what ran under his Codex Max account. It is not a surprise billing story, he is not paying extra. The point is that the way he uses his computer changed completely, and he thinks we are sleeping on it. More of his computer stopped being app-by-app manual work and started running through agents. Most of the work he does now goes through agents and Codex, not apps directly, and when he does open an app it feels like a hassle. His files, browser sessions, documents, code, and terminal output all route through Codex.

The number itself is not the point, and he is blunt about that: do not wake up and decide "Nate said burn half a billion tokens," that would be a dumb target. The number matters because it shows the computer itself is changing. We have computed for decades in bits and bytes, and now we are moving to tokens, and he says he can prove this is the biggest shift. He mapped his token burn back over a year, and behaviorally it is very clear the biggest jump came in roughly the last month, as computer use plus the 5.5 model in Codex unlocked a huge number of his workflows at once.

So when he cites the giant number, half a billion, 800 million, whatever, he is not bragging about volume. If that only meant he was typing more prompts, it would be embarrassing. It went up because the unit of work changed in scale. He stopped asking AI only for answers and started asking Codex to carry more of the job: go find the source files, go read the transcript, go make the artifact, go render the document, go check the package, go inspect the browser, go keep working until the goal is done. When he says Codex 10x'd parts of his workflow, he does not mean he got 10x smarter. He means the size of the job he is willing to hand the machine changed. The chart is not a scoreboard or a vanity metric. It is a receipt that reflects how the work has changed.

Figure 1. The receipt, redrawn. Jones mapped a year of his own daily token burn. It sits flat and low while AI is mostly chat, then turns sharply upward in the final month once computer use and the Codex 5.5 model let him hand over whole jobs rather than ask for answers. The 510 million token day is not a target, it is evidence that the unit of work, not his typing speed, changed in scale.

The unit of work gets bigger, and the new compute model

He names the deeper question: what is the compute model, and what is changing? For most of our lives computers have been application-first, and that was itself a revolution. He remembers DOS, when the app became the unit of work. In the 1990s he could write a document without writing code, open a browser, he name-checks Netscape Navigator, open a spreadsheet and just do the work. Huge productivity gains. But the human moved between the apps, the human remembered why each one was open, the whole experience was built around the human first.

He grounds the new model in a story. He made a TikTok recently pointing out that his computer feels like it belongs to Codex as much as to him, because sometimes he cannot use it: it is burning literally 100 million tokens an hour and you can hear it hissing in the background. It runs at max memory capacity while he records, and he does not mind, because it is doing ten things at once that he could never do at once. He just hands out assignments, goes for a walk, touches grass, comes back, and ten things are done.

That is the paradigm shift, and he dates it: the first change in the computing paradigm in about forty years. We are moving from a world where humans sit at the center of the compute paradigm to one where humans sit above it and delegate to agents who run the compute for us. Codex is a way into that future, not the only one, and he is explicit that he is not claiming Anthropic will not get there, he knows they will. Underneath Codex sit the old primitives, files, source notes, templates, the applications themselves, and Codex can drive all of them with agents. The mechanism, in plainer words, is a state machine, which is a fancy way of saying an agent in a loop that remembers what it is doing and can work the whole computer. Tokens are the cost of letting that agent compute for you, so the more of your work runs through agents, the more your computer activity becomes token activity. That is the simplest answer for half a billion tokens a day, and he insists it is not an anomaly: he is easily doing 300, 400, 500 million tokens a day without trying hard. The goal is never to burn tokens or be wasteful. The goal is to put an active layer between your intent and the machine, so the intelligence can start to scale for you.

	Application-first (the last 40 years)	Agent-first (the shift now)
Unit of work	the app (DOS, the document, the browser)	the job, handed off in plain English
Who routes	the human moves between apps human is the router	the agent runs the loop human delegates
Who remembers	you, why each app is open and what is current	the thread, the goal, folders, artifacts, standard
Cost is measured in	bits and bytes	tokens
Your posture	operating the machine, hands on keys	sitting above it, assigning and checking
Example move	open the app, do the step, switch apps	go find the files, make the artifact, keep going until done

Figure 2. The forty year turn Jones is describing. The application-first era made the human the router who remembers why each app is open and moves between them by hand. The agent-first era puts the human above the machine: you hand off a job, and a thread that owns the goal runs the loop and reports back. The cost of work stops being bits and bytes and becomes tokens, which is exactly what his dashboard records.

Chief of staff threads

The first thing that made Codex click was that he stopped treating every thread like a random chat. Most people use AI as a pile of separate conversations: one chat for a draft, one for a bug, one for a note, one for a random question. The problem is that the human becomes the router. You have to remember where everything is, what matters, what the next move was, which version is current, what standard the work is supposed to meet. That does not scale, because our brains get tired.

The better pattern is one thread that stays pointed at the work. It knows the goal, the folders, the current artifacts, and the standard, and then it can spin out smaller jobs without making you re-explain the whole project every time. That is what he means by a Chief of Staff thread. It is not magic memory, he is careful here: you still have to give it sources, still have to correct it, still have to make it show receipts. But used this way it stops feeling like a chatbot and starts feeling like a home base for the work.

Threads, goals, and subagents

The next change was getting serious about goals and threads, which sounds small until you use it on a real project. A normal chatbot tends to stop the moment it has produced something that looks like an answer. Codex gets far more useful when you give it the actual objective: not "help me with this," but "read these sources, produce this artifact, check it against the standard, and do not stop at the first plausible draft, keep going." That changes the relationship. You are not asking for a response, you are assigning a job out.

He clears up a common confusion. A thread is not one agent doing every step itself. A thread is the run that owns the job, and a subagent is a smaller helper inside that job, used for a narrow piece of work so the main thread does not get buried in noise. One thread can plan the goal, using subagents for discovery, source checking, scouting, and reading through messy material. When the goal is cleaner, you can send it to another thread to execute. The execution thread owns the deliverable but still uses subagents inside the job: one scouts a site, another checks sources, another inspects output, another summarizes a noisy folder. The thread owns the job as a whole, the subagents handle contained pieces. Once that clicks, thread mode stops looking like a bunch of chats and starts looking like a way to separate planning, execution, and checking. And with the Chief of Staff pattern you manage most of this just by talking to your Chief of Staff. You do not hand-assign work to individual agents anymore, that is not how it works.

Figure 3. How Jones separates the work. The Chief of Staff thread holds the durable context. It hands a planning thread the task of shaping a goal, then hands a clean goal to an execution thread that owns the deliverable. Each thread spawns short-lived subagents for narrow pieces, scouting a site, checking sources, inspecting output, summarizing a noisy folder, so the thread that owns the job never gets buried in noise.

Computer use, plugins, and skills

The power is not one magic prompt, it is the setup around the model. He breaks the setup into named parts. Computer use is literal: it can see a screen, click, type, and use an app. Tools and connectors call real systems, plugins let it reach the places where your work already lives. Skills let you teach it a reusable way to do a job instead of explaining the same process every single time, and that last part matters most. If you correct Codex once, that is just a chat you had. If you turn the correction into a skill, a checklist, a reusable instruction, the work begins to compound.

This is where the code label is most misleading. Developers understand it first because they already live in a world of tools, files, tests, and workflows. But that same pattern now applies to documents, reports, research, invoices, dashboards, meeting prep, family logistics, and customer support. All of it can use code patterns to get better with Codex. If the work lives on your computer, Codex can help you get it done using patterns it learned from code, and you do not have to know code to do it.

A heads-up dashboard for work: the big example

The workflow he picks to demonstrate a big loop is a heads-up dashboard for your whole work day. Imagine, instead of buying some SaaS that forces a fixed shape on you, plug into Slack, plug into email, and still does not cover everything, you build an exact heads-up display that surfaces what matters in your workplace, custom-tuned to your tools. You can do it now, and it is not that hard. The recipe has three explicit steps you tell Codex:

Tell Codex about all the sources you use to do work: email, Slack, WhatsApp messages, the "carrier pigeon" messages, whatever it is. Those are all your sources.
Tell it what matters to you, how you actually move the needle in your job, and have an honest discussion about how you refer to those sources and what is salient in each one.
Ask it to design a dashboard that is live-updateable based on the sources it can pull from, via computer use or via an MCP server. Some sources have an MCP server, Slack has an MCP server skill, others it reaches with computer use in the browser, and that is fine.

The result is a personal heads-up display for work. At any point you can glance at it and know what matters in Slack, what matters in email, what you have to do, and what your prioritized list is, then go get it. Crucially, nobody built it with a seed round and a pile of VC money. You built it just for you, the way you work, with your data, and Codex can do that today. He notes the full readout lives on his Substack, and you can see examples over his shoulder because he actually built it on screen.

The dashboard is also a teaching device for two ideas: big loops and automations. You can wire an automation that updates the dashboard every 15 minutes or every half hour, your call. It checks all the data sources, runs the saliency analysis to see what really matters, then comes back and says "this is what I think matters, this is how I re-rank the priority, this is what to emphasize for work." It becomes your headquarters for work every day, and you custom-built it. He flags why this is new: as cool as the models were even two or three months ago, and as far into the long-running agentic revolution as we are, we did not have the computer availability and the computer use availability to unlock this. He picked it because it shows something only Codex could do today, and he expects other models to follow soon.

He highlights one feature that makes the loop reliable, the set-of-goal feature (the "set of gold" in his telling). It zeros Codex in on the goal you define and runs through walls until it reaches the done state. He loves it because he wants agents that do not stop early. He recalls the Ralph Wiggum loop era, back in January and February, when everyone was excited because Claude kept stopping on agent loops and "Ralph" made it keep going. With Codex you do not need that trick: you set a goal and it just keeps going.

Figure 4. The delegation loop, the practical core of the video. You give Codex five things, a goal (with a clear definition of done), the sources to work from, a standard to meet, a permission boundary, and a way to prove it finished, then the set-of-goal behavior keeps the agent running through walls until it reaches done rather than stopping at the first plausible draft. Wrapped in an automation, the same loop re-runs on a schedule, which is how the heads-up dashboard refreshes itself.

The first useful Codex loop

His advice for newcomers is to not start by automating your whole life. Pick one loop that is annoying and valuable. He rattles off candidates: turn this transcript into a brief, organize this source folder, build a simple dashboard to track inbound email subscriptions, prepare my day from calendar, email, and Slack, draft three versions of this document and explain the difference, check this package and tell me what is missing. Then give Codex the five things: a goal, sources, a standard, a permission boundary, and the proof that it is done. That is the most basic way to set up a loop. It is not a fancy prompt or a hack, you are just setting up a loop, a real assignment with real sources and a way to check the results.

For people already using Codex, the next level is to hunt for the loops you keep repeating. Every time you find yourself giving the same correction, writing the same setup note, asking for the same kind of review, or checking the same kind of output, ask whether that should become a skill, a standing workflow, an automation, or a memory for Codex. That is the moment it stops being one-off help and starts becoming a system that evolves with you through a series of automated loops.

Boundaries, receipts, and responsible delegation

When he says Codex is blowing his mind, he does not mean he wants agents running around his life without rules, he means the opposite. The more powerful the tool gets, the more the boundaries matter. Do not paste API keys or passwords into the chat, learn to use a .env file, it is not hard and it keeps secrets out of the prompt. Do not give it write access just because read access would be useful. Do not let it send, publish, delete, or spend money unless you truly understand the workflow.

And when it produces something important, make it show the receipts. This is the part of Codex he finds most interesting, not just that it is powerful, but that it is easy to inspect. It will show you the files, the logs, the tests, the renders, and the command output, so you can build a habit of getting proof from your agent. That is what keeps the whole thing from turning into hype and wishful thinking. The tool matters because it lets you hand off more work responsibly, and the skill is learning to do that without getting sloppy.

The new computer literacy

He closes on why he made the video. Codex is changing how he works, and the story is not only for developers. He repeats the refusal: he is not asking you to pick a side in a platform fight between OpenAI and Anthropic, he is asking you to pay attention to what Codex lets you practice and see if it is useful. If you do knowledge work, write, research, manage projects, build documents, run support, plan your life, or spend your day moving between apps, this matters to you.

Codex, he says, is one of the first tools that lets you practice a new kind of computer literacy, the literacy of the future. Not typing, not prompting, but handing work to agents that can truly use the computer and then learning how to check what came back. That is why he built the token dashboard and why he wanted a real deep dive instead of a quick reaction. He points to the practical checklist, examples, and setup notes on his Substack, where there is an active community and a Slack already building with Codex, and he wants the comments to be useful too: if you use Codex, tell him how, if you have a better workflow, show it. The closing note is the same energy he opened with. Computing is changing, Codex is the tip of the spear, and he is excited to see what you build.

Key takeaways

The real story is not that Codex writes code. It is that it makes the computer feel like something you can hand whole jobs to in plain English, so your files, browser, drafts, and screenshots come into range of an agent.
The token number is a receipt, not a target. Jones hit 510 million tokens in a day, and routinely does 300 to 500 million, because the unit of work got bigger, not because he prompts more. Do not chase the number.
We are in the first computing paradigm shift in about 40 years: from application-first, where the human is the router moving between apps, to agent-first, where the human sits above the machine and delegates to agents in a loop.
A thread is the run that owns a job; a subagent is a narrow helper inside it. Separate planning, execution, and checking into threads, and manage it all through a single Chief of Staff thread that holds the durable context.
The power is the setup around the model, not a magic prompt: computer use (see, click, type), tools and connectors, plugins, and especially skills, which turn a one-time correction into compounding, reusable instruction.
The flagship example is a personal heads-up dashboard built from your real sources (email, Slack, WhatsApp) via MCP servers and computer use, refreshed by an automation that runs a saliency analysis every 15 to 30 minutes. You build it for yourself, with your data, no VC required.
The repeatable delegation loop is five things: a goal (with a clear definition of done), sources, a standard, a permission boundary, and proof that it is done. The set-of-goal behavior keeps the agent going until done instead of stopping at the first plausible draft.
Start with one annoying, valuable loop, not your whole life. Then graduate by spotting the corrections and reviews you repeat and turning them into skills, workflows, automations, or memory.
More power demands tighter boundaries. Keep secrets in a .env file, withhold write and spend access unless you understand the workflow, and always make the agent show receipts (files, logs, tests, renders, command output).
The new computer literacy is not typing or prompting. It is handing work to agents that can truly use the computer and then learning how to check what came back.

Chapters

Timestamps are clickable. Click one and the player jumps there and keeps playing while you read.

0:00 Codex makes the computer feel different
3:07 The token dashboard as a work receipt
4:45 The unit of work gets bigger
6:37 A new computing paradigm
8:12 Chief of staff threads
9:44 Threads, goals, and subagents
10:53 Computer use, plugins, and skills
12:04 A heads-up dashboard for work
16:08 The first useful Codex loop
17:09 Boundaries, receipts, and responsible delegation
18:34 The new computer literacy

Notable quotes

Codex is not just giving me better AI answers, it's making my computer feel different. Nate B Jones, 0:08

That is why Codex is blowing my mind. Not because it writes code, but because it makes the computer feel like something I can hand work to. Nate B Jones, 0:44

The number went up because the unit of work fundamentally changed in scale. I stopped asking AI only for answers, and I started asking Codex to carry more of the job. Nate B Jones, 4:09

It's the first change in the computing paradigm in like 40 years. We're moving from a world where humans were the center of the computing paradigm to where humans sit above the computing paradigm and we delegate to agents who run the compute for us. Nate B Jones, 6:45

The problem is that the human becomes the router. You have to remember where everything is. Nate B Jones, 8:25

If I correct Codex once, that's just a chat that I had. If I turn the correction into a skill, into a checklist, into a reusable instruction, the work begins to compound. Nate B Jones, 11:13

Give it a goal, give it sources, give it a standard, give it a permission boundary, and give it the proof that it's done. That's the most basic way to set up a loop. Nate B Jones, 16:52

The more powerful the tool gets, the more important the boundaries get. Nate B Jones, 17:13

Codex is one of the first tools that lets you practice a new kind of computer literacy, the computer literacy of the future. Not typing, not prompting, but handing work to agents that can truly use the computer and then learning how to check what came back. Nate B Jones, 18:52

Resources mentioned

Nate B Jones, the channel (AI News & Strategy Daily), where this deep dive lives.
Codex, OpenAI's agentic tool and the subject of the whole video, including the Codex Max plan he runs his token burn under.
Anthropic and Claude, named as the other side he is explicitly not asking you to take a side against, and as a lab he expects to reach the same place.
The Model Context Protocol (MCP) and MCP servers, how Codex reaches sources like Slack with a server skill rather than browser computer use.
Slack, WhatsApp, and email, the everyday work sources you wire into the heads-up dashboard.
Microsoft Word and Excel, examples of the documents and spreadsheets Codex renders and checks.
Google Chrome and Windows, the dozen tabs and the platform Codex now runs on.
MS-DOS and Netscape Navigator, his touchstones for the last big shift to application-first computing.
The Ralph Wiggum loop, the early 2026 trick for making an agent keep going that Codex's set-of-goal behavior makes unnecessary.
A .env file, his recommended way to keep API keys and secrets out of the prompt.
Nate's Substack newsletter, where the full dashboard readout, the checklist, the examples, and the active building community (and Slack) live.

Where it stands

This is an enthusiasm piece, and Jones flags it himself, he is "obsessed" and "learning in public," so the honest footnotes are about claims versus hopes. The strongest, most durable idea is the delegation loop: a goal, sources, a standard, a permission boundary, and proof of done is a clean, tool-agnostic discipline that works whether or not Codex stays ahead, and the boundaries-and-receipts section is genuinely good security hygiene. The softest material is the framing around the token numbers. A 510 million token day is a vivid receipt, but he is careful to say it is not a target, and it is worth keeping that caveat front of mind, raw token burn is not a measure of value or even of efficiency, and a heavier loop is not automatically a better one. His "first paradigm shift in 40 years" line is a marketing-scale claim, persuasive as narrative, unfalsifiable as history, and the GUI era and the mobile and web eras would each have a claim to the title too. Finally, several specifics rest on his own setup and may shift fast: the exact model name (Codex 5.5), the "set of goal" feature, and which sources expose an MCP server are all moving targets in a tool this new. He is honest that other models will do this soon, which is the right read: the loop is the lasting lesson, the particular vendor is the example of the week.

Full transcript

I'm obsessed with Codex right now, in the way a kid is obsessed with a new PlayStation. I keep wanting to kind of grab people and say, "No, no, no, you have to see what this thing just did." Because Codex is not just giving me better AI answers, it's making my computer feel different. It's my files, it's my browser, it's my folders and drafts and screenshots, and they're all belonging to Codex now, right? It's all of my weird little systems and the stuff I usually have to manually connect all by myself. Codex moves across all of that. And that is why my token dashboard has gotten ridiculous lately. Not because I'm chatting more, but because I'm handing Codex bigger jobs. Before Codex, a lot of my AI work still ended up looking like chat, unless it was code, right? "Draft this, summarize this, clean this up, help me think through this." And it was really useful, but it was still basically me asking for help. And with Codex, I started doing something else. I started giving my computer jobs. Find the transcript, read the folder, compare the versions, render the Word file, check that it opens, open the browser, use the site, keep going until there's something real for me to inspect. And that is why Codex is blowing my mind. Not because it writes code, but because it makes the computer feel like something I can hand work to. My files and drafts are all now in range for Codex. More and more of anything I do on the computer is now work I can hand to an agent in plain English. And this is the part I want to unpack, because I think people are going to bounce off this tool for the wrong reason. This is not a take-a-side video. I am not asking you to join team OpenAI. This is just a deep dive into why Codex works for me, why I'm fired up about it, and what I've learned from using it hard enough that it's actually changed my day. And if you haven't used it because the word Codex sounds like code, that's exactly why you ought to stay with me here. The name is bad, honestly. It sounds like a developer tool. But it's not only a developer tool. Developers are seeing it first because coding has a really clean working environment that made it easy for Codex to engage. It has clean tests and files and diffs and logs and Codex can engage with that. But the habit Codex teaches is much bigger than code. If you write, if you research, if you make documents or Excel spreadsheets, or if you run a tiny business, or if you organize projects, or build side projects, or manage content, or spend your day just switching apps, or even opening a dozen Chrome tabs, the important thing is not that Codex can write software. The important thing is that Codex can help you get all of that work done on the computer you already have and use. And yes, it's for Windows, too, now. So, I'm going to show you how I'm actually using it. I'm going to show you the Chief of Staff thread. I'm going to show you goals, multiple threads, computer use, plugins, skills, drafting several artifacts at once, using websites, checking work, and turning repeated corrections into workflows that I can reuse. And if you're already using Codex, I want to hear what I'm missing. I'm still learning this in public with you. If something I show you helps, or if you have a better way to run it, stick it in the comments. Let's make this a learning thread. This is early enough that the real playbook is still being written by the people who push the tool hard. On May 20th, my local Codex log showed 510 million tokens in one day. And I know that that sounds completely insane. And this is not all of my AI tokens, by the way. This is just under my Codex Max account. I'm not talking about a surprise billing story here. I'm not paying extra for this. The point is that the way I'm using my computer is changing completely. And I think we're sleeping on it, and I want to tell you about it. More of my computer stopped being app-by-app manual work and started running through agents. It is now at the point where most of the work I do on my computer is through agents and Codex. It's not through apps directly. And when I go to apps, I feel like it's a hassle, right? My files, my browser sessions, my documents, my code, my terminal output, all of it is getting routed through Codex. And the number of tokens is not the point. Don't wake up and say, "Well, Nate said burn half a billion tokens." That would be a dumb target. The number matters because it shows that the computer itself is changing. We have been computing for decades using bits and bytes, and now we're moving to tokens. And this is the biggest shift in that, and I can prove it. I mapped my token burn back over a year. It is very clear, behaviorally, that the biggest shift in token burn has been over the last month or so as computer use plus 5.5 in Codex have unlocked a huge amount of my workflows at once. So, when I talk about the token burn, I'm not saying, "Look at this giant number." Half a billion tokens, 800 million tokens, whatever it is. It sounds crazy. If that only meant I was typing more prompts, it would be really embarrassing. But that's not what's happening here. The number went up because the unit of work fundamentally changed in scale. I stopped asking AI only for answers, and I started asking Codex to carry more of the job. Go find the source files, go read the transcript, go make the artifact, go render the document, go check the package, go inspect the browser, go keep working till the goal gets done. And so, the chart reflects that. So, when I say Codex has helped me 10x parts of my workflow, I don't just mean I became 10x smarter. I mean the size of the job I'm willing to hand to the machine changed. So, the chart isn't a scoreboard, it's not there to sort of make a vanity metric out of. It's just a receipt that reflects the way work has changed. So, the first piece here, what is the compute model? What is changing? For most of our lives, computers have been application-first, and that was considered a big deal. I remember back when it was DOS, and the app was a huge revolution in computing, right? Because the app was a unit of work. And I could write a document without writing code in the 1990s when documents became a thing. I could actually open a browser. I remember Netscape Navigator. I could open a spreadsheet and do the work and that was a huge productivity improvement. The human moved between the apps. The human remembered why each app was open. The whole computing experience was built around the human first. I made a TikTok recently where I pointed out that my computer feels like it belongs to Codex as much as to me now because sometimes I can't use it because it's burning literally 100 million tokens an hour and you can hear it hissing in the background. It's burning tokens while I record this and I can't use it because it's literally at max memory capacity but I don't mind that because it's doing 10 things at once for me and I can't do 10 things at once. I just can give out assignments and then I go take a walk and I touch grass and I come back and I've got 10 things done. So we are building the computing paradigm differently now. It's the first change in the computing paradigm in like 40 years. We're moving from a world where humans were the center of the computing paradigm to where humans sit above the computing paradigm and we delegate to agents who run the compute for us. So Codex is a way into the future. I'm not saying Codex is the only answer that will ever get here. I just want to underline that. I am not saying Anthropic won't get here. I know that they will. Primitives like files and source notes and templates and applications themselves, they're all underneath Codex. Codex can drive all of them with agents. You essentially have a state machine in Codex which is a fancy way of saying you have an agent in a loop that remembers what it's doing in Codex that can work the whole computer. Tokens are the cost of letting the agent compute for you and the more of your work that runs through agents, the more your computer activity becomes token activity. And so that is the simplest answer for how I get to a half a billion tokens a day. And by the way, if you're like, oh well, that was an anomaly. No, it's not an anomaly. I'm easily doing 300, 400, 500 million tokens a day these days. And I don't even try that hard. And I feel like I could do more if I wanted to, but the point is not to burn tokens. The point isn't to be wasteful. The point is to make an active layer between your intent and the machine, so the active layer can start to scale for you. The intelligence can scale for you. The first thing that made Codex click for me was this. I stopped treating every thread like a random chat. Most people use AI like a pile of separate conversations. One chat for a draft, one chat for a bug, one chat for a note, one chat for a random question. And the problem is that the human becomes the router. You have to remember where everything is. You have to remember what matters. You have to remember what the next move was. You remember what version was current. You remember what standard the work is supposed to meet. That does not scale very well, because our brains get tired. The better pattern is to create one thread that stays pointed at the work. It knows the goal. It knows the folders. It knows the current artifacts. It knows the standard. And then it can help you spin out smaller jobs without making you re-explain the entire project every time. And that is what I mean by a chief of staff thread. It's not magic memory. You still have to give it sources. You still have to correct it. You still have to make it show receipts. But once you start using Codex this way, it stops feeling like a chatbot and starts feeling like a home base for the work. The next thing that changed my usage was getting more serious about goals and threads. And this sounds really small until you use it on a real project. If I ask a normal chatbot for help, it will often stop when it has produced something that looks like an answer. Codex becomes much more useful when I give it the actual objective. Not help me with this, but more like read these sources, produce this artifact, check it against the standard, and do not stop at the first plausible draft. Keep going. That changes the relationship. Now, I am not asking for a response. I'm just assigning a job out. A thread is not one agent doing every step by itself. Codex can still use sub agents for smaller tasks, but the useful pattern looks bigger, right? A thread is the run that owns the job. And a sub agent is just a smaller helper inside that job. You use it for a narrow piece of work so the main thread does not get buried in noise. So, one thread can plan the goal and that planning thread can use sub agents for discovery and source checking and scouting and reading through messy material. And then when the goal is cleaner, I can send that goal to another thread to execute. The execution thread can own the deliverable, but it can still use sub agents inside the job. One sub agent might scout a site, another might check sources, another might inspect output, another might summarize a noisy folder. The thread owns the job as a whole. The sub agents just handle contained pieces of the job. Once you understand that as a concept, thread mode stops looking like a bunch of chats and starts looking like a way to separate planning and execution and checking the work. And the nice thing is with the Chief of Staff pattern, you can get a lot of this managed just by talking to your Chief of Staff. You don't have to assign out these work to individual agents. That's not how it works anymore. The thing that makes Codex powerful is not one magic prompt. It is the setup around the model. Computer use is literal. It can see a screen, it can click, it can type, it can use an app. Tools that it calls real systems, plugins and connectors let it reach the places where your work already lives. Skills let you teach it a reusable way to do a job instead of explaining the same process every single time. And that last part matters so much. If I correct Codex once, that's just a chat that I had. If I turn the correction into a skill, into a checklist, into a reusable instruction, the work begins to compound. And this is where that code label becomes really misleading. Developers understand this first because they already live in a world where there's tools and files and tests and workflows. That same pattern of work applies now to documents and reports and research and invoices and dashboards and meeting prep and family logistics and customer support. All of it is using code patterns to get better with Codex. If the work lives on your computer, Codex can start to help you get that work done using those patterns it learned from code and you don't have to know code to do it. The sample Codex workflow that I think is big enough that I want to get into with you today is a workflow that essentially provides you a heads-up dashboard for all of your work day. Like imagine a world where instead of buying some SaaS that, you know, has a defined amount of work that says you have to plug into your Slack and you have to plug into your email and this and that and it doesn't produce everything. You can make an exact heads-up display that gives you live alerts of what matters in your workplace that's custom-tuned to your tools. You can do it now. It's not that hard. All you have to do is take the time to go into Codex and tell Codex one, all about the sources that you use to do work. So, the email, the Slack, the WhatsApp messages, the carrier pigeon messages, whatever it is that you use to do work. And then you say, "Those are all my sources." Two, "This is what matters to me. This is how I move the needle in my job." And then have a really honest discussion with Codex about that. And talk about how you refer to some of the sources, maybe all of the sources at different points. What is salient? What matters about the information in these sources? And then, next, you say, "Okay, I want you to design for me a dashboard that is live-updateable based on the sources you can pull from via computer use or maybe via MCP server." Some of them are via MCP server. Slack has an MCP server skill. Some they'll use computer use in the browser, and that's fine. And say, "Design me a dashboard just for me that is my personal heads-up display for work." So, I can look at it, and I can say at any given point, I know what matters in Slack, I know what matters in email, I know what I have to do, I know what my prioritized list is, and I can go and get it. And it's not something that someone built with a seed round and a bunch of VC money. You built it just for you in a way that works for you with your data. And Codex can do that today. And yes, I have the complete readout on that on Substack. You can actually see examples of that over my shoulder here as I'm talking because we went through and we built it. It's really fun. It helps you to understand what a big loop can be. It helps you to understand automations because you can actually start to build an automation that updates this every 15 minutes, every half hour, it's kind of up to you. It will check through all those data sources. It will run the saliency analysis to see what really matters. It will come back and say, "This is what I think matters. This is how I rejig the priority, and this is what I want to emphasize as really important for work." It becomes your headquarters for work every day, and you custom built it. Isn't that cool? I think that's really cool. That's an example of an open loop you can build. That has never been something that we could make before. That wasn't something we could make even two or three months ago because as cool as the models were and as much as we're into the long-running agentic revolution, we didn't have the computer availability, and we did not have the computer use availability to get that unlocked. And so, I picked this because it shows something that only Codex could do today. I'm sure other models will come along and do it soon. And Codex will go and do that work, especially if you use the set of gold feature. The set of gold feature is really handy because it basically zeros in Codex on the gold you define, and it will just run through walls until it gets to that done state. And I love that because I want to have agents that don't stop early. Remember when we talked about the Ralph Wiggum loop and it was like January and February and we were all excited because Claude was stopping on agent loops, but Ralph made Claude keep going. You don't need to do that with Codex. You set a goal and it just keeps going. It's great. If you're new to Codex, do not begin by trying to automate your whole life. Just pick one loop that is annoying and valuable. Something like turn this transcript into a brief, organize this source folder, build me a simple dashboard to track my inbound email subscriptions, whatever it is. Prepare my day from calendar, email, and Slack. Draft three versions of this document and explain the difference. Check this package, tell me what's missing. I can give you a bunch more, right? Then give Codex five things. Give it a goal, give it sources, give it a standard, give it a permission boundary, and give it the proof that it's done. That's the most basic way to set up a loop. It's not a fancy prompt. It's not a hack. You're just setting a loop up. A real assignment with real sources and a way to check the results. And if you're already using Codex, this is the level you go to next. Look for the loops you keep repeating. Every time you find yourself giving the same correction or writing the same setup note or asking for the same kind of review or checking the same kind of output, then ask whether that should become a skill. Ask whether it should become a standing workflow, an automation. Ask whether it should become a memory for Codex. And that is when it stops being one-off help and starts becoming something where Codex is evolving with you to accomplish the work you want done through a series of automated loops. When I say Codex is blowing my mind, I do not mean I want agents running around my life without rules. I mean the opposite. The more powerful the tool gets, the more important the boundaries get. Don't paste API keys or passwords into the chat, right? Learn to use a .env file. It's not hard and it keeps secrets out of the prompt. That's just one example, right? Or don't give it write access just because read access would be useful. Don't let it send and publish and delete or spend money unless you really understand the workflow. And when it produces something important, make it show the receipts. This is why Codex is interesting to me. It's not just that it's powerful, it's that it's very easy to inspect the work. It will show you the files and the logs and the tests and the renders and the command output and you can build a habit of getting proof from your agent around it. And that's what keeps this from turning into a bunch of hype and wishful thinking. The tool matters because it lets you hand off more work responsibly. And the skill is learning to do that without getting sloppy. The reason I wanted to make this video is simple. Codex is changing how I work and I don't think the story is only for developers. Look, I'm not asking you to pick a side in a platform fight between OpenAI and Anthropic. I'm saying just pay attention to what Codex lets you practice and see if it's useful. If you do knowledge work, if you write, if you research, if you manage projects, if you build documents, if you run support, when you plan your life, or when you spend your day moving between apps, this app matters to you. This app will make a difference for you. Codex is one of the first tools that lets you practice a new kind of computer literacy, the computer literacy of the future. Not typing, not prompting, but handing work to agents that can truly use the computer and then learning how to check what came back. That's why I built the token dashboard. That's why I'm using this thing so much. That's why I wanted this to be a real deep dive instead of a quick reaction. If you want the checklist and the examples and the setup notes, I put the practical version of all of this to get started on the Substack. And there's an active community there that's already building with Codex that you can check into. We have a whole Slack, it's amazing. But I also want the comment section to be useful here. If you're using Codex, tell me how. If you have a better workflow, I want to see it. If one of these tricks helps, tell me which one. This is still early enough that people who use the tool hard are learning from each other in public, and I want you guys to be the cool kids. Show me you're the cool kids, and show me what you're building. This is why it feels exciting. This is a moment when computing is changing, and Codex is at the forefront of that. Codex is the tip of the spear on that. So, show me what you're building in the comments. I'll see you next time. I'm so excited to see what you're building with Codex.