From the Codex Official Team: How to Get the Most Out of Codex

Author: jason (@jxnlco) Original:

jason@jxnlco·13h 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… 2411 31K 83K

Most developers, when first using coding AI agents, typically have them do just one thing: write code. For example, inspect a codebase, generate a diff, run tests, and then open a pull request.

Writing code is still Codex’s core strength. But if you think about it, most of the work we do on a computer is essentially code-related: running terminal commands, browsing the web, calling APIs, exporting documents, responding to various events, or triggering automation workflows. When Codex begins to extend into these areas, it no longer feels like a narrow “coding assistant” but evolves into a “universal worker” that can handle all sorts of computer tasks.

Codex’s new features make this shift tangible. Current threads can remember your context, call various tools, display generated artifacts, and seamlessly transition between different prompts—no more having to “reintroduce yourself” every time you finish a conversation.

To fully unlock Codex’s potential, you need to combine the following tips:

• Durable threads that retain long-term memory
• Flexible use of voice input, steering, and queuing while you’re in control
• Extending Codex’s reach beyond the codebase with the browser, computer-use, MCP servers (a universal standard for AI to safely connect local data and tools), and various connectors
• Using thread automations and Goals to keep it working when you step away from the computer
• Mastering the side panel to review generated code, documents, slides, and other files at any time

Durable Threads

Durable threads: Long-running Codex conversations that retain work context across your multiple sessions.

“Pinning threads” is a great way to keep these persistent conversations at your fingertips. This is a godsend for workflows that need to be pushed forward repeatedly, such as:

• A dedicated “chief of staff” thread (handling daily chores)
• A product release thread
• A documentation review thread
• A monitoring thread that keeps an eye on external data

They are not ephemeral chat boxes; they are durable workspaces. Over time, Codex can return to these threads at any time, remembering your past decisions, personal preferences, and current progress. Without this feature, you’d have to feed this background information from scratch every time.

Pinning shortcuts make this incredibly practical. Just press Command-1 through Command-9, and you can instantly jump back into these saved dedicated threads to continue working.

Voice Input

Voice input works well because it captures the raw, rough ideas in your head before you have to carefully type them into text.

Codex has built-in voice input. It’s especially useful for vague ideas that are “easier said than typed.” For example:

“I remember someone named Ben mentioned this on Slack. I forget the details. Go find it for me.”

For an AI agent that can search, gather context, and report back to you, these few words are enough to get it working.

When you have a rough idea but haven’t fully formed it, spending two or three minutes “mumbling” your thoughts into it works surprisingly well.

Transcription of recordings is similar. An unpolished meeting minutes or a dictated draft plan is often more valuable than a brief summary. Because those rough recordings retain your hesitations, emphasis, and those moments of inspiration that haven’t been fully articulated.

Steering and Queuing

The true power of voice input becomes evident when combined with direct control over running tasks.

While a task is executing, if you want to

Steering: Interrupt Codex mid-task and give it a new direction.

This comes in handy when you see the AI going off course and need to correct it before it hits a dead end. For example, while having it review a website, you can point things out in the side panel and directly interrupt its work by speaking:

• “Make this a bit smaller”
• “The spacing between these two elements looks off”
• “This copy is wrong”

Queuing: Assign Codex its next tasks after it completes the current step.

Queuing is different. It doesn’t interrupt the ongoing task but lines up new tasks behind it. You can say something like:

“After this job is done, send the preview link to Slack for the reviewer.”

In short, “steering” changes what Codex is doing right now, while “queuing” arranges what it should do next. Both features give you a sense of “human-machine synergy” and control during task execution.

Tools and Reach

Once a thread has continuous memory, the next question is: what can it reach? Codex’s reach extends outward layer by layer:

• $browser: In-app browser in the side panel, where Codex can review web pages and annotate them.
• @chrome: Accesses your browser’s login state to handle Chrome-based workflows.
• @computer: Handles tasks that can only be done through the desktop GUI.

$browser is for reviewing web pages in the side panel; @chrome is for browser work that requires your logged-in state; and @computer is for tasks that require clicking around on the desktop.

MCP servers and various connectors extend this ability throughout your entire workflow. The Slack integration, various MCP tool connectors, and MCP guides are important because many critical tasks start as a chat message, an email in your inbox, or a scheduling issue before they become code.

Skills make repeatable workflows reusable. Once a workflow proves useful, you can solidify it into a skill so that Codex can run it directly next time without having to relearn the entire process.

Work from Anywhere

The concept of working with Codex from anywhere completely breaks the traditional limitation of “having to sit at a computer to work.” A task can be started on your Mac, loaded with files, permissions, and local environment, and continue silently when you leave your desk and check in from your phone.

This is incredibly useful in fragmented time. You can have Codex run a long task on your computer and then step away to grab coffee. If it has questions while you’re out, you can reply from your phone, approve its next steps, or assign new directions before returning to your seat. Your local environment quietly works away, while you are free to move around.

Automations

Automation features allow Codex to work automatically according to a schedule you set. For tasks that need to start from scratch daily, such as generating daily reports or routine codebase checks, use “scheduled automation.” But if you need to continue work within a thread that has historical memory, use “thread automation.”

Thread automation: Like a scheduled “heartbeat” mechanism that periodically returns to the same Codex thread to continue working according to a schedule.

