OpenAI Codex Security Explained: Find and Fix Bugs Fast

OpenAI Codex Security is the tool that turns a security review from a week of manual reading into a single terminal command. On 12 November 2026, OpenAI shipped version 0.10.0 of its open-source vulnerability scanner, and the update fixes the two complaints developers had been shouting about since the summer: scans that died halfway through and had to start again, and scans that quietly burned through far more money than anyone planned.

The new release adds resumable scans, one shared budget across a whole batch of repositories, and clearer explanations when a patch cannot be applied. In this guide, we explain what OpenAI Codex Security is, what version 0.10.0 changes, how to install it and run your first scan, what it actually costs, how it compares with Snyk, CodeQL and Semgrep, and where its limits still are.

In this article:

What Is OpenAI Codex Security?

OpenAI Codex Security is an open-source command-line tool and TypeScript SDK that finds security vulnerabilities in source code, checks whether each finding is real, drafts a fix, and verifies that the fix works. It ships as the npm package @openai/codex-security, runs under the short command cs, and is published under the Apache 2.0 licence.

OpenAI first introduced the Codex Security platform in March 2026 as a research preview, built around its GPT-5.5-Cyber model, and then open-sourced the CLI and SDK on 28 July 2026. Since then the project has moved fast: 55 releases in under four months, and a GitHub repository that passed 12,000 stars on the day version 0.10.0 landed and stood at more than 14,000 stars by 20 November 2026.

The idea is simple to state and hard to do well. Traditional static analysis tools match code against a library of known-bad patterns. They are fast, but they produce long lists of warnings, many of them false alarms, and they cannot reason about whether a suspicious-looking piece of code is actually reachable or exploitable. OpenAI Codex Security takes a different approach: it hands the code to an AI model that reads it, traces how data flows through it, and then tries to reproduce the suspected problem in an isolated environment before reporting it. A finding only survives if the tool can show its working.

That validation step is the whole point. Developers ignore scanners that cry wolf, and the most common complaint about every security tool ever shipped is noise.

OpenAI says the approach has been tested at real scale. On a beta cohort, the company reports that the system analysed more than 1.2 million commits, surfaced 792 critical findings and 10,561 high-severity findings, and cut noise by up to 84% in one case. Those are OpenAI’s own numbers, not an independent audit, so treat them as a signal rather than a guarantee. Still, the direction of travel is clear: the tool is designed to produce a short list of findings a human can actually act on, rather than a thousand-line report nobody reads.

What you get in the box is three things. First, the CLI, which is how most people will use it: point it at a repository or a diff, and it scans. Second, a TypeScript SDK, for teams that want to build scanning into their own tooling. Third, a GitHub Action, for running scans automatically on pull requests and pushes.

Results can be exported as SARIF, JSON or CSV, so they drop into the dashboards and issue trackers teams already use. The tool also ships 24 skills for coding agents such as Claude Code, Cursor and Codex itself, installed with npx skills add openai/codex-security, so an agent can call the scanner as part of its own workflow.

One thing to understand before you go further: OpenAI Codex Security is open source, but it is not free to run. The client code costs nothing, and there is no seat count or licence fee. The model work behind a scan does cost money. A real scan needs either a ChatGPT sign-in with Codex access or an API key billed per use, and the code being scanned is sent to the model provider.

OpenAI is the default provider, but the CLI also supports OpenRouter, Fireworks, Amazon Bedrock and Cheaper Inference, so you are not locked into a single bill. Keep that distinction in mind whenever you read a headline calling it “free”: free to download, not free to operate.

Developer reviewing code scanned by OpenAI Codex Security in a dark-themed editor

What Is New in OpenAI Codex Security 0.10.0?

Version 0.10.0 of OpenAI Codex Security was released on 12 November 2026, with a small 0.10.1 patch following on 18 November. It is not a relaunch, and it is not the open-sourcing moment — that happened in July. It is a maintenance release with four changes that matter in daily use, and all four address the same theme: long scans that stop halfway and scans that cost more than planned. If you tried the tool in August or September and walked away frustrated, this is the version that answers your complaint.

Resumable Scans in OpenAI Codex Security

The headline feature is scan resumption. An interrupted Standard scan can now be continued from its saved checkpoint with codex-security scans resume SCAN_ID, keeping the usage and budget it already spent. Before this release, a scan that failed near the end — a rate limit, a network drop, a repository whose HEAD changed mid-scan — simply threw its work away.

