Latest Innovations
Checkmarx for Developers
Partners
Blog
Research

OpenAI Codex Security: Capabilities, Limitations, and Best Practices

AI cybersecurity cover image

Summary

OpenAI Codex Security uses AI reasoning and threat modeling to discover code vulnerabilities, validate exploitability, and propose fixes. However, it cannot replace runtime, cloud, and supply chain controls. Enterprise adoption requires managing agent permissions, protecting sensitive code, and integrating scanning into a broader AppSec program.

What Is Codex Security? 

Codex Security is an AI-powered application security agent by OpenAI designed to identify, validate, and remediate vulnerabilities in code repositories. It uses frontier-model reasoning and repository context to understand application architecture, trust boundaries, sensitive components, and likely attack paths rather than relying only on pattern-based scanning.

How Codex Security works:

  • Building an editable, project-specific threat model: Maps sensitive components, trust boundaries, and attack paths, with editable assumptions to reflect deployment context.
  • Investigating vulnerabilities with LLM reasoning instead of signature rules: Analyzes relationships across files and components to identify contextual security weaknesses.
  • Validating findings in an isolated environment: Attempts to reproduce suspected vulnerabilities through tests and code execution to assess exploitability.
  • Proposing patches with full system context for human review: Suggests targeted fixes that account for application architecture and remain subject to developer approval.
  • Scanning repository history and new commits: Investigates existing code and incoming changes to uncover security debt and newly introduced vulnerabilities.

How to access Codex Security:

  • Codex Security in ChatGPT web and desktop app: Provides interfaces for repository workflows, with cloud scanning access dependent on workspace permissions and availability.
  • Codex Security Cloud for connected GitHub repositories: Analyzes authorized repositories and evaluates new commits using project-specific threat models.
  • Codex Security CLI and TypeScript SDK for terminals and CI/CD pipelines: Supports local repository analysis and integration into internal tools and automated workflows.
  • Custom security policies, severity rubrics, and finding deduplication: Uses project guidance and organizational severity criteria to contextualize findings and support consistent triage.

Although Codex Security can identify complex code vulnerabilities and generate remediation suggestions, it does not provide comprehensive application security coverage. It cannot replace dedicated SAST, SCA, DAST, cloud security testing, or runtime security controls, and its reasoning-based scanning may miss vulnerabilities or produce inaccurate severity assessments. 

Exploit validation also depends on the ability to reproduce issues in isolated environments, while generated patches still require human review. Organizations should therefore use Codex Security alongside enterprise application security platforms, which provide broader testing coverage, centralized risk prioritization, consistent policy enforcement, and security governance across the software development lifecycle.

This is part of a series of articles about Claude Mythos.

Codex Security Release Timeline and Availability 

From Aardvark to Codex Security and OpenAI Daybreak: Release Timeline

Codex Security began as Aardvark, an agentic security researcher announced in October 2025. Aardvark entered private beta with the ability to continuously analyze repositories, create codebase-specific threat models, investigate vulnerabilities, validate findings, and recommend patches.

On March 6, 2026, OpenAI integrated Aardvark into Codex and renamed it Codex Security, releasing it as a research preview. The product retained the threat-model-driven approach while becoming part of the broader Codex environment for repository analysis and agentic software development workflows.

On May 11, 2026, OpenAI launched Daybreak, its broader cybersecurity initiative, with Codex Security as a core component alongside its frontier models and security partners. On June 22, 2026, OpenAI expanded Daybreak with the full release of GPT-5.5-Cyber, an updated Codex Security plugin, the Daybreak Cyber Partner Program, and the Patch the Planet open-source initiative. For more on the program, see our guide to OpenAI Daybreak.

OpenAI also open-sourced Codex Security as the @openai/codex-security package, a command-line interface and TypeScript SDK under the Apache 2.0 license, so teams can scan repositories, verify fixes, and add security checks to CI/CD pipelines.

At DevDay on September 29, 2026, OpenAI introduced Codex Security Cloud as a plugin in Codex, scanning connected GitHub repositories in the cloud and preparing fixes even when a developer’s machine is offline.

Codex Security Access Requirements, Supported Plans, and Codex for OSS

Codex Security is available as a research preview for eligible ChatGPT Pro, Business, Enterprise, and Edu users. Codex Security Cloud connects to GitHub repositories, so users must authorize the repositories they want analyzed before running repository or commit-level security scans.

