Codex | AI Assistant Documentation

The Codex agent has arrived in JetBrains, effectively killing the need to hop between terminal-based workflows and IDE-native context. By moving the agent directly into your editor, you’re gaining persistent project awareness and standardized MCP support that finally makes AI-driven development feel like part of the IDE rather than a bolted-on chat window.

If you’ve been living in a graveyard of terminal tabs trying to keep track of concurrent AI tasks, this is the shift you’ve been waiting for. Codex isn't just another LLM wrapper; it’s a deep integration that understands your project structure, respects your file system, and allows for structured task management without forcing you to copy-paste between a browser and your IDE.

IDE Context is the New Baseline

Codex stops the "did the AI see the file?" guessing game by automating context ingestion. When you enable IDE context, the agent is perpetually aware of your active file and current selection. You don't need to manually attach snippets or explain the project structure every time you trigger a prompt.

The indicator in the chat input is a simple toggle, but it’s critical. When it’s on, you’re feeding the agent exactly what it needs to make informed edits. If you’re tired of explaining the same project directory layout to a chatbot, this persistent context—combined with AGENTS.md instructions in your root directory—ensures your agent behaves like a team member who actually knows the codebase.

Choose Your Level of Autonomy

You aren't stuck with one way of working. Codex offers three distinct operation modes: Read-only, Agent, and Agent (full access).

• Read-only: Keeps the agent in a browser-like state. It explains, it critiques, but it doesn't touch your disk.
• Agent: The sweet spot for most tasks. It modifies your project files but stays within the sandbox.
• Agent (full access): This is for when you need the agent to act as a system administrator, running installs and making edits outside the immediate workspace.

The beauty is in the approval flow. You don't have to guess what the agent is doing. The built-in diff viewer lets you review changes before they go live, and if it blows something up, you’ve got a one-click rollback feature. It’s a safety net that encourages you to actually let the agent do the heavy lifting.

Extending Capability via MCP

If you’re working with complex data or external tools, Codex’s support for the Model Context Protocol (MCP) is the real differentiator. By configuring MCP servers, you’re essentially giving the agent a set of standardized APIs to interact with your local databases or infrastructure tools.

For those running DataGrip or IDEs with the Database Tools plugin, the configuration is straightforward. Once you’ve mapped the streamable-http server, the agent can query your database directly. It’s a massive upgrade from manually writing SQL migrations or debugging query strings. You’re no longer just asking the AI to write code; you’re asking it to execute tasks against your actual infrastructure.

Skills Over Prompts

Stop writing "write a function that..." over and over. Codex uses skills to handle repeatable workflows. You can install curated skills from public repos like openai/skills or build your own using the $skill-creator.

When you reference a skill with the $ prefix, you’re invoking a predefined set of instructions and scripts. It’s the difference between asking a junior dev to "do it like this" and having a library of documented internal procedures. If you find yourself doing the same task three times, wrap it in a skill.

Integrating the Frontend Workflow

While Codex manages the logic, you still need to bridge the gap between your UI and the code. This is where tools like markagent come in to supplement the agentic workflow. When you’re inspecting a live React component on a rendered page and need to point the agent to a specific DOM element or CSS selector, markagent captures the source file path and context, turning your visual feedback into a structured markdown prompt that Codex can actually process. It’s a clean way to ensure your agent is editing the right component without you having to hunt through the file tree.

Final Verdict on Model Reasoning

Don’t ignore the reasoning level settings. If you’re fixing a syntax error, keep it low for speed. If you’re architecting a new feature, crank it up. The 5.2 model is snappy, but the "reasoning level" is where the quality comes from. It’s a trade-off between latency and accuracy that you finally have manual control over.

Stop baby-sitting your AI. Let the agent handle the machine while you handle the architecture.