Community reports from the early months describe 50-minute scans consuming half a week’s token quota before failing, and one case of $13 in charges before a scan died with no way back. That failure mode was the single biggest reason teams hesitated to run the tool on large repositories. Resume does not make scans faster, but it makes them survivable, and for a tool that charges by the token, not re-doing paid work is a real saving.

There is a limit worth knowing. Resume support in 0.10.0 covers Standard scans. Deep Scan reports should not be assumed to recover the same way, and the release notes are careful on this point. If your workflow depends on Deep mode, test resume behaviour on a small repository first rather than discovering its limits on a Friday-night scan of a monorepo.

One Shared Budget With –max-total-cost

The second change is the --max-total-cost flag, which puts one estimated budget across a bulk or component scan instead of a separate cap per repository. Previously you could set --max-cost for a single scan, but a team scanning twenty repositories had to manage twenty separate ceilings, and a batch could still add up to an unpleasant total. Now one number governs the whole batch, including retries and recoveries.

The flag is an estimate, not a hard wall: OpenAI warns that work already in flight can exceed it, so a scan that is mid-flight when the budget runs out may still finish its current step. Treat it as a strong guardrail rather than a guarantee, and set it lower than your real limit if you want headroom.

This matters because the cost problem was never theoretical. Early adopters reported scans eating half a week’s token quota, and the Hacker News threads from July and August are full of people who learned the hard way that an agentic scanner with no ceiling is a credit card with no limit. The --max-cost per-scan flag was the first fix. --max-total-cost is the second, and for teams scanning many repositories it is the more important one.

ArmorCode SAST Findings Import

The third change is an import path for ArmorCode SAST findings. Findings from ArmorCode’s static analysis tooling can now flow into OpenAI Codex Security for validation and fixing. That sounds like a small integration, but it changes the tool’s position in a security stack. Instead of replacing an existing scanner, Codex Security can sit downstream of it: ArmorCode (or another tool) finds the candidates, and the AI model checks which ones are real and drafts the patches. The November releases also made external scanner imports a default part of the workflow, so this is a direction OpenAI is clearly investing in rather than a one-off connector.

Clearer Explanations When a Patch Is Blocked

The fourth change is the least glamorous and possibly the most useful day to day: when a patch cannot be applied, the tool now explains why instead of failing quietly. Anyone who has stared at a scanner that reported a finding, offered a fix, and then silently produced nothing will understand the value. The release also reports a revision_changed status when a hosted fix ends on a different commit than the one scanned, and the SDK can now publish workbench findings to the cloud. None of these is a headline, but together they make the tool’s output trustworthy in the specific way that matters: you can see what happened, why it happened, and what changed.

How OpenAI Codex Security Works

Understanding OpenAI Codex Security means understanding its four-step loop, because the loop is the product. Most scanners stop at step one. This one is built around the idea that a finding is only worth your time if it survives scrutiny.

Step one is finding. The model reads the repository — or a diff, if you are scanning a pull request — and looks for vulnerability patterns: injection flaws, authentication gaps, unsafe deserialization, secrets handling, logic errors that a pattern matcher would miss. You choose a depth mode.

Standard mode is the default, optimised for speed and common vulnerability patterns. Deep mode runs a multi-pass analysis for complex logic flaws, and costs more. You can also scope a scan to a single component, and newer November releases added a --exclude-path option to keep directories such as generated code or vendored dependencies out of the scan entirely.

Step two is validation. This is where OpenAI Codex Security earns its keep. For each candidate finding, the tool tries to reproduce the problem in an isolated environment — actually demonstrating the flaw rather than asserting it. A SQL injection claim has to show the injection working. An authentication bypass has to show the bypass. Findings that cannot be reproduced are dropped or downgraded, which is how the noise reduction happens.

No scanner eliminates false positives entirely, and you should still review what it reports, but a validated finding carries far more weight than a pattern match.

Step three is patching. For findings that survive validation, the tool drafts a fix as a patch you can review. The patch is a proposal, not an automatic commit. You read it, you test it, you decide. That distinction matters: automatically applying AI-written security patches to production code without review would be reckless, and OpenAI does not present it that way. The tool’s job is to do the tedious first draft so a human can make the judgement call quickly.

Step four is verification. After a patch is applied, the tool re-checks the code to confirm the vulnerability is actually gone and that the fix did not break the surrounding behaviour. The result is a scan history you can reopen, re-run or export, instead of a report that vanishes when the terminal closes. Results export as SARIF, JSON or CSV, which means they can feed into GitHub’s security tab, a SIEM, or a simple spreadsheet for triage.

