Author: jason (@jxnlco
Original:
jason
@jxnlco
·
Article
Getting the most out of Codex
Most developers first use coding agents for code: inspect a repository, make a diff, run tests, and open a pull request.
That’s still the center of gravity for Codex. But much of the work on a...
38
187
1.5K
Most developers, when they first encounter AI agents for code editing, usually only have them do one thing: write code. For example, checking a repository, generating a diff, running tests, and then submitting a pull request.
Writing code indeed remains the core strength of Codex. But if you think about it, most of the work we do on a computer is essentially related to code: executing terminal commands, browsing the web, calling APIs, exporting documents, responding to various events, or triggering automation processes. When Codex begins to extend into these areas, it no longer feels like just a narrow "programming assistant," but evolves into an "all-around worker" that can help you handle all kinds of computer tasks.
New features of Codex make this transformation tangible. Current threads can remember your context, call various tools, display generated artifacts, and transition seamlessly between different prompts, so you no longer have to "re-introduce" yourself every time you finish a chat.
To completely squeeze out the potential of Codex, you need to combine these expert moves:
- Durable threads that can preserve memory long-term
- Flexible use of voice input, task steering, and task queuing while you maintain control
- Extending Codex's reach beyond the codebase using browsers, computer-use, Model Context Protocol (MCP) servers (a universal standard for AI to safely connect to local data and tools), and various connectors
- Letting it continue working while you are away from your computer using thread automations and Goals
- Proficient use of the side panel to review generated code, documents, slides, and other files at any time
Durable threads
Durable threads: Long-running Codex threads that maintain your work context throughout multiple uses.
Pinning threads is a great way to keep these durable conversations available at a moment's notice. This is a godsend for workflows that need to be advanced repeatedly, such as:
- A dedicated "Chief of Staff" thread (helping you handle daily chores)
- A thread specifically for product launches
- A thread for reviewing documentation
- A monitoring thread focused on external data
These are not "chat and burn" chat boxes; they are persistent workspaces. Over time, Codex can return to these conversations at any time, remembering your previous decisions, personal preferences, and current progress. Without this feature, you would have to feed it all this background information from scratch every time.
Pinning shortcuts makes this extremely practical. By pressing Command-1 through Command-9, you can instantly jump back into these saved dedicated threads to continue working.
Voice input
Voice input is useful because it captures the most primitive, raw thoughts in your head before you have to carefully craft them into text.
Codex has built-in voice input. This is particularly effective for those vague ideas that are "easy to say but a pain to type." For example:
"I remember someone named Ben mentioned this on Slack.
I forgot the details.
Go find it for me."
For an AI agent that can search, gather context, and report back to you on its own, these few sentences are enough for it to get to work.
When you have a general idea in your head that isn't fully formed yet, spending two or three minutes "muttering" at it and dumping your thoughts all at once also works surprisingly well.
Recording transcription follows the same logic. An unpolished meeting record or a dictated draft plan is often more valuable than a brief summary. Because those raw records preserve your hesitant tone, emphasized points, and those unfinished flashes of inspiration.
Steering and queuing
When you combine voice input with direct control over running tasks, its power truly manifests.
When a task is executing, if you want to:
Task Steering: Interrupt Codex mid-task before it's finished and give it a new direction.
This comes in handy when you find the AI is going off track and need to correct it before it hits a wall. For example, while having it review a website, you can point things out in the side panel while directly interrupting its work:
- "Make this a bit smaller"
- "The spacing between these two elements doesn't look right"
- "This copy is written incorrectly"
Task Queuing: Assign Codex the next task after it completes the current step.
Task queuing is different. It doesn't interrupt the ongoing task but places the new task at the end of the line. You can tell it:
"After this job is done, send the preview link to the reviewer on Slack."
Simply put, "steering" is changing what Codex is doing right now, while "queuing" is arranging what it should do next. Both features allow you to maintain a sense of "human-machine unity" control throughout task execution.
Tools and reach
Once a thread has continuous memory, the next question is: what can it touch? Codex's tentacles can extend outward layer by layer:
- $browser: An in-app browser running in the side panel where Codex can review and mark up web pages.
- @chrome: Can access your browser's login state to handle Chrome-based workflows.
- @computer: Specifically for tasks that can only be completed through a desktop graphical user interface (GUI).
$browser is suitable for web reviews in the side panel; @chrome is for in-browser work requiring your account login; and @computer is used for tasks that require clicking around on the computer desktop.
MCP servers and various connectors extend this capability further into your entire workflow. Slack integration, as well as various MCP tool connectors and MCP guides, are important because many critical tasks often start as a chat message, an email in an inbox, or a scheduling issue before they ever become code.
Skills allow repetitive workflows to be reused. Once a workflow is proven useful, you can solidify it as a skill so Codex can run it directly next time without having to relearn the process from scratch.
Work from anywhere
The concept of working with Codex from anywhere completely breaks the traditional limitation that we "must sit in front of a computer to work." A task can start on your Mac filled with files, permissions, and local environments, and then continue to progress silently when you leave your desk and check it on your phone.
This is very useful during fragmented time. You can have Codex run a long task on your computer and then leave your desk to grab a coffee. If it has a question while you're out, you can reply directly via phone, approve its next move, or give it a new direction before returning to your seat. Your local environment stays there working quietly while you move freely.
Automations
Automation features allow Codex to work automatically according to a schedule you set. For tasks that need to start from scratch every day, like generating daily reports or routine codebase checks, use "scheduled automation." But if you need to advance work within a conversation that has historical memory, use "thread automation."
Thread Automation: Like a timed "heartbeat" mechanism that periodically returns to the same Codex thread to continue working according to a set schedule.
Pinning threads is useful, but it still requires you to actively go back to it. "Thread automation," on the other hand, can check in every few minutes or hours on its own until a certain condition is met, and can even adjust the check-in frequency based on the situation.
For example, your "Chief of Staff" thread can run every 30 minutes:
Every 30 minutes, check my Slack and Gmail for any messages that need processing but haven't been replied to.
Help me prioritize them.
If someone asks me a question, research it as deeply as possible and help me draft a reply, but don't send it directly.
When you return to your computer, the most time-consuming "background gathering" work is often already done. As a human, you only need to make the final decision to send it out.
Thread automation is also perfect for handling "feedback loops." It can silently watch your comments in PRs, Google Docs, or Slack, and automatically advance follow-up modifications while you're away.
Imagine an animation production scenario: a reviewer posts a video on Slack. Thread automation can periodically check the discussion progress; as soon as modification suggestions come in, it automatically renders a new version, then @mentions the reviewer in the original thread and replies with the new video. If a software integration interface can't automatically complete the final upload, it can even mobilize "desktop automation" to finish the last step via the GUI.
This complete closed loop spans Slack for receiving feedback, the codebase for rendering, and desktop automation tools for the final upload.
Goals
When a task has a clear finish line and the AI agent can continuously work toward that end, the power of Goals truly explodes.
Goals: Longer-running Codex tasks with a clear finish line that the AI will continue to sprint toward over a period of time.
A bad goal is set like this:
Implement the plan in this Markdown file.
A good goal must have a measurable success criterion.
For example, an engineer wanting to migrate an internal tool from Python to Rust can set up the new directory, set the goal, and draw a clear finish line:
This new version's development is only complete once all unit tests pass.
Goal setting is essentially combining "continuous execution" with a "verifier." You, as the human, define the desired outcome, the conditions for when to stop, and the signals used to judge if Codex is getting closer to the finish line.
Useful verifiers include:
- A complete set of test cases
- A benchmark performance test
- A consistently reproducible bug
- A verification matrix
- An end-to-end workflow that must always pass
Ambition is important, but ambition without a verification mechanism is just wishing.
The side panel
The side panel feature keeps your generated work results right next to your chat window. You no longer have to export files and painfully switch between different software; you can review them right in place. The generated results might be code, but they could also be slides, PDFs, web pages, spreadsheets, or anything else generated.
It is particularly good at handling four types of work:
- Inspecting generated artifacts
- Annotating areas that need modification
- Operating web interfaces
- Reviewing changes to code or files
The side panel allows users to view Markdown documents, spreadsheets, data tables, plain documents, and slides directly in place. You can inspect, annotate, and modify files without interrupting your existing workflow.
Your slides or PDFs stay open right next to the dialog box, waiting for your review and modification at any time.
The in-app browser allows Codex to directly inspect rendered web pages, control them, and even respond directly to annotations you make on the page. Comments on web pages or files all stay within this work loop, no longer needing to be split into separate hand-off tasks as before.
The web page becomes both its output result and a control panel you can manipulate. Codex can build a page, open it in the side panel, inspect it itself, fix bugs, and then continuously iterate and optimize the same thing in place.
The following scenarios are especially effective with the side panel:
- Using a single index.html for lightweight static displays
- Running Storybook to review UI components
- Using Remotion Studio for code-generated animations
- Slide presentations shown in the browser
- Data apps for data analysis flows
A simple index.html file can turn into a fun interactive app without even setting up a server. Moreover, thread automation can quietly update these static files over time, so when you return, the latest progress is always waiting for you.
Shared memory
When those long-running threads can break the boundaries of a single chat and share memory, their utility takes a qualitative leap.
Shared memory: Persistent context stored outside a single conversation, allowing future work to proceed based on clear, traceable information.
A relatively safe approach is to "anchor" these persistent threads in an Obsidian vault. Simply put, create a folder for storing plain text files. It's straightforward, convenient for you to view, modify, and move at any time, and it lasts a long time. Teams can put this folder in any cloud drive they like, such as Git, Dropbox, Google Drive, or other sync tools.
Your vault might look like this:
[text]
vault/
├── TODO.md
├── people/
├── projects/
├── agent/
└── notes/
In the root directory, you can place an AGENTS.md file. Here, you can set rules for Codex: how it should update this vault when it learns new things about people, projects, decisions, and to-dos.
Don't blindly copy a specific vault structure. What you need to do is "teach" your AI agent: where persistent context should go, which context needs to be kept, and when not to mess around with files.
A practical AGENTS.md guide might say:
- Treat ~/vault as your long-term working memory area.
- Try to keep notes organized; don't let fragmented records get everywhere.
- Accurately categorize to-dos, people, projects, daily summaries, and drafts.
- Properly save decisions made, blockers encountered, owners, dates, and useful links.
- If there is no substantial new progress, do not randomly modify files in the vault.
Codebases are for storing code. This vault is for storing rolling context: who is involved, what was changed, where things are stuck, who follows up next, and those details that would completely disappear if cut off between two chats.
Important context should never be locked solely within the text records of a single chat. Write them down and put them where the next thread can pick them up immediately.
Codex itself also provides official memory features in Settings > Personalization > Memory. They are like built-in local notepads used to remember your personal preferences, common workflows, and frequently encountered pitfalls. However, this feature is meant to supplement the context you clearly write down, not replace it. The Chronicle memory component follows the same logic, helping Codex extract and build memory from what has recently happened on your screen.
From code outward
Although Codex started with writing code as its main trade, now many peripheral tasks surrounding code can be handled within this same system: whether it's MCP servers, web interfaces, desktop control, thread automation, or files that can be reviewed directly in the side panel.
This completely changes how we control it. "Task steering" can interrupt its actions mid-way; "task queuing" can help it arrange the next steps; "thread automation" allows the system to keep running when you're not there; and "goal setting" draws a clear finish line, letting Codex know where to keep sprinting.
Today's Codex can already carry a complete workflow: from hearing instructions and executing tasks to the final review of files. Even if these tasks have long since exceeded the scope of the codebase, it still handles them with ease.