Enterprise and Edu organizations can manage access through workspace permissions and role-based controls. Administrators can determine which users or groups can access Codex Cloud, Codex Security, and related security capabilities.

OpenAI also offers Codex for Open Source, which provides selected maintainers of important open-source projects with access to Codex resources such as ChatGPT Pro, API credits, and, in some cases, Codex Security. Eligibility is based on factors such as ecosystem importance, project usage, and active maintenance, with security access evaluated separately.

How Codex Security Works 

Codex Security follows a threat-model-driven workflow that combines repository analysis, vulnerability investigation, exploit validation, and remediation: 

  1. It examines the codebase to build an editable threat model that identifies sensitive components, trust boundaries, and potential attack paths. 
  2. The agent then uses language-model reasoning to investigate security weaknesses across files and commits. 
  3. When possible, it validates suspected vulnerabilities in an isolated environment. 
  4. For confirmed issues, it generates patch suggestions for human review and can revalidate fixes after they are merged.

The following diagram, originally published by OpenAI to describe the Aardvark project, illustrates this workflow.

Source: OpenAI

Building an Editable, Project-Specific Threat Model

Codex Security begins by analyzing the repository to understand the application’s security-relevant architecture and how its components interact. It builds a project-specific threat model that can include attacker entry points, trust boundaries, sensitive data flows, authentication mechanisms, privileged operations, and other code paths that may be important from a security perspective.

Because the threat model is editable, developers and security teams can refine it with deployment-specific context that may not be obvious from source code alone. This gives Codex Security a more accurate foundation for later vulnerability investigation and helps focus analysis on risks that are actually relevant to the application.

Investigating Vulnerabilities With LLM Reasoning Instead of Signature Rules

Instead of relying primarily on signatures or predefined vulnerability patterns, Codex Security uses language-model reasoning to investigate how the application behaves. It can inspect multiple files and components together, follow data and control flows, reason about attacker-controlled inputs, and analyze whether apparently safe code becomes vulnerable when combined with other parts of the system.

The agent can also use tools, run tests, and spend additional compute investigating promising leads. This allows it to search for complex or application-specific weaknesses that may not match a known rule, while using the repository’s broader context to determine whether a suspicious pattern represents a meaningful security issue.

Validating Findings in an Isolated Environment

When Codex Security identifies a potential vulnerability, it can attempt to reproduce the issue in an isolated environment before presenting it as a validated finding. The system can execute relevant code, construct test cases, and observe whether the suspected attack path behaves as expected.

This validation step helps distinguish genuinely exploitable vulnerabilities from theoretical concerns or false positives. It can also provide developers with clearer evidence showing how the issue is triggered, making it easier to understand the risk and verify that a subsequent fix addresses the problem.

Proposing Patches With Full System Context for Human Review

For validated vulnerabilities, Codex Security can generate patch suggestions based on its understanding of the affected code and the surrounding application architecture. Rather than applying a generic remediation pattern, it can take into account intended application behavior, related components, and existing coding conventions when proposing a fix.

The proposed remediation remains under human control. Developers and security teams can inspect the change, test it, modify it if necessary, and move it into a pull request through their normal development workflow. This keeps human review in the loop while reducing the manual work required to move from vulnerability discovery to remediation.

Scanning Repository History and New Commits

Codex Security can analyze an existing repository to identify vulnerabilities that may already be present in the codebase. This makes it useful for uncovering security debt in older application logic rather than limiting analysis only to newly written code.

It can also perform commit-level analysis as the repository changes, evaluating new code in the context of the wider system and its threat model. This enables teams to use Codex Security both as a deeper repository-wide security researcher and as an ongoing control for identifying vulnerabilities introduced by new development. 

Ways to Run Codex Security 

Codex Security in ChatGPT Web and Desktop App

Eligible users can access Codex Security through the Codex environment associated with their ChatGPT workspace. The web interface provides a way to connect authorized GitHub repositories, configure security analysis, review project-specific threat models, and investigate findings with supporting evidence. Developers can also review proposed patches and move remediation into their normal pull request workflows. 

The Codex desktop app provides a complementary development interface for working with repositories and agent-generated changes, although access to Codex Security’s cloud scanning features and management controls may still depend on the web interface and workspace permissions.

Codex Security GitHub Integration: Cloud Scanning for Connected Repositories