There is one more piece of the design worth noting. The CLI ships with a policy command that drafts repository-wide or component-scoped SECURITY.md guidance for future scans, using a knowledge-base file such as an architecture document for context. The draft is saved outside the checkout, and no scan runs while it is being written.

In practice, this lets a team encode its own security rules — “this service never trusts input from that queue”, “this module handles payment data” — so later scans judge the code against the team’s own standards, not just generic vulnerability classes.

OpenAI Codex Security protects code with AI-powered vulnerability detection, symbolised by a padlock on a laptop

Installing OpenAI Codex Security and Running Your First Scan

Getting started with OpenAI Codex Security takes about ten minutes, and most of that is authentication. The install itself is one command. Before you begin, check the requirements: Node.js 22.13 or later (versions 22, 24 or 26 are supported) and Python 3.10 or later, which the tool needs for scan execution and SARIF export. You will also need either a ChatGPT sign-in with Codex access or an API key, because the scan itself runs against a model.

Step 1: Install the CLI. Install version 0.10.0 globally from npm, and pin the version while you learn the tool — the project is moving fast, with 55 releases since July, and commands can shift between versions:

npm install -g @openai/codex-security@0.10.0
cs --version

The first command installs the package. The second should print 0.10.0. If you prefer not to install globally, npx @openai/codex-security runs the same CLI. The commands cs and codex-security are the same tool, so use whichever is shorter on your keyboard.

Step 2: Sign in. For interactive use on your own machine, run codex-security login and sign in with ChatGPT. For CI or a headless server, set an API key in the environment instead — either OPENAI_API_KEY or CODEX_API_KEY. If you use a different provider, pass it with the --provider flag and its own key; OpenRouter, Fireworks, Cheaper Inference and Amazon Bedrock are all supported.

Step 3: Prove the setup with a dry run. Before spending any money on a real scan, run the CLI’s dry-run and mock-scan flows, which need no sign-in at all. They confirm the install works, the configuration resolves, and the output format is what you expect. The official tutorial for version 0.10.0 walks through this in about 30 minutes, and it is worth doing once: the install takes under a minute, and the mock scan takes under a second.

Step 4: Run your first real scan. Point the tool at a repository you own, set a cost cap from the very first run, and start small:

cs scan . --max-cost 5 --mode standard

That scans the current directory in Standard mode with an estimated $5 ceiling. Read the full scan plan the CLI prints before it starts — it shows the model, the effort level and the limits — and read the report it writes when it finishes. The default model is gpt-5.6-sol at high reasoning effort, which is thorough but not cheap, so a small repository is the right place to learn what a report looks like.

Step 5: Resume a scan if it stops. If a Standard scan is interrupted, you do not start over. Find the scan ID in the output or the scan history, then run:

codex-security scans resume SCAN_ID

The scan continues from its saved checkpoint, keeping the usage and budget already spent. This is the feature version 0.10.0 exists for, and it is the command you will be glad to know when a long scan dies at 90%.

Step 6: Scan a batch with one budget. When you are ready to scan several repositories or components, set one shared ceiling for the whole batch:

cs scan . --max-total-cost 25 --max-time 30m

The --max-total-cost flag shares an estimated $25 budget across the batch, including retries, and --max-time adds a time limit. Remember the caveat: work already in flight can exceed the estimate, so leave headroom between your flag and your real spending limit.

A final warning before you scan anything: only scan repositories you own or have permission to assess. Pointing a vulnerability scanner at someone else’s code without permission is not a grey area, and some cybersecurity requests through OpenAI’s systems need approval under its Trusted Access for Cyber programme. The tool is built for defending your own code. Use it that way.

What Does OpenAI Codex Security Cost?

The honest answer is that OpenAI Codex Security has no price list, because there is no separate price for the tool. OpenAI’s README and guides do not list a fee for the scanner itself. What you pay for is the model work a scan consumes, and that depends on three things: which model you use, how big the repository is, and which scan mode you choose. The CLI is built around limits for exactly that reason, and understanding them is more useful than any single dollar figure.

The default model is gpt-5.6-sol, priced at $4 per million input tokens and $20 per million output tokens in short context, as of 14 September 2026. A small repository scanned in Standard mode might cost a dollar or two. A large monorepo in Deep mode, with the model reading thousands of files and reasoning at high effort, can cost tens of dollars — and early adopters learned this the expensive way, with reports of scans consuming half a week’s token quota before failing.

That is why the cost flags exist, and why you should treat them as mandatory rather than optional.

