OpenAI Codex Hidden Features: 9 Commands Most Users Have Never Tried
From /goal multi-hour agentic loops to /pet desktop companions, Codex has a full command system most users never discover. Here's the complete list.
Codex Has 9 Slash Commands Most Users Have Never Touched
OpenAI quietly shipped a full command system inside Codex, and the most important one — /goal, which can run an agentic loop for multiple hours or even days via a TOML file edit — is buried behind an early-access flag most users never find. That’s not a footnote. That’s the whole product.
Here are nine commands and features that change how Codex actually works. Most users are running the app without knowing any of them exist.
/goal — The Multi-Hour Agentic Loop Nobody Told You About
This is the one that matters most, so it goes first.
Type /goal in a Codex chat and you activate what the team calls a “Ralph loop” — an agentic execution mode that can run for multiple hours or, reportedly, up to days. It doesn’t stop to ask for permission. It doesn’t pause for confirmation. It just works through the goal until it’s done or hits a hard wall.
The catch: it’s not on by default. You have to edit the TOML config file to enable it. That makes it an undocumented power-user feature — the kind of thing you only find if you’re already deep enough in the tool to go looking.
Alex Finn used /goal over the course of an hour to build a complete extraction shooter video game from scratch. Not a prototype. A playable game with auto-generated assets — because if you enable the image generation skill before running /goal, Codex will generate all the visual assets autonomously as part of the loop. The gameplay footage speaks for itself: top-down shooter, surprisingly coherent art style, functional mechanics.
That’s the real argument for /goal. It’s not a chat. It’s a job you hand off.
agents.md — The File Codex Reads Before Every Chat
If you’re coming from Claude Code, you know CLAUDE.md. Codex has the same concept under a different name: agents.md.
Every time you open a new chat inside a project, Codex reads this file first. It’s your project’s onboarding doc — who you are, what the project is, what the end goal looks like, what Codex should already know before you type a single word.
The practical move: after your first session in a new project, have Codex write the agents.md for you based on what you just discussed. It’ll pull the relevant context and structure it properly. From that point forward, every new chat starts informed instead of blank.
One warning: don’t let this file grow indefinitely. Every token in agents.md is a token consumed at the start of every chat. Keep it tight. The goal is orientation, not documentation.
Plan Mode — Brainstorm Without Executing
There’s a toggle in the Codex interface called Plan Mode. When it’s on, Codex will brainstorm, ask clarifying questions, and lay out an approach — but it won’t touch a single file or run a single command.
This is not a minor UX detail. It’s the difference between an agent that acts and an agent that thinks.
The right workflow: start every significant build in Plan Mode. Let Codex ask its questions. Iterate on the plan until you’re aligned. Then switch Plan Mode off and let it execute. You’ll catch misunderstandings before they become code you have to undo.
The common mistake is skipping this step because you’re impatient. Don’t. The planning phase is where you spend 5 minutes to save 45.
Full Access vs. Default Permissions — Stop Babysitting Your Agent
By default, Codex pauses and asks for approval before doing anything consequential: running a script, accessing the network, writing to a file. This is the right default for new users. It’s the wrong default once you know what you’re doing.
Go to Settings → General → Auto Review or Full Access. Switch it to Full Access and Codex stops asking. It just does the work.
Yes, there are horror stories about agents deleting databases. Those stories almost always trace back to vague instructions, not autonomous permissions. If your agents.md is clear and your plan is solid, Full Access is a productivity multiplier, not a liability.
Keep Default Permissions while you’re learning the tool. Switch to Full Access once you trust your own prompting.
The Skills System — Reusable Recipes Stored as Markdown
A skill in Codex is a markdown file that tells the agent how to do something consistently. Store them globally in ~/.codex/skills/ and they’re available across every project. Store them locally in the project directory and they’re scoped to that project only.
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
The slash commands you see in chat — /browser-use, /image-gen, /pdf, /skill-creator — are all skills. You can build your own and call them the same way.
The workflow that actually works: build something once, get an output you like, then tell Codex to reverse-engineer a skill from what it just did. It’ll write the markdown instruction file, store it in the right place, and from that point forward you can call it by name. The skill gets better every time you use it and give feedback.
This is also where the comparison to Claude Code’s built-in command system becomes interesting. Both tools have a slash-command layer, but Codex’s skills system is more explicitly user-extensible — you’re writing the recipes yourself, not waiting for the platform to ship them.
The Automations Tab — Scheduled Tasks That Run While You Sleep
The Automations tab in Codex lets you set up scheduled chats: hourly, daily, weekly. You write a prompt, set a schedule, and Codex injects that prompt into a new chat inside your project at the specified time.
The practical example: set up a weekly automation that runs your YouTube comment analysis skill every Sunday at 5 PM, updates the Excel output, and pushes the changes to GitHub so Vercel auto-deploys the updated dashboard. You configure it once. It runs without you.
The important caveat: this is a local cron. If you close the Codex app or shut down your machine, the automation stops. For truly 24/7 operation, you need the process running on a server somewhere. That’s a real limitation, and it’s worth knowing before you build something that depends on it.
The automation prompt itself is editable — you can see exactly what gets injected into each scheduled chat, and you can modify it. Treat early automations like training wheels. Watch the first few runs. Correct the mistakes. Then let it go.
The Context Window Bar — Your Session Budget, Visible
At the bottom of every Codex chat, there’s a bar showing how much of your context window is currently used. It resets every 5 hours, with a weekly reset as well.
Codex’s context window is approximately 256,000 tokens. Claude Code with Opus sits around 1 million. That’s a real gap on paper. In practice, GPT 5.5 is significantly more token-efficient than Opus, which means sessions in Codex tend to last longer than the raw numbers suggest for equivalent work. The bar at the bottom is your real-time read on where you stand.
Codex auto-compacts context the same way Claude Code does, so you’re not going to hit a hard wall without warning. But context management still matters. The model intelligence setting compounds this: Extra High costs significantly more of your session budget than Medium. Use Extra High for hard bugs. Use Medium for planning and routine builds.
For more on how these two tools compare on the token efficiency question, the Codex vs. Claude Code context window comparison is worth reading alongside this.
/personality — Pragmatic Mode Is the One You Actually Want
Type /personality in any Codex chat and you get two options: Friendly or Pragmatic.
Built like a system. Not vibe-coded.
Remy manages the project — every layer architected, not stitched together at the last second.
Pragmatic means concise, task-focused, and direct. No preamble. No “Great question!” No padding. Just the answer and the next step.
This should probably be the default for anyone using Codex as a development tool. The Friendly mode is fine for onboarding. Pragmatic is what you want when you’re in the middle of a build and you need the agent to just do the thing.
You can also access this through the side chat — the “Open side chat” button opens a parallel conversation within the same project context, useful for asking questions without interrupting an active build session. Set personality there and it persists.
Browser Use — Visual QA That Actually Finds Bugs
The /browser-use skill opens an in-app browser and gives Codex control of the mouse. It can navigate, click buttons, fill forms, and document what it finds.
This isn’t just a demo feature. In a real test on a freshly built dashboard, Codex’s browser use found six actual bugs without any human prompting: broken YouTube external links that weren’t opening new tabs correctly, an empty explorer state that was too bare, search that was too literal, and several other UI issues. Six bugs in one automated pass on a brand-new app.
The right way to use this: build it into your skills. Tell Codex that before it ever presents you with a finished build, it must run a browser use pass and fix what it finds. You stop getting half-finished deliverables. The QA loop becomes part of the build loop.
This is also where the agentic workflow patterns start to compound. If you’re thinking about how to structure longer autonomous runs, Claude Code’s agentic workflow patterns covers the underlying logic well — the patterns translate directly to Codex even though the tooling differs.
/pet and /hatch — The Feature That’s More Useful Than It Looks
Yes, /pet shows a desktop companion. Yes, /hatch lets you customize it using image generation. Yes, it’s a little silly.
But the pet lives at the bottom of your screen at all times, even when you’re in a different application. It shows you what Codex is currently working on. It gives you a visual indicator when a session needs attention. When you’re running a long build and you’ve switched to something else, the pet is your peripheral monitor.
Hunter built petdecks.com — a public gallery to discover, share, and install Codex pets. That’s a community forming around what looks like a gimmick. The gimmick has a real function: it makes a background agent legible without requiring you to context-switch back into the app.
The Rate Limits Screen — Know Before You Hit the Wall
Settings → Rate Limits Remaining shows you exactly what percentage of your session budget is left and when it expires. Both the 5-hour rolling window and the weekly window are visible.
Seven tools to build an app. Or just Remy.
Editor, preview, AI agents, deploy — all in one tab. Nothing to install.
This matters more than it sounds. If you’re about to kick off a long /goal run or a complex build, you want to know whether you have 97% remaining or 12%. Running out of session mid-build is worse than not starting — you end up with half-finished code and a context that’s been compacted into something the next session can’t fully reconstruct.
Check this before any significant session. It takes three seconds.
The Bigger Picture
Nine features. Most of them invisible unless you go looking.
The /goal command is the one that changes the category. Everything else — skills, automations, browser use, the context bar — is infrastructure for working smarter within a session. /goal is infrastructure for working across sessions, across hours, across days. That’s a different kind of tool.
The pattern here is familiar to anyone who’s spent time with Claude Code’s hidden features: the surface-level interface undersells what the tool can actually do. The defaults are conservative. The power is opt-in. You have to go find it.
When you’re thinking about where this kind of agentic capability fits into a broader workflow — connecting to external services, chaining multiple models, running automations that touch business tools — platforms like MindStudio handle that orchestration layer: 200+ models, 1,000+ integrations, and a visual builder for composing agents and workflows without writing the plumbing yourself.
And if the end goal is a production app rather than a script or a dashboard, the abstraction question becomes relevant. Remy takes a different approach to that problem: you write a spec — annotated markdown — and it compiles a complete full-stack application from it. TypeScript backend, SQLite database, auth, deployment. The spec is the source of truth; the code is derived output. Different tool, different layer, same direction of travel.
Codex’s hidden command system is worth learning in full. The users who find /goal are building things the users who don’t find it aren’t building. That gap will widen.