Codex Security Cloud is delivered as a plugin in Codex and connects directly to GitHub.

Codex Security Cloud is designed for managed, ongoing security scanning across GitHub repositories. After a repository is connected and authorized, Codex Security builds a project-specific threat model, analyzes repository history for existing vulnerabilities, and can continue evaluating new commits as the codebase changes.

The Codex Security Plugin in the Codex App, CLI, and IDE

Beyond cloud scanning, the Codex Security plugin brings the same threat-model-driven analysis into the Codex app, CLI, and IDE extensions. Developers can point it at a repository, a branch, a specific component, a pull request, or uncommitted local changes, which makes it useful for reviewing AI-generated code before it is committed or merged. Like the rest of Codex Security, the plugin remains in research preview, so its behavior and availability may change.

Codex Security CLI and TypeScript SDK for Terminals and CI/CD Pipelines

OpenAI also provides the open-source @openai/codex-security package as both a command-line interface and TypeScript SDK. The CLI can scan authorized local repositories directly from a terminal, while the SDK allows organizations to embed Codex Security capabilities into internal security tools and automated workflows.

Custom Security Policies, Severity Rubrics, and Finding Deduplication

Codex Security supports repository-wide or component-specific security guidance that can be stored in SECURITY.md files and used to influence how future scans assess the codebase. Teams can provide architecture documents, threat models, deployment information, or other knowledge-base material so findings are evaluated against the organization’s actual security assumptions and policies.

Findings can also be reclassified using a custom severity rubric without changing their original scan severity or rerunning vulnerability discovery. This allows organizations to map findings to their own definitions of critical, high, medium, or lower-priority risk based on factors such as business impact, deployment context, and exploitability.

What Codex Security Does Not Cover 

It’s important to realize that Codex Security is a solution focused on code vulnerabilities and does not address other aspects of the vulnerability lifecycle.

Deployment, Cloud, and Infrastructure Misconfigurations

Codex Security is primarily designed to analyze application source code, repository context, and code changes. It is not a replacement for cloud security posture management, infrastructure configuration auditing, or continuous monitoring of deployed environments. Misconfigured IAM roles, exposed storage buckets, overly permissive firewall rules, Kubernetes configuration problems, and similar infrastructure issues may therefore require dedicated cloud and infrastructure security controls.

Repository context can still help Codex Security reason about infrastructure-as-code or deployment assumptions when those artifacts are included in the project. However, it does not automatically provide complete visibility into the actual state of cloud accounts, production networks, Kubernetes clusters, or other infrastructure outside the material and environments made available to the scan.

Broken Authorization and Business Logic Flaws at Runtime

Codex Security can identify complex authorization and business-logic vulnerabilities when the underlying weakness can be understood from repository context. OpenAI specifically positions its reasoning-based approach as useful for issues such as authorization gaps, workflow bypasses, and violations of application invariants that traditional source-to-sink analysis may miss.

However, it should not be treated as a substitute for testing the behavior of a fully deployed application under real production conditions. Vulnerabilities that depend on runtime configuration, external services, unusual user states, production data, or complex interactions between independently deployed systems may require API security testing, penetration testing, runtime monitoring, or other dynamic techniques. Project-specific validation environments can improve coverage, but the quality of that validation depends on how closely the environment represents the real system.

Enforced Pre-Commit Security for AI-Generated Code

Codex Security Cloud primarily reviews connected repositories and their commits, so code generated locally by an AI coding assistant is not automatically visible to the cloud service before it enters the repository workflow. Organizations relying only on repository or commit monitoring therefore have a window in which insecure generated code may exist locally before a cloud scan evaluates it.

The Codex Security plugin and open-source CLI can analyze a repository, branch, component, pull request, or local working-tree changes, so developers can review AI-generated code before committing it. What Codex Security does not provide is enforcement: nothing requires every developer or coding agent to run those checks, and there are no organization-wide policies governing what must be scanned before code enters the repository.

Limitations of Codex Security Vulnerability Scanning

Codex Security can discover complex code vulnerabilities, investigate attack paths, validate findings, and propose fixes. However, its reasoning-driven approach introduces tradeoffs in scanning consistency, detection coverage, validation reliability, and scalability. These limitations make it useful as a complementary security research tool rather than a complete replacement for established application security testing.