Three flags control spending. --max-cost sets an estimated limit for one scan. --max-total-cost, new in version 0.10.0, sets one estimated limit for a whole batch of scans, including retries. --max-time caps how long a scan may run. The GitHub Action example in the official documentation caps each scan at an estimated $5 — that $5 is the example’s cap, not a price for the service, but it is a sensible starting point for a pull-request scan. Set your caps on the first run, not after the first surprise bill.

There are two more cost facts to keep in mind. First, the estimate is not a hard wall: work already in progress can exceed it, so a scan that is mid-flight when the budget runs out may still finish its current step.

Second, the client is Apache 2.0, which means there is no licence fee and no seat count — you can run it on as many machines as you like, and the only bill is the model usage. If you switch providers, the pricing changes with the provider: OpenRouter, Fireworks and Bedrock each bill their own rates, so compare them if you scan often.

For a solo developer, a realistic monthly cost is a few dollars of model usage for occasional scans of personal projects. For a team scanning every pull request, the cost is a line item to budget like any other CI expense — small per scan, meaningful in aggregate, and entirely controllable through the caps. The tool’s own history makes the point: the version 0.10.0 release exists largely because the community demanded better cost control, and the community demanded it because the bills were real.

OpenAI Codex Security in CI/CD

A scanner you run by hand once a month is a hobby. A scanner that runs on every pull request is a safety net. OpenAI Codex Security is designed for the second use, and the GitHub Action is the easiest way to get there. The official workflow checks out the repository, then runs the scan with an API key stored as a secret, a scope, a model, a cost cap and a failure threshold. A minimal version looks like this:

name: Codex Security Gate
on: [pull_request]
jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Scan the repository
        uses: openai/codex-security@REPLACE_WITH_REVIEWED_COMMIT
        with:
          scope: repository
          model: gpt-5.6-sol

The details matter more than the shape. Pin the Action to a reviewed commit rather than a floating tag, so a compromised or changed release cannot silently alter what runs in your pipeline. Set --fail-on-severity high so the build fails when a high-severity finding survives validation — that is the flag that turns a report into a gate.

Scan the diff rather than the whole repository on pull requests, so each change is judged on what it introduces instead of re-litigating the entire codebase every time. And keep the cost cap in the workflow: the official example caps each scan at an estimated $5, which keeps a busy repository’s CI bill predictable.

There is a practical rhythm that works well for most teams. Run a Standard-mode diff scan on every pull request with a low cost cap and a high-severity gate. Run a full-repository Standard scan on a nightly schedule with a shared batch budget. Reserve Deep mode for releases, for code that handles money or personal data, and for the occasional audit of a sensitive component. Export the results as SARIF so findings land in GitHub’s security tab, where developers already triage them, instead of in a separate dashboard nobody opens.

One caution from the tool’s own history: long scans in CI can hit the same failure modes as long scans anywhere. A repository whose HEAD changes mid-scan used to kill the run outright. Version 0.10.0’s resume support covers Standard scans, so a failed CI scan can now be continued rather than restarted — but only if your workflow preserves the scan ID and the checkpoint. If your pipeline discards state between runs, resume cannot help you, so design the workflow to keep it.

Development team using OpenAI Codex Security in their CI workflow to review code together

OpenAI Codex Security vs Snyk, CodeQL and Semgrep

No scanner wins on every axis, and the right choice depends on what you are scanning and what you already pay for. Here is how OpenAI Codex Security compares with the three tools developers most often weigh it against.

Feature OpenAI Codex Security Snyk Code GitHub CodeQL Semgrep
How it finds bugs AI model reads code and validates findings by reproducing them AI-assisted static analysis with a large rule library Query-based analysis over a code database Pattern matching with custom rules
False positives Lower, because findings are validated before reporting Moderate, improving with AI triage Low for its query set, but limited to known patterns Depends on rule quality; can be noisy out of the box
Fix suggestions Drafts and verifies patches Fix suggestions for many findings Autofix suggestions with a Copilot subscription Limited; some autofix rules
Dependency scanning Not documented Yes, Snyk Open Source Yes, Dependabot and dependency review No, needs a companion tool
Container and IaC scanning Not documented Yes Partial, via Actions and partners Yes, with Semgrep rules for IaC
Licence and cost Apache 2.0 client; pay per model use, no seat fee From $25 per month per developer Free for public repos; GitHub Advanced Security from about $30 per active committer per month Free open-source engine; paid platform for teams
Best for AI-validated review of your own code, with patches Teams wanting one platform for code, dependencies and containers GitHub-native teams wanting deep query-based analysis Teams that want fast, customisable, self-hosted rules