Pinning a thread is useful, but it still requires you to go back to it actively. Thread automation, on the other hand, can check in every few minutes or hours, keep running until a condition is met, and 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 unprocessed messages that need attention. Prioritize them for me. If someone asks me a question, research thoroughly as much as possible, then draft a reply, but don’t send it directly.

When you return to your computer, the most time-consuming “background context gathering” work is often already done. As a human, you only need to make the final call to send.

Thread automation is also perfect for handling “feedback loops.” It can silently watch your comments on code merge requests, Google Docs, or Slack, and automatically push forward subsequent modifications while you’re away.

Imagine an animation production scenario: a reviewer posts a video in Slack. Thread automation can periodically check the discussion progress. Once a revision comment comes in, it automatically renders a new version, then @replies the reviewer in the original post with the new video. If a software’s integration API can’t automatically complete the final upload, it can even call “desktop automation” to click through the GUI for the final step.

This complete loop spans Slack for receiving feedback, the codebase for rendering, and desktop automation for the final upload.

Goals

When a task has a clear finish line and the AI agent can continuously strive toward that goal, the power of Goals truly explodes.

Goal: A longer-running Codex task with a clear finish line, where the AI works persistently toward it over 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 wants to migrate an internal tool from Python to Rust. They can set up a new directory, define the goal, and draw a clear finish line:

The development of this new version is not complete until all unit tests pass.

Goal setting, in essence, combines “continuous execution” with a “verifier.” You, as the human, define the desired outcome, the stopping condition, and the signals that indicate whether Codex is getting closer to the finish line.

Good verifiers include:

• A complete set of test cases
• A baseline performance benchmark
• A reproducible bug
• A validation matrix
• An end-to-end workflow that must always pass

Ambition is important, but ambition without a verification mechanism is just wishful thinking.

The Side Panel

The side panel feature keeps your generated work products side by side with your chat window. You no longer have to export files and painfully switch between different applications; you can review them right in place. The generated output could be code, but also slides, PDFs, web pages, spreadsheets, or anything else generated.

It excels at four types of work:

• Reviewing generated artifacts
• Annotating areas that need modification
• Interacting with web interfaces
• Reviewing code or file changes

The side panel allows users to view Markdown documents, spreadsheets, data tables, regular documents, and slides directly in place. You can review, annotate, and modify files without interrupting the existing workflow.

Your slides or PDF sit open next to the dialog, ready for your inspection and modification.

The in-app browser lets Codex directly inspect rendered web pages, control them, and even respond to annotations you make on the page. Comments on web pages or files stay within this closed workflow, no longer requiring you to break them out into separate handoff tasks.

The web becomes both its output and a control panel you can manipulate. Codex can build a page, open it in the side panel, inspect it, fix bugs, and then iterate and optimize the same thing in place.

The following scenarios work especially well with the side panel:

• Lightweight static displays using a single index.html
• Running Storybook to review UI components
• Code-generated animations with Remotion Studio
• Slide presentations in the browser
• Data apps for data analysis workflows

A simple index.html file can become a fun interactive mini-application without needing a server. Moreover, thread automation can silently update these static files over time, so when you come back, you always see the latest progress.

Shared Memory

When long-running threads can break free of a single conversation’s boundaries and share memory, their role leaps in quality.

Shared memory: Persistent context stored outside a single conversation, allowing future work to proceed based on explicit, traceable information.

A relatively robust approach is to “anchor” these persistent threads in an Obsidian vault. In simple terms, create a folder of plain text files. It’s straightforward, easy to view, modify, move, and long-lasting. Teams can put this folder in any cloud storage they like, such as Git, Dropbox, Google Drive, or other syncing tools.

Your vault might look like this:

[text] vault/ ├── TODO.md ├── people/ ├── projects/ ├── agent/ └── notes/

At the top level, you can put an AGENTS.md file. Here, you can set rules for Codex: how it should update the vault when it learns new things about people, projects, decisions, and to-do items.

Don’t rigidly copy a particular vault structure. What you need to do is “teach” your AI agent where persistent context should go, what context to keep, and when not to mess with files.

A practical AGENTS.md guide might say:

• Treat ~/vault as your long-term working memory.
• Keep notes organized; avoid creating fragmented records everywhere.
• Accurately categorize to-dos, people, projects, daily summaries, and drafts.
• Preserve decisions made, blockers encountered, responsible persons, dates, and useful links.
• Do not modify files in the vault without substantial new progress.

The codebase stores code. This vault stores the rolling context: who is involved, what changed, what is blocked, who follows up next, and the details that would disappear if lost between two conversations.

Important context should never be locked solely in a single chat transcript. Write it down, where the next thread can immediately pick it up.

Codex itself also offers official memory in Settings > Personalization > Memory. They’re like built-in local notepads for remembering your 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 works similarly, helping Codex extract and build memory from what’s recently appeared on your screen.

From Code Outward

Although Codex still starts with code as its core business, many peripheral tasks around code can now 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. “Steering” can interrupt its actions mid-stream; “queuing” can arrange its next steps; “thread automation” keeps the system running when you’re not present; and “Goals” draw a clear finish line, telling Codex to keep charging toward it.

Today’s Codex can already shoulder a complete workflow: from listening to instructions, executing tasks, all the way to final file review. Even when these tasks have long extended beyond the codebase, it remains capable.