1. Reasoning-Based Detection Does Not Guarantee Consistent Vulnerability Coverage

Codex Security uses LLM reasoning to investigate vulnerabilities based on repository context and a project-specific threat model. This approach helps identify complex business logic flaws and authorization weaknesses that conventional static analysis may struggle to detect. However, the quality of its findings depends on how effectively the model understands the application, selects attack paths, and investigates potential weaknesses.

Unlike deterministic, rule-based SAST engines, reasoning-driven analysis does not inherently guarantee that every relevant vulnerability pattern will be checked systematically. The agent may prioritize promising attack paths while overlooking other weaknesses. As a result, organizations still need conventional static analysis to provide repeatable checks for known vulnerability classes, secure coding violations, and established security rules.

2. Exploit Validation Can Miss Vulnerabilities That Are Difficult to Reproduce

One of Codex Security’s main capabilities is attempting to validate suspected vulnerabilities in an isolated environment before reporting them. This helps reduce false positives by providing evidence that a potential weakness can be exploited. However, successful validation depends on whether the agent can construct a suitable test environment and reproduce the vulnerable behavior.

Some genuine vulnerabilities require complex application states, specific dependencies, unusual input combinations, or environmental conditions that are difficult to recreate. A failure to reproduce an issue does not necessarily mean the code is secure. Organizations that rely too heavily on validated findings risk overlooking vulnerabilities that remain exploitable but cannot be demonstrated through the agent’s available tests.

3. Threat Model Accuracy Depends on Application Context and Human Input

Codex Security creates an editable threat model that identifies sensitive components, trust boundaries, and potential attack paths. This helps direct scanning toward application-specific risks instead of treating every suspicious code pattern equally. However, the threat model is only as reliable as the information available to the agent.

Incomplete architecture documentation, undocumented business requirements, and incorrect assumptions about intended application behavior can affect which vulnerabilities receive attention. OpenAI recommends refining threat models over time, indicating that automated analysis alone may not capture all security-relevant context. Security teams must therefore review and maintain these models to reduce the risk of missed findings or incorrect severity assessments.

4. Reduced False Positives Do Not Eliminate Detection and Severity Errors

Codex Security uses contextual reasoning and validation to improve finding accuracy. OpenAI reported that its early development reduced false positives and severity overreporting substantially. These improvements can reduce unnecessary triage, but they do not demonstrate that the system consistently detects all relevant vulnerabilities or assigns accurate severity in every application.

A validated vulnerability may still receive an inappropriate priority if the agent misunderstands business impact, compensating controls, or exploitation requirements. Conversely, a vulnerability that the agent fails to identify or validate may never appear in its findings. Security teams still need independent testing, risk-based triage, and established vulnerability assessment processes rather than assuming that high-confidence findings represent comprehensive coverage.

5. Deep Security Reasoning Can Increase Scan Time and Resource Consumption

Codex Security can investigate code paths, execute tests, construct validation cases, and spend additional computation on promising vulnerabilities. These capabilities are valuable for complex security research, but they can also make scanning more resource-intensive than lightweight rule-based checks.

OpenAI acknowledges that initial scans of large repositories can take longer than subsequent scans of new code. Its cloud service also uses token-based billing, making resource consumption a consideration for organizations scanning large portfolios. Teams must balance the benefits of deeper investigation against scan frequency, cost, and development pipeline performance. Conventional SAST can remain useful for fast, predictable security checks, while agentic investigation provides additional depth for higher-risk code.

6. Automated Patch Generation Still Requires Independent Security Review

Codex Security can propose targeted patches based on the affected code and surrounding application behavior. This can accelerate remediation by giving developers a concrete starting point instead of requiring them to investigate and fix every finding manually.

The gap between working code and secure code is measurable. In a study Checkmarx commissioned from independent researcher The Weather Report, published in July 2026, frontier models produced working code 83% to 95% of the time, but only 24% to 36% of that code was both secure and functional. 

However, generating a plausible fix is not equivalent to proving that the vulnerability has been eliminated without introducing regressions. A patch may address the demonstrated exploit while leaving related attack paths unresolved, changing intended behavior, or creating new defects. OpenAI explicitly recommends reviewing generated patches through normal development workflows and using additional code review controls. Organizations should also require appropriate testing and verification before considering a vulnerability remediated.

Security Risks of Deploying Codex Agents in the Enterprise 

