AI Coding Agents Are Creating a New CI/CD Attack Surface
AI Coding Agents Are Creating a New CI/CD Attack Surface: How to Secure the Agentic Software Supply Chain
Software development is entering a new phase. AI systems are no longer limited to generating code snippets or answering programming questions. Coding agents can inspect repositories, modify files, execute tests, investigate vulnerabilities, and propose fixes through automated development workflows.
This evolution creates an important security challenge: an AI agent can inherit the privileges of the development environment in which it operates, while processing content controlled by someone else.
A coding agent reviewing a pull request might encounter malicious instructions in source files, documentation, issue descriptions, test output, or dependency metadata. If the agent can also access credentials, execute shell commands, communicate with external services, or modify repository settings, an ordinary code review task can become a path to credential exposure or software supply-chain compromise.
This is not merely a theoretical concern about unreliable AI output. It is an architectural problem involving identity, authorization, execution isolation, untrusted input, and the trust boundaries of CI/CD.
In this article, we examine the threat model, the relevant 2026 developments, and a practical defensive architecture for organizations deploying AI agents in software engineering.
1. Why AI agent security is becoming a DevOps priority
Three developments make this issue particularly relevant.
1.1 AI agents are moving deeper into the software development lifecycle
On September 19, 2026, Google described an approach that integrates AI-assisted vulnerability detection into its infrastructure development process. The system examines code changes, uses specialized agents to assess findings, and applies structural validation to determine whether vulnerabilities are reachable. A separate process can propose fixes for human review. Google also described using code structure, call graphs, and repository-specific threat models to improve detection precision. Google Cloud
The architectural lesson is more important than any single model or vendor.
Rather than treating security scanning as a separate activity performed near release time, organizations can integrate security analysis into every development change.
A simplified workflow looks like this:
- A developer or coding agent proposes a change.
- An analysis agent examines the changed code and relevant context.
- Specialized validation checks whether potential findings are technically plausible.
- Automated tests and security scanners evaluate the proposed change.
- A remediation agent may suggest a correction.
- A human reviewer approves the final change before it reaches a protected branch or production.
This model can reduce the time between introducing a defect and detecting it. However, each additional automated capability creates a new question: what can the agent do if its instructions or interpretation are manipulated?
An agent that can only read code has a different risk profile from one that can read code, execute arbitrary commands, retrieve secrets, and merge changes.
The distinction should be reflected in system architecture, not left to the model's judgment.
1.2 Prompt injection can become an infrastructure security problem
Prompt injection occurs when untrusted content influences an AI system to deviate from its intended task or instructions.
In a coding workflow, the untrusted content does not need to arrive through a conventional chat prompt. It can be embedded in a repository file, pull request description, issue comment, build log, or other information consumed by an agent.
OWASP's July 8, 2026, GenAI and Agentic AI exploit roundup describes reported scenarios involving repository workflows, credential exposure, and excessive agent permissions. The report discusses how attacker-controlled content can redirect an agent's behavior when the surrounding workflow grants access to sensitive capabilities. These reports should be understood as documented security research, not as evidence that every AI coding agent is vulnerable or that every described scenario caused confirmed criminal losses. OWASP Gen AI Security Project
Consider a hypothetical code-review agent that reads a pull request and has access to a shell tool.
A malicious contributor places instructions inside a file that the agent is expected to inspect. The instructions attempt to persuade the agent to perform an unrelated action, such as locating credentials or transmitting data to an external endpoint.
If the agent has no sensitive credentials and cannot perform unrestricted network operations, the attempt has limited impact.
If the same agent has access to a privileged deployment token and unrestricted command execution, the consequences could be substantially more serious.
The critical distinction is that prompt injection is an input-manipulation risk, while excessive permissions turn that risk into an operational security incident.
A model's system prompt cannot replace authorization controls enforced outside the model.
1.3 CI/CD platforms are tightening workflow trust boundaries
On September 17, 2026, GitHub announced the general availability of workflow execution protections, including a default rule restricting pull_request_target in affected public repositories. GitHub's October 21 editorial update moved automatic enforcement for the affected repositories to December 2, 2026. This policy does not apply universally to all repositories, and maintainers should verify their repository's actual policy and evaluation status. The GitHub Blog
The underlying security concern predates AI agents.
GitHub documents how a workflow triggered by pull_request_target can run with the base repository's token and secrets. If that workflow checks out and executes untrusted pull-request code, attacker-controlled scripts may run in a privileged environment. GitHub Security Lab has documented this class of vulnerability as a pwn request. GitHub Docs
AI agents add another execution layer to this existing problem.
A workflow may appear safe because its automation is intended only to review or fix code. But if an agent can execute repository-controlled scripts or access privileged tools, the security implications can resemble those of an improperly isolated build job.
The lesson is straightforward: the trust level of the trigger, the content being processed, the agent's identity, and the permissions of its tools must be designed together.
2. Understanding the agentic CI/CD threat model
Traditional CI/CD security focuses on source-code integrity, dependency provenance, runner isolation, secrets management, and deployment permissions.
AI-assisted workflows need these controls, plus additional protections around model inputs and tool invocation.
A useful threat model separates the system into five components.
| Component | Primary risk | Recommended control |
|---|---|---|
| Untrusted inputs | Malicious instructions in code, issues, logs, or documentation | Treat external content as data, never as authorization |
| AI reasoning layer | Incorrect conclusions or prompt injection | Constrained tasks, explicit policies, independent validation |
| Tool execution layer | Unauthorized shell commands, API calls, or file operations | Allowlisted tools and restricted execution environments |
| Identity and secrets | Credential exposure or privilege escalation | Short-lived credentials and least privilege |
| Release pipeline | Unauthorized merges, deployments, or artifact promotion | Protected branches, deterministic checks, independent approval |
These components are interdependent.
For example, an agent might correctly identify a vulnerability but propose an unsafe fix. Alternatively, it might propose a technically sound patch after being manipulated into accessing unrelated files.
Security must therefore evaluate both the quality of the proposed code and the authority exercised while producing it.
The most important trust boundaries
Boundary A: External content to the agent
Everything originating from an untrusted pull request must remain untrusted, even if the model describes it as an instruction.
Boundary B: Agent to execution environment
The agent should not automatically receive unrestricted shell access merely because executing commands would make its task easier.
Boundary C: Agent to credentials
Repository read access does not justify access to production deployment keys, cloud administrator credentials, or organization-wide tokens.
Boundary D: Proposed changes to production
An agent's recommendation must not become an authorization decision. Independent controls should determine whether a change can be merged, released, or deployed.
This separation prevents a single model-level failure from automatically becoming a production-level compromise.
3. Attack scenario: when a code-review agent becomes a security liability
Consider a company that uses an AI agent to review external pull requests in a JavaScript or TypeScript repository.
The agent can:
- Read the entire repository.
- Execute tests and shell commands.
- Install dependencies.
- Access a private package registry.
- Comment on pull requests.
- Create branches and push fixes.
This configuration may appear productive, but it combines several trust levels in a single execution environment.
Step 1: An attacker submits a malicious contribution
The pull request contains an apparently ordinary code change. A modified documentation file or test fixture also contains instructions designed to manipulate the review agent.
The instructions are untrusted input. They have no legitimate authority to change the agent's permissions or redefine its approved task.
Step 2: The agent processes the malicious content
While analyzing the pull request, the agent encounters the embedded instructions.
A vulnerable agent may follow those instructions instead of maintaining its original task boundaries. Whether this happens depends on the model, agent framework, context, and available controls.
Step 3: The agent invokes an overly powerful tool
Suppose the agent can execute arbitrary commands and access a long-lived package-registry credential.
If it follows the malicious instructions, it may attempt to access sensitive data or send information outside the intended environment.
This is the critical transition: untrusted content has influenced an action that possesses real execution authority.
Step 4: The incident expands beyond the pull request
Depending on the permissions and environment, the impact might include:
- Exposure of package-registry credentials.
- Unauthorized repository changes.
- Access to additional internal resources.
- Modification of build artifacts.
- Attempts to interfere with deployment workflows.
These are potential consequences, not guaranteed outcomes. Network restrictions, token scope, runner isolation, and other controls may prevent or limit them.
The same general trust-boundary problem is relevant to ordinary CI workflows. GitHub's documentation explains that executing code from an untrusted pull request in a privileged pull_request_target workflow can expose repository secrets and write permissions. GitHub Docs
Step 5: Detection may be difficult without appropriate telemetry
If the system records only the final patch, investigators may not have enough information to determine whether the agent encountered malicious instructions, accessed a sensitive tool, or attempted an unauthorized action.
A production-grade agentic workflow should therefore record:
- The identity and origin of the triggering event.
- The repository commit and artifact versions involved.
- The agent and model configuration used.
- The tools requested and the actions actually executed.
- Authorization decisions and denied operations.
- Credential identities and relevant access events.
- The resulting changes and approval history.
Logs should exclude raw secrets and sensitive content that does not need to be retained.
The objective is to make the agent's behavior auditable without creating another repository of sensitive data.
4. A secure architecture for AI-powered development
A practical architecture separates the agent's reasoning capabilities from the systems that enforce security policy.
The following design can be implemented incrementally in a conventional CI/CD environment.
Layer 1: Isolate untrusted code
Run validation for external contributions in an isolated, preferably ephemeral environment.
The environment should have:
- No production credentials.
- No unrestricted access to internal services.
- A narrowly scoped repository token.
- Restricted network egress where practical.
- Resource limits and execution timeouts.
- A clean environment for each untrusted job.
Do not assume that a test suite is safe simply because it is part of the repository. Build scripts, dependency lifecycle hooks, test configuration, and other repository-controlled components may execute code.
GitHub explicitly warns against checking out and running untrusted pull-request code in privileged pull_request_target workflows. GitHub Docs
Layer 2: Give the agent task-specific tools
Instead of providing unrestricted access to a terminal and every connected service, expose a small set of capabilities.
For example:
| Tool | Recommended permission |
|---|---|
| Read source files | Read-only access to the target repository |
| Inspect a diff | Read-only |
| Run unit tests | Restricted sandbox |
| Run static analysis | Restricted sandbox |
| Propose a patch | Write to an isolated working branch |
| Comment on a pull request | Explicitly scoped API permission |
| Merge a pull request | Not available to the agent by default |
| Deploy to production | Separate, independently authorized workflow |
| Read production secrets | Not available to the review agent |
A tool broker can enforce these restrictions before each operation.
The broker should validate the requested action, target resource, parameters, and current authorization policy. It should not accept a model's assertion that an action is safe as sufficient authorization.
For sensitive actions, require a separate approval mechanism.
Layer 3: Separate identities and credentials
An agent should have a distinct identity rather than automatically inheriting a developer's or administrator's credentials.
Use separate identities for distinct responsibilities, such as:
- Code review.
- Vulnerability analysis.
- Patch generation.
- Release approval.
- Production deployment.
Where supported, use short-lived credentials, narrowly scoped tokens, and explicit audience restrictions.
For cloud deployments, workload identity federation can reduce the need for long-lived cloud credentials in CI/CD. It does not eliminate the need for authorization policies or restrict what trusted workflow code can do after obtaining a credential.
The National Institute of Standards and Technology highlighted the identity and authorization challenges of software agents in its February 5, 2026, concept paper on software-agent identity. Its broader AI Agent Standards Initiative, announced February 17, 2026, also addresses secure and interoperable agent ecosystems. These initiatives reinforce the importance of treating agents as identifiable principals with explicit authority. NIST
Layer 4: Validate results deterministically
AI can help identify vulnerabilities and propose fixes, but its conclusions should not be the only release gate.
Combine agent analysis with established security engineering controls:
- Static application security testing.
- Dependency and software-composition analysis.
- Secret scanning.
- Infrastructure-as-code scanning.
- Unit and integration tests.
- Type checking and linting.
- Structural analysis of potentially vulnerable code paths.
- Independent review of high-risk changes.
Google's September 2026 description of its infrastructure security pipeline provides a useful example: AI-assisted findings are checked using code structure, call graphs, and specialized triage rather than relying exclusively on a model's initial judgment. Google Cloud
The principle is to use AI to expand analytical coverage while retaining independent verification.
Layer 5: Keep production authorization outside the agent
The agent may propose a patch, but it should not automatically decide that its own patch is safe to deploy.
A safer release sequence is:
- The agent creates a proposed change.
- The change enters the normal review process.
- Independent tests and security checks run.
- Required reviewers approve the change.
- Protected deployment controls authorize release.
- Runtime monitoring evaluates the deployed system.
This creates a separation between generating a recommendation and authorizing a consequential action.
5. Practical implementation: hardening a GitHub Actions workflow
The following example demonstrates a safer starting point for validating pull requests in a Node.js project.
It uses the ordinary pull_request event, limits the repository token to read-only access, and prevents the checkout action from persisting its authentication credentials in the working directory.
name: Pull Request Validationon:pull_request:types: [opened, synchronize, reopened]permissions:contents: readjobs:validate:name: Validate Untrusted Contributionruns-on: ubuntu-latesttimeout-minutes: 15permissions:contents: readsteps:- name: Checkout sourceuses: actions/checkout@v6with:persist-credentials: false- name: Set up Node.jsuses: actions/setup-node@v6with:node-version: "22"- name: Install dependenciesrun: npm ci- name: Run testsrun: npm test- name: Run static analysisrun: npm run lint
Important: Pin third-party actions to verified full commit SHAs in production, rather than relying on mutable version tags. Review the chosen action versions and compatibility with the repository before adopting the example.
The workflow illustrates several important controls:
- Least privilege: The job receives only the repository content permission declared here.
- Credential handling:
persist-credentials: falseprevents checkout credentials from being persisted by the action for later Git commands. - No explicit application secrets: The example does not pass production or package-registry secrets to build steps.
- Timeout: The job has a bounded execution duration.
- Untrusted code remains untrusted: Running tests may execute repository-controlled scripts, so the job still needs an appropriately isolated environment.
GitHub documents the behavior of pull_request workflows and the risks of executing untrusted code in privileged workflows in its security guidance. GitHub Docs
Why this workflow is not sufficient for every project
A private dependency registry, deployment integration, or agent framework may require additional credentials or permissions.
Do not solve that problem by adding broad secrets to the same job that executes untrusted code.
Instead, consider:
- Using a controlled dependency mirror or credential broker.
- Separating dependency retrieval from untrusted build execution where feasible.
- Giving privileged operations their own workflow and identity.
- Ensuring that artifacts from untrusted jobs are treated as untrusted data.
- Requiring independent authorization before privileged workflows consume artifacts or modify repositories.
A second workflow is not automatically safe just because it uses a different trigger. If it downloads and executes attacker-controlled artifacts with access to secrets, the same trust-boundary problem can reappear.
Adding an AI review agent
An AI review step should be introduced only after the underlying execution environment has been appropriately restricted.
A safer agent design would permit:
- Reading the patch and relevant source files.
- Identifying potential vulnerabilities.
- Explaining the evidence supporting each finding.
- Proposing a patch as an artifact or isolated branch.
- Returning a structured result for independent validation.
It should not automatically receive permission to read secrets, merge code, alter security settings, or deploy to production.
If the agent requires shell access, place that capability behind an execution service with explicit command policies, resource restrictions, and audit logging. Do not rely exclusively on the agent's instructions to prevent dangerous commands.
The resulting architecture is more resilient because the agent's authority is constrained even when its reasoning fails.
6. The December 2026 GitHub Actions change: What maintainers should do now
GitHub's September 17 announcement, updated on October 21, 2026, identifies December 2, 2026, as the enforcement date for its default pull_request_target restriction in affected public repositories. The change is not a universal ban: repositories with applicable policies can explicitly allow the event. Maintainers should review the latest announcement and their repository's policy status rather than assuming their workflows are unaffected. The GitHub Blog
Recommended audit procedure
Step 1: Inventory workflow triggers
Search workflow files for:
pull_request_targetworkflow_runissue_commentworkflow_dispatch
These triggers are not inherently unsafe. Their security depends on what the workflow does, which identities can initiate it, and what permissions it receives.
Step 2: Identify untrusted execution
Look for workflows that:
- Check out code from external pull requests.
- Run build scripts or tests supplied by contributors.
- Install dependencies from untrusted changes.
- Execute AI-generated commands.
- Download artifacts from less-trusted workflows and execute them.
Step 3: Review credentials and permissions
Determine whether each job can access repository secrets, cloud credentials, private package tokens, write-enabled GitHub tokens, or internal services.
Remove unnecessary permissions. Separate jobs that process untrusted contributions from those that need privileged access.
Step 4: Review the agent's tool access
For every coding or review agent, document which tools it can call and which resources those tools can access.
An agent that can only inspect code should not silently gain write permissions because another workflow component needs them.
Step 5: Verify enforcement and test the replacement
Review the GitHub Actions policy evaluation results for affected repositories. Replace unnecessary uses of pull_request_target with a suitable lower-privilege workflow where possible.
Test the new workflow using controlled pull requests and confirm that it does not expose secrets, execute untrusted code in a privileged context, or break required validation.
GitHub's official workflow execution protections announcement and secure usage documentation provide the relevant implementation details. The GitHub Blog
7. Advanced defensive strategies for production AI agents
Basic workflow hardening is necessary, but organizations operating autonomous agents at scale need additional controls.
7.1 Treat retrieved content as untrusted, regardless of its source
An agent may consume code, tickets, logs, documentation, monitoring events, and outputs from connected services.
Content originating from an authenticated service is not necessarily trustworthy. An attacker might control a ticket, influence a log entry, or submit a malicious pull request through a legitimate account.
Record the provenance of inputs and maintain a clear distinction between:
- Instructions defined by the application.
- Authorization policies enforced by the platform.
- Data retrieved from external systems.
- Recommendations generated by the model.
Retrieved data must never independently grant permissions or override the system's security policy.
7.2 Make tool authorization independent of model reasoning
Suppose an agent requests permission to execute a deployment operation.
The authorization service should evaluate the authenticated agent identity, requested action, target environment, current policy, and required approval state.
The request should be denied if any required condition is not satisfied.
This approach is stronger than asking the model whether the deployment is safe because authorization decisions are enforced independently of the model's output.
7.3 Use policy-based egress controls
An agent with access to internal files may also have network access.
Even if its filesystem permissions are restricted, unrestricted outbound connectivity can create a channel for data exfiltration.
For sensitive environments:
- Restrict outbound traffic to approved destinations.
- Use an authenticated proxy or controlled egress gateway.
- Block access to unnecessary internal network ranges.
- Restrict cloud metadata service access where appropriate.
- Monitor unusual outbound requests.
- Separate development, staging, and production network access.
Network restrictions should be enforced outside the model and should remain effective even if the agent executes an unexpected command.
7.4 Test the complete system, not only the model
AI red teaming should examine how the model interacts with its tools, identities, data sources, and execution environment.
Useful test scenarios include:
| Test | Expected defensive behavior |
|---|---|
| Malicious instructions in a pull request | Agent treats them as untrusted content |
| Request to read an unavailable secret | Access is denied by the execution environment |
| Attempt to invoke an unauthorized tool | Tool broker rejects the request |
| Unexpected outbound connection | Network policy blocks or alerts on the attempt |
| Agent proposes an unsafe patch | Independent checks fail or a reviewer rejects it |
| Artifact from an untrusted workflow | Consumer validates and treats it as untrusted |
| Attempted production deployment | Separate authorization policy prevents unauthorized release |
These are proposed defensive tests, not claims that any particular product automatically passes them.
The OWASP GenAI Security Project provides a useful starting point for assessing risks associated with prompt injection, excessive agency, and sensitive information disclosure. OWASP Foundation
8. A practical 30-day implementation roadmap
Organizations do not need to replace their development platforms to begin securing AI-assisted development.
A staged implementation is usually more practical.
| Period | Priority | Deliverable |
|---|---|---|
| Days 1–7 | Discovery | Inventory coding agents, workflow triggers, connected tools, and credentials |
| Days 8–14 | Containment | Remove unnecessary secrets, restrict token permissions, and isolate untrusted execution |
| Days 15–21 | Verification | Add deterministic security checks, artifact validation, and authorization tests |
| Days 22–30 | Governance | Establish audit logging, human approval requirements, and agent-specific security policies |
Suggested security metrics
Track measurable outcomes rather than relying on the number of AI-generated reviews.
Security metrics
- Percentage of agent workflows with explicitly declared permissions.
- Number of privileged credentials available to untrusted jobs.
- Number of workflows that execute untrusted code with privileged access.
- Percentage of production deployments protected by independent authorization.
- Number of unauthorized tool requests blocked.
Engineering metrics
- Median time from vulnerability introduction to detection.
- Median time from confirmed finding to remediation.
- Percentage of agent findings validated by independent checks.
- False-positive rate of automated security findings.
- Percentage of agent-generated patches that pass the required test suite.
Metrics should be interpreted together. For example, a reduction in reported vulnerabilities might indicate improved code quality, but it could also reflect incomplete scanning or reduced detection coverage.
9. What is confirmed, and what remains uncertain?
A technically responsible analysis should distinguish current evidence from predictions.
Confirmed developments
- AI-assisted infrastructure security: Google described an agent-based approach to continuous vulnerability detection, structural validation, and proposed fixes in September 2026. These are Google's reported implementation details, not an independent guarantee of identical results in other environments. Google Cloud
- Agentic AI security risks: OWASP's 2026 exploit roundup documents reported scenarios involving prompt injection, tool misuse, excessive permissions, and sensitive information exposure. The scenarios do not establish that every agent framework is affected. OWASP Gen AI Security Project
- CI/CD trust-boundary protections: GitHub has announced additional workflow execution protections and an enforcement timeline for affected public repositories. Maintainers must verify which policies apply to their own repositories. The GitHub Blog
- Agent identity and authorization: NIST has published initiatives addressing secure and interoperable AI agents and the identity and authority of software agents. NIST
Reasonable projections
The following are engineering forecasts rather than established outcomes:
- AI agents will likely become more deeply integrated into code review, remediation, and release engineering.
- Agent-specific identity, authorization, and auditability are likely to become more important as organizations deploy agents across multiple services.
- Security teams will likely need to expand their existing CI/CD threat models to include model inputs, tool calls, and agent-generated artifacts.
- Organizations that combine AI analysis with independent verification may be better positioned to improve security coverage without granting agents unrestricted authority.
The pace and extent of adoption will vary by organization, platform, and regulatory environment. These projections should be reassessed as new technical evidence becomes available.
Conclusion: Secure the authority, not just the model
AI coding agents can help development teams identify vulnerabilities earlier, investigate complex codebases, and accelerate remediation. They can also introduce new pathways between untrusted input and privileged execution if their permissions are not carefully constrained.
The appropriate response is not to abandon AI-assisted development. It is to apply established security engineering principles to the new execution model.
Treat external content as untrusted. Give each agent only the authority required for its task. Isolate code execution. Keep credentials out of untrusted environments. Validate proposed fixes independently. Require explicit authorization for consequential actions, and preserve sufficient audit data to investigate failures.
Most importantly, do not make the model responsible for enforcing its own security boundaries.
The future of secure AI-driven DevOps depends on combining intelligent automation with deterministic controls, least-privilege identities, and independently enforced release policies.
For teams adopting coding agents today, that architecture is a practical foundation for scaling automation without making the software supply chain unnecessarily fragile.
SEO and publication package
SEO title: AI Coding Agent Security: Protecting CI/CD Pipelines in 2026
Meta description: Learn how to secure AI coding agents, GitHub Actions, cloud identities, and CI/CD pipelines against prompt injection, credential exposure, and software supply-chain attacks.
Suggested URL slug: ai-coding-agent-security-ci-cd-2026
Primary keyword: AI coding agent security
Secondary keywords:
- AI agent security
- CI/CD pipeline security
- GitHub Actions security
- AI prompt injection
- Software supply-chain security
- DevSecOps automation
- Least-privilege access control
- AI vulnerability detection
- Cloud identity security
- Agentic AI security
Suggested category: AI Security / DevSecOps
Suggested tags: Artificial Intelligence, Cybersecurity, DevOps, CI/CD, Cloud Security, GitHub Actions, Application Security, Supply Chain Security
Target audience: Security engineers, DevSecOps professionals, cloud architects, software engineers, and technical leaders deploying AI agents.
Suggested difficulty: Advanced
Suggested reading time: 12–15 minutes
Suggested diagrams
Diagram 1 — Agentic CI/CD security architecture
Show the pull request entering an isolated validation environment, followed by the analysis agent, restricted tool broker, deterministic security checks, human approval, and protected deployment pipeline. Mark trust boundaries and show that production credentials are unavailable to the analysis agent.
Diagram 2 — Prompt injection and privilege escalation
Illustrate the difference between an untrusted instruction entering an agent and the potential consequences when that agent has excessive permissions. Show how restricted tools, short-lived credentials, and network controls interrupt the chain.
Diagram 3 — Secure AI-assisted remediation lifecycle
Illustrate the sequence:
Code Change → AI Analysis → Independent Validation → Proposed Fix → Human Review → Protected Release
Show the authorization service and audit logging as cross-cutting controls.
Primary references
- Google: Using AI Agents to Secure Infrastructure — September 19, 2026.
- GitHub: Workflow Execution Protections Generally Available — September 17, 2026; updated October 21, 2026.
- GitHub Actions: Securely Using `pull_request_target` — Official workflow security guidance.
- OWASP: GenAI and Agentic AI Exploit Roundup, Q2 2026 — July 8, 2026.
- NIST: AI Agent Standards Initiative — February 17, 2026.
- NIST: Identity and Authority of Software Agents — February 5, 2026.
- OWASP GenAI Security Project — Guidance on generative AI and agentic system security.
Author
Discussion · 0
No comments yet — start the discussion.
Sign in to join the discussion.