The comparison makes the trade-off plain. OpenAI Codex Security does one job — AI review of your own application code, with validation and patches — and it does that job in a way the others do not. Snyk covers more ground: it scans your dependencies, your containers and your infrastructure as code, which Codex Security does not document at all. If you need a single platform for all of those, Snyk is the more complete answer, at $25 per month per developer and up.

CodeQL is the strongest choice if your code already lives on GitHub and you want deep, query-based analysis with Autofix, though the full Advanced Security pricing starts at about $30 per active committer per month. Semgrep is the fastest and most customisable of the four, and its open-source engine is free, but it is a pattern matcher at heart: it finds what its rules describe, and it cannot reason about a vulnerability the way a model can.

The honest way to use Codex Security is therefore as a complement, not a replacement. Run CodeQL or Semgrep for fast, deterministic coverage on every commit. Run Snyk or Dependabot for your dependencies and containers. Then run OpenAI Codex Security where its validation matters most: on pull requests touching authentication, payments or data handling, and on periodic deep reviews of sensitive components. The tools answer different questions, and a team that uses two of them well is safer than a team that uses one of them perfectly.

There is also a cost comparison worth making. Snyk and CodeQL charge per seat or per committer, which grows with the team. Codex Security charges per model use, which grows with the amount of code scanned. A small team scanning a large codebase may find the per-use model cheaper; a large team scanning small pull requests may find the opposite. The caps make the per-use model predictable, but only if you actually set them.

What OpenAI Codex Security Cannot Do

Every tool review that only lists strengths is an advertisement. OpenAI Codex Security has real limits, and knowing them before you adopt it will save you a disappointing month.

It does not scan your dependencies, containers or infrastructure. The tool reviews your own application code. Dependency and container scanning are not documented, so if your biggest risk is a vulnerable library three layers deep in your dependency tree, you still need Snyk, Dependabot or an equivalent. Do not assume a clean Codex Security report means a clean supply chain.

Your code leaves your machine. The CLI runs locally, but the scan itself sends relevant code to the model provider — OpenAI by default, or whichever provider you choose. That is inherent to the design: the model cannot read code it never sees. If your code contains secrets, customer data or anything under a strict handling policy, review what the tool sends and whether your provider’s terms allow it. The hosted cloud option exists for teams that prefer a managed service, but the same consideration applies there.

It is still a research preview in important respects. OpenAI introduced Codex Security as a research preview, and the open-source CLI has been public only since July 2026. The project moves fast — 55 releases in four months — which is exciting and unstable in equal measure. Commands, flags and defaults can change between versions, which is why pinning the version matters.

Some cybersecurity requests need approval through OpenAI’s Trusted Access for Cyber programme, and access itself requires a ChatGPT plan with Codex access or an API key; the documentation does not spell out exactly which ChatGPT plans include it, so verify your own access before promising a team it will work.

Validation is not proof. Reproducing a vulnerability in an isolated environment is far stronger evidence than a pattern match, but it is not a guarantee that the finding matters in production, and it is not a guarantee that the absence of findings means the absence of bugs. The model can miss logic flaws, misunderstand business rules, and be misled by unusual code. Treat a clean report as a good sign, not a certificate.

Budgets are estimates, not walls. Both --max-cost and the new --max-total-cost are estimates, and work already in flight can exceed them. If your spending limit is a hard compliance boundary rather than a preference, set the flags well below it and monitor actual usage separately.

It will not fix your security culture. A scanner that drafts patches is still only as good as the humans who review them. An unreviewed AI patch applied automatically is a new vulnerability with a confident tone. The tool’s design assumes a human reads every patch, and every team that adopts it should keep that assumption.

Who Should Use OpenAI Codex Security?

OpenAI Codex Security fits some teams very well and others not at all. Here is a practical way to decide.

Solo developers and small teams should try it first. The install is one command, there is no seat fee, and a $5 cap makes the first scan nearly free. If you maintain an open-source project or a side business with a web application, a monthly Standard scan of your own code is one of the cheapest security improvements available.

The GitHub Action also means your pull requests get a second pair of eyes without hiring anyone. For the site’s own audience of independent developers and small teams, this is the sweet spot — and it is also why the project passed 14,000 GitHub stars so quickly: it solves a problem individuals feel directly.

Security-conscious startups should use it as a second layer. If you already run Semgrep or CodeQL in CI, add a Codex Security diff scan on pull requests that touch sensitive areas. The validated findings and drafted patches save your most expensive resource — senior engineers’ review time — and the per-use pricing means you only pay when code actually changes. Just keep the human in the loop on every patch, and keep a dependency scanner running alongside it.

Enterprise teams should evaluate it carefully and pilot it on one repository first. The Trusted Access for Cyber approval step, the question of which ChatGPT plans include access, the code-leaves-the-machine design, and the research-preview status all need answers from your security and legal teams before a rollout.

The hosted Codex Security platform, with its enterprise billing and the Daybreak heritage, may fit better than the open-source CLI for a large organisation — but the CLI is the right way to learn what the technology can do before committing.

Who should skip it for now? If you need dependency and container scanning and you can only adopt one tool, pick Snyk or a GitHub-native stack instead. If your code cannot leave your premises under any circumstances, an AI scanner that sends code to a model provider is the wrong architecture, no matter how good the findings are. And if you want a tool that requires no judgement — install it, forget it, trust the output — this is not that tool. Every finding deserves a human look, and every patch deserves a human review.

Engineer in a data centre where OpenAI Codex Security scans run in CI pipelines

Frequently Asked Questions

Is OpenAI Codex Security free?

The client is free: it is open source under Apache 2.0, with no licence fee and no seat count. Running a scan is not free, because the scan consumes model work that is billed per use. You need a ChatGPT sign-in with Codex access or an API key, and you control the spend with --max-cost, --max-total-cost and --max-time. The GitHub Action example caps each scan at an estimated $5.

What is the difference between OpenAI Codex Security and Codex?

Codex is OpenAI’s general coding agent: it writes code, refactors, and completes tasks. OpenAI Codex Security is a specialised sibling focused only on security: it finds vulnerabilities, validates them by reproducing them, drafts patches and verifies the fixes. They share a lineage and some infrastructure, but Codex Security is the tool you reach for when the question is “is this code safe?” rather than “can you build this feature?”

Can OpenAI Codex Security resume a failed scan?

Yes, since version 0.10.0. An interrupted Standard scan can be continued from its saved checkpoint with codex-security scans resume SCAN_ID, keeping the usage and budget already spent. Resume support covers Standard scans; do not assume the same behaviour for Deep scans without testing it.

How much does a scan cost?

There is no fixed price. The default model, gpt-5.6-sol, costs $4 per million input tokens and $20 per million output tokens in short context, as of 14 September 2026. A small repository in Standard mode may cost a dollar or two; a large monorepo in Deep mode can cost tens of dollars. Set --max-cost on every scan and --max-total-cost on every batch, and remember both are estimates — work already in flight can exceed them.

Does OpenAI Codex Security replace Snyk or CodeQL?

No. It reviews your own application code with AI validation and patch drafting, which is a different job from dependency scanning, container scanning and infrastructure scanning. Snyk covers dependencies and containers; CodeQL offers deep query-based analysis inside GitHub. The strongest setup uses Codex Security alongside one of them, not instead of it.

What do I need to run OpenAI Codex Security?

Node.js 22.13 or later, Python 3.10 or later, and either a ChatGPT sign-in with Codex access or an API key (OpenAI by default, or OpenRouter, Fireworks, Amazon Bedrock or Cheaper Inference via the --provider flag). Install with npm install -g @openai/codex-security, then run cs scan . on a repository you own or have permission to assess.

The Bottom Line

OpenAI Codex Security is the most interesting security tool OpenAI has shipped this year, and version 0.10.0 is the release that makes it usable in anger. The resumable scans fix the failure mode that made long scans a gamble. The shared batch budget fixes the cost problem that made teams nervous about running it at all. The ArmorCode import and the clearer blocked-patch explanations make it a better citizen in a real security stack.

None of this makes it a replacement for Snyk, CodeQL or Semgrep, and none of it removes the need for a human to read every finding and every patch. But for a solo developer, the proposition is hard to beat: one command, a $5 cap, and an AI reviewer that shows its working before it asks for your trust.

Install version 0.10.0, pin it, set your caps, and run it on a repository you own. The first scan will tell you more about your code than a month of reading about the tool ever could. If you want to go deeper into the model family behind the scanner, read our guide to GPT-6 Cyber, and if you want to compare it with the coding agents developers pair it with, see our GitHub Copilot Fusion guide and our explainer on DeepSeek DeepInfer, the open-source inference engine behind some of the cheapest AI in the world.

Leave a Comment

Your email address will not be published. Required fields are marked *