Beyond Codex Security limitations, the use of Codex Security in an organization also raises important security issues. The information below is taken from OpenAI guidance about safe usage of Codex.

Codex Agents as Non-Human Identities With Repository Access

Codex agents can review repositories, execute commands, modify files, interact with development tools, and in some configurations access networks or MCP-connected systems on behalf of users. This makes them function similarly to privileged non-human identities within the software development environment. If an agent receives excessive repository permissions, credentials, or network access, a compromised or incorrectly instructed session could potentially perform actions beyond what the organization intended.

Enterprises should therefore apply least-privilege access, sandboxing, approval requirements, and explicit network policies to Codex deployments. OpenAI also supports managed configurations, secure credential storage, workspace-bound authentication, and telemetry covering prompts, tool executions, approval decisions, MCP usage, and network activity, giving security teams additional controls for governing agent behavior.

Related content: Read our guide to AI agent security

Source Code and Data Exposure in Cloud-Based Scanning

Cloud-based Codex and Codex Security workflows require application context to be processed outside the developer’s local environment. Depending on the workflow, this context can include source code, repository history, configuration files, prompts, tool results, and other information required for the agent to understand and analyze the project. Organizations handling proprietary code or regulated data should therefore evaluate what information is made available to the service and whether its use complies with internal data-handling requirements.

OpenAI states that data from ChatGPT Enterprise, Business, Edu, and its API platform is not used to train its models by default, and business data is encrypted both at rest and in transit. Organizations can also use enterprise access controls, retention options, data-residency features where eligible, and other governance mechanisms. These protections reduce exposure risk, but enterprises should still avoid unnecessarily placing secrets, production credentials, sensitive customer data, or other restricted information within repositories and agent contexts.

Shadow AI: Codex Use Outside Approved Development Workflows

Shadow AI can arise when developers use Codex through personal accounts, unmanaged local installations, unauthorized extensions, or workflows that fall outside the organization’s approved ChatGPT workspace. In these cases, security teams may lose visibility into which repositories are being accessed, what credentials are available to agents, which external systems agents can communicate with, and whether organization-wide security policies are being enforced.

Managed Codex deployments provide controls intended to reduce this risk. Enterprise administrators can separately govern Codex Local and Codex Cloud access, use RBAC to restrict availability, enforce configuration requirements that users cannot override, control network behavior, and collect Codex activity through compliance and OpenTelemetry logging.

Why Application Security Platforms Are a Critical Complement for Codex Security 

Codex Security brings valuable AI-driven vulnerability discovery, exploit validation, and remediation capabilities to software development. However, identifying and fixing individual code vulnerabilities is only one part of an enterprise application security program. Organizations also need consistent security testing, software supply chain protection, centralized risk management, and governance across the entire software development lifecycle (SDLC).

Application security platforms such as Checkmarx One complement tools like Codex Security by combining multiple detection technologies with enterprise-wide security controls. Rather than relying on a single AI-based scanning approach, organizations can use these platforms to establish comprehensive, repeatable, and measurable security processes.

Combine AI Reasoning With Deterministic Security Testing

Codex Security uses AI reasoning to investigate complex vulnerabilities and identify attack paths that traditional rule-based scanners may overlook. However, reasoning-based detection alone cannot guarantee consistent coverage of known vulnerability patterns across every scan.

Application security platforms combine deterministic SAST with AI-powered analysis to provide complementary detection methods. Deterministic engines systematically inspect code against established security rules, while AI can investigate complex relationships and emerging vulnerability patterns.

Extend Security Coverage Beyond First-Party Source Code

Codex Security focuses on analyzing application code and its surrounding repository context. While it can identify vulnerabilities involving dependencies or configuration files, repository reasoning is not equivalent to maintaining dedicated security coverage across every component of an application.

Comprehensive AppSec platforms integrate multiple testing technologies, including SAST, software composition analysis (SCA), DAST, infrastructure-as-code (IaC) scanning, API security, and secrets detection. These capabilities help organizations identify vulnerable or malicious open-source packages, exposed credentials, insecure configurations, and weaknesses in running applications.

Prevent Vulnerabilities Earlier in AI-Assisted Development

Codex Security can analyze repository changes, local code, and proposed modifications, depending on how it is deployed. However, making scanning capabilities available does not automatically ensure that every developer or AI coding agent uses them before introducing insecure code.

Application security platforms can enforce checks directly within development environments and automated workflows. Advanced solutions with agent-focused capabilities can also inspect certain actions, such as file modifications and package installations, before execution. This preventive approach reduces dependence on developers remembering to initiate scans and helps organizations apply consistent security safeguards during AI-assisted development.

Centralize Risk Prioritization Across Applications and Security Tools

Codex Security provides vulnerability findings, severity assessments, and supporting evidence that help developers understand individual security issues. However, these results alone do not establish a unified view of application security risk across an organization’s entire software portfolio.

Application Security Posture Management (ASPM) platforms address this challenge by correlating findings from multiple testing tools and evaluating them using factors such as exploitability, reachability, application exposure, and business criticality. This helps security teams allocate limited remediation resources to the vulnerabilities that pose the greatest organizational risk instead of managing isolated scanning results.

Resolve Risk as Fast as AI Delivers It

: AI-assisted vulnerability remediation for modern AppSec teams

Keep pace with growing volumes of findings. Prioritize attackable risk and deliver review-ready suggested fixes with less manual effort, helping AppSec and development teams reduce exposure faster.

Jump to Key Benefits

Best Practices for Using Codex Security in your Application Security Program 

Review and Edit the Threat Model Before the First Full Scan

Codex Security uses a project-specific threat model to determine where to focus its investigation, including attacker entry points, trust boundaries, sensitive data, and high-impact code paths. Teams should inspect this model early and correct assumptions about authentication, deployment architecture, exposed interfaces, privileged operations, and other application-specific security boundaries before relying on broad scan results.

The threat model should also be maintained as the application evolves. Changes to architecture, APIs, identity flows, or deployment patterns can alter the application’s attack surface, so periodically refining the model helps Codex Security investigate scenarios that more closely reflect the system’s actual security posture.

Define an Organizational Security Policy and Severity Rubric for Scans

Define what constitutes a reportable vulnerability before scaling Codex Security across many repositories. Repository-wide or component-specific SECURITY.md guidance can describe trusted boundaries, attacker assumptions, important assets, accepted risks, and application-specific security requirements, giving the scanner better context for deciding which conditions should be treated as vulnerabilities.

Organizations can also apply their own severity rubric after discovery. Severity classification can incorporate architecture, deployment, and business context to map findings to internal definitions of critical, high, medium, or lower-priority risk without changing the original scan evidence. Consistent policies make it easier to triage findings across teams and apply common remediation SLAs.

Require Code Review and Human Approval for Codex Security Remediation PRs

Treat Codex-generated patches as proposed changes rather than automatically trusted fixes. Codex Security generates remediation for validated findings but does not automatically modify the repository; patches can instead be raised as pull requests and reviewed through the organization’s normal development process.

Reviewers should confirm that the patch closes the identified attack path without introducing functional regressions, new vulnerabilities, or unexpected architectural changes. OpenAI specifically recommends applying the normal review process to Codex Security PRs and using Codex Code Review as an additional check, while keeping a human responsible for final approval and merging.

Combine Repository Scanning With Pre-Commit IDE Checks, SCA, and DAST

Codex Security should operate as one layer of a broader application security program rather than replacing specialized security controls. Use local or IDE-based security checks before code is committed where practical, and combine repository analysis with software composition analysis to identify vulnerable third-party dependencies and supply-chain risks.

Dynamic application security testing can provide another complementary layer by testing the behavior of a running application from the outside. Together, early developer feedback, Codex Security’s contextual repository analysis, SCA, CI/CD checks, DAST, and manual testing provide coverage across different stages of the SDLC and different vulnerability classes that no single scanning technique can fully address.

Integrate Codex Security Findings Into a Centralized ASPM Platform

Connect Codex Security’s vulnerability findings with an Application Security Posture Management (ASPM) platform to maintain a unified view of application risk. Instead of managing Codex Security findings separately, organizations should correlate them with results from existing security tools, identify overlapping vulnerabilities, and associate findings with affected applications, assets, and business services.

Where supported by available integrations or APIs, automate the exchange of finding status, remediation ownership, and vulnerability metadata between Codex Security and the ASPM platform. This helps security teams avoid duplicate remediation efforts, prioritize vulnerabilities based on their broader organizational impact, and track remediation progress through a consistent workflow. Platforms such as Checkmarx One can provide centralized risk management across application security testing tools.

Enforce Enterprise Security Gates Independently of Codex Security Results

Use Codex Security as an additional source of security findings without allowing its results to become the sole basis for release approval. Organizations should maintain centrally enforced security gates in their CI/CD pipelines that evaluate applications against mandatory security requirements, regardless of whether Codex Security identifies or validates a vulnerability.

Security gates can enforce policies based on unresolved critical vulnerabilities, prohibited dependencies, compliance requirements, and approved security exceptions. Teams should also define how Codex Security findings affect release decisions, including when additional investigation is required and who can authorize exceptions. Keeping these controls independent of any single AI scanning engine ensures that security requirements remain consistent even when scans are incomplete, validation is inconclusive, or AI-generated assessments differ between runs.

Securing Codex-Generated Code with Checkmarx One

Codex Security, Codex coding agents, and other AI assistants can now write code, investigate vulnerabilities, and propose fixes. However, each tool reports results in its own interface, and none of them should be the only judge of its own output. AppSec teams need an independent layer that validates AI-generated code and AI-generated fixes against the same policies, and correlates the results into a single view of application risk.

Checkmarx One is the unified, cloud-native application security platform for enterprises that need to secure code, applications, and AI-driven development at scale. It brings Fusion SAST, SCA, IaC Security, API Security, Checkmarx DAST, Container Security, and supply chain security together with ASPM and the Checkmarx Assist family of agentic AI agents. Because every finding lands in the same platform and data model, Checkmarx One applies consistent scanning, prioritization, and policy regardless of whether a developer, Codex, or another AI tool produced the code or the fix.

Checkmarx Triage & Remediation Assist extends the platform into the pull request. Triage Assist turns SAST and SCA scan output into clear, explainable verdicts, and Remediation Assist generates review-ready fixes directly inside GitHub pull requests, without bypassing human oversight.

Key capabilities of Checkmarx One and Triage & Remediation Assist:

  • Deterministic precision plus frontier AI: Fusion SAST runs deterministic rules alongside AI-based analysis in a single scan, reaching an F1 score of 0.64 against an industry average of roughly 0.20, and 0.74 with the Checkmarx Fusion multi-model layer. Its Findings Analysis Engine labels every finding rather than deleting it, so nothing is silently dropped. This is the complement reasoning-only tools need. 
  • Independent validation of AI-generated code and fixes: Checkmarx One scans every change with its own engines, so code and patches produced by Codex Security or other AI tools are tested against the same security rules as human-written code. A Codex remediation PR is scanned like any other pull request, helping catch fixes that close one issue but introduce another.
  • Correlated risk across scanners: ASPM correlates findings across code, open source, infrastructure, APIs, containers, and the supply chain, and prioritizes them by exploitability, reachability, and business context. Teams get one view of application risk instead of disconnected result lists.
  • Attackability-based triage in pull requests: Triage Assist classifies findings as False Positive, Acceptable Risk, or Action Required using exploitability and reachability signals in real code context, plus policy and business context. Each verdict can come with an evidence pack, such as code references, an ingress-to-impact narrative, and control checks, so decisions are verifiable and auditable.
  • Human approval for every fix: Remediation Assist delivers fixes as actionable diff blocks or a separate remediation PR, including dependency fixes for SCA findings.  Nothing merges automatically: fixes go through normal code review, approvals, and merge policies, and developers remain accountable for final changes. This is the same model recommended above for Codex Security remediation PRs.
  • Security inside Codex itself: Developer Assist runs as an official Codex CLI plugin, as well as in IDEs and other AI coding agents. It detects vulnerabilities as code is created, retrieves context from Checkmarx One, generates a fix, and rescans to verify it before commit. In supported autonomous workflows, it repeats that loop with the coding agent through hooks and MCP. It complements Codex Security’s repository and commit scanning by enforcing checks where AI-generated code is written.
  • SCA and DAST in the same platform: Checkmarx SCA identifies vulnerable open-source packages, Malicious Package Protection blocks malicious ones, and Checkmarx DAST tests the running application  from the outside. Their findings are prioritized alongside code-level results in Checkmarx One, covering dependency and runtime risks that Codex Security does not address.
  • Governance for AI-driven remediation: Developers review and merge each fix, while AppSec retains policy control and full traceability over every automated triage and remediation decision.