---
title: "OpenAI Symphony Security: Governing Codex Agents That Take Work From Your Issue Tracker | Anomity Blog"
description: "OpenAI's open-source Symphony gives every open ticket its own Codex agent. How it works, what its spec leaves to you, and how to secure orchestrated coding agents."
url: "https://anomity.ai/blog/openai-symphony-codex-orchestration-security/"
source: html
---

OpenAI Symphony Security: Governing Codex Agents That Take Work From Your Issue Tracker

Contents

- What OpenAI Symphony is
- How Symphony runs one agent per ticket
- The security model Symphony leaves to you
- The ticket is the prompt: prompt injection through issues
- Credentials and tokens: what stays on the host
- MCP servers, skills and tools the agents inherit
- Audit trails and visibility
- A hardening checklist for orchestrated coding agents
- How Anomity fits
- Frequently asked questions

0%

10 min read

Share

- X.com

- LinkedIn

- Email

- Copy URL

- Copy markdown

[← Back to blog](https://anomity.ai/blog/)

- Home

- Blog

- OpenAI Symphony Security: Governing Codex Agents That Take Work From Your Issue Tracker

![Anomity robot illustrating OpenAI Symphony Security: Governing Codex Agents That Take Work From Your Issue Tracker]

Guide

# OpenAI Symphony Security: Governing Codex Agents That Take Work From Your Issue Tracker

Anomity Research
Anomity Research
·
Nov 13, 2026
·
10 min read

Share: Copied

TL;DR

- Symphony is an open-source spec and Elixir reference implementation from OpenAI that turns an issue tracker into a control plane for coding agents: it polls the board, gives each active ticket its own workspace and Codex agent , restarts stalled runs, and stops a run when its ticket closes. OpenAI says it saw a 500% increase in landed pull requests on some internal teams.
- OpenAI calls it a reference implementation , not a product it will maintain. The repository describes it as an engineering preview for trusted environments , and the Elixir README calls its code a prototype for evaluation, recommending you build your own hardened version from SPEC.md .
- The spec deliberately does not mandate a sandbox, approval or operator-confirmation policy. The Elixir build falls back to workspace-write with approval requests rejected when settings are omitted, but the sample WORKFLOW.md in the repo uses approval_policy: never , network access on , and Codex inheriting the full shell environment .
- The ticket text becomes the agent's prompt, so anyone who can write to an eligible ticket can steer an agent. The spec itself warns that tracker data, repository content and tool arguments should not be treated as trustworthy, and that a permissive setup can lead to data leaks, destructive changes or full machine compromise .
- Tracker tokens are kept host-side and removed from the Codex child's environment, which is a good pattern. But each raw tracker tool can reach whatever its token can reach , and everything else the agent uses, from gh logins to Codex's own MCP servers and skills, comes from the host. Inventory those hosts, scope the tokens, and keep an audit trail that outlives the orchestrator's in-memory state.

On April 27, 2026, OpenAI published an open-source spec for Codex orchestration called Symphony. The idea is simple to state: stop supervising coding agents session by session, and let them pull work from the issue tracker instead. Every open ticket gets an agent, the agents keep running, and people review what comes back. This guide explains how Symphony works, based on OpenAI's post and the openai/symphony repository, and then looks at what changes for security teams when coding agents run unattended, in parallel, from a board that many people can write to.

## What OpenAI Symphony is

OpenAI's team built Symphony after moving to a repository where Codex wrote all the code. The new bottleneck was human attention: according to the post, engineers could comfortably juggle three to five interactive Codex sessions before context switching hurt. Symphony removes the sessions from the picture. A project board, Linear in OpenAI's setup, becomes the control plane, ticket states act as a state machine, and the orchestrator makes sure every active ticket has an agent working on it. OpenAI reports a 500% increase in landed pull requests on some teams.

The project is mostly a document. The heart of the repository is `SPEC.md`, a language-agnostic definition of the service, and OpenAI suggests pointing a coding agent at it to build your own version. There is also an Elixir reference implementation. OpenAI says it does not plan to maintain Symphony as a standalone product, and the repository labels it an engineering preview for testing in trusted environments. Agents are driven through Codex App Server, the headless mode that exposes Codex over a JSON-RPC interface.

## How Symphony runs one agent per ticket

- Poll. On a fixed interval, Symphony asks the tracker for issues in the configured active states, such as Todo, In Progress or Rework, and dispatches them up to a concurrency limit.
- Isolate. Each issue maps to its own directory under a workspace root. A repository-defined after_create hook typically clones the code into it.
- Prompt. Symphony renders the issue's identifier, title, description, labels and URL into a prompt template taken from WORKFLOW.md , a file that lives in your repository alongside the code.
- Run. It launches Codex in app-server mode with that workspace as its working directory and keeps it going, up to a turn limit, while the ticket stays active. Crashed or stalled runs are retried with backoff.
- Hand off or stop. The agent itself moves tickets, posts comments and opens pull requests using the tools it is given. When a ticket reaches a terminal state such as Done or Cancelled, Symphony stops its agent and cleans up the workspace.

OpenAI's post describes giving its agents more than code editing: the `gh` CLI and skills for reading CI logs, so they could open several pull requests, respond to review feedback and close stale work. The team moved toward giving agents objectives rather than fixed transitions. That is where much of the productivity comes from, and it is also what makes the security model matter.

## The security model Symphony leaves to you

Symphony's spec is unusually direct about this. It requires that agent workspaces stay under the configured root, that the agent's working directory is the per-issue workspace, and that directory names are sanitized. Beyond that, it lists "mandating strong sandbox controls beyond what the coding agent and host OS provide" as a non-goal and asks every implementation to document whether it relies on auto-approval, operator approvals or stricter sandboxing. The defaults depend on which implementation and which config you run:

Setting Elixir implementation, if omitted Sample WORKFLOW.md in the repo

`codex.approval_policy` Reject sandbox approvals, rule prompts and MCP elicitations `never`

`codex.thread_sandbox` `workspace-write` `workspace-write`

Turn sandbox Writes limited to the issue workspace, read access to the full filesystem, `networkAccess: false` `workspaceWrite` with `networkAccess: true`, passed to Codex as written

Codex shell environment Codex default `shell_environment_policy.inherit=all`

Concurrency and turns 10 concurrent agents, 20 turns per run 10 concurrent agents, 20 turns per run

Sources: the configuration section of the Elixir README, the sample WORKFLOW.md and the Elixir config schema in the repository. Note that even the restrictive default limits where the agent can write, not what it can read: files elsewhere on the host, including credentials in the user's home directory, stay readable. In Codex's configuration reference, `shell_environment_policy.inherit` controls which environment variables a spawned process starts with, and `all` passes everything through. The sample file is what many teams will copy first, so it is worth reading it as a high-trust profile rather than a baseline. Workspace hooks deserve the same care: the spec calls them arbitrary shell scripts from `WORKFLOW.md` that are fully trusted, so whoever can change that file can change what runs on the orchestrator host.

If you have already tuned interactive Codex, the same levers apply here, and our guides to [Codex sandbox modes and approval policies](https://anomity.ai/blog/securing-openai-codex-sandbox-and-approvals-guide/) and [Codex full-access mode and the trust boundary](https://anomity.ai/blog/openai-codex-full-access-trust-boundary/) cover them in depth. The difference is that nobody is watching the terminal, so an approval prompt either blocks the run or has been switched off.

## The ticket is the prompt: prompt injection through issues

In an interactive session, a developer decides what to paste into the agent. In Symphony, the ticket author does. Any text in an eligible issue's title or description reaches an agent that can run commands, call the tracker API and, in many setups, push to GitHub. Comments, linked pages and repository files the agent reads along the way are further input. Symphony's spec, section 15.5, says plainly that implementations should not treat tracker data, repository contents, prompt inputs or tool arguments as trustworthy, and that a permissive deployment can lead to data leaks, destructive mutations or full machine compromise.

This is not a documented Symphony vulnerability. It is the familiar combination of untrusted input, private data and a way to act, described in our post on [the lethal trifecta in production agents](https://anomity.ai/blog/lethal-trifecta-production-agent-exfiltration/), now running on a schedule. Untrusted text has already reached Codex's command paths before, as in the [Codex branch-name command injection that exposed GitHub tokens](https://anomity.ai/blog/openai-codex-branch-name-command-injection-github-token-theft/). Practical controls from the spec include restricting which projects, boards, teams and labels can dispatch work. The Elixir build supports `tracker.required_labels`, so an issue only runs if someone has added an agreed label, which turns dispatch into a deliberate act. Boards that accept tickets from customers, integrations or form submissions should never feed an agent directly.

## Credentials and tokens: what stays on the host

Symphony handles the tracker credential well. OpenAI's post explains that instead of giving agents a Linear MCP server or the token itself, it exposes a `linear_graphql` function through Codex dynamic tool calls. The Elixir implementation runs each tracker tool in the orchestrator process with the configured credential and unsets the declared token variables before it starts Codex. The spec makes this a requirement: tracker credentials must not pass through the agent's environment, and literal tokens must not sit in a `WORKFLOW.md` the agent can read.

Two gaps remain. First, keeping the token hidden is not the same as limiting it. The README says each raw tool can access whatever its credential can access: for Linear, the configured project scopes Symphony's own reads, not the agent's GraphQL calls, and Asana tool calls are not limited to the configured project. A personal Linear key from an admin hands every agent that admin's reach. Use a dedicated service identity with the narrowest scope the tracker allows. Second, every other credential on the host is outside this mechanism. A `gh` login, cloud CLI profiles, package registry tokens and anything in the shell environment are reachable by the agent, and with `inherit=all` they are passed straight in. For more on this pattern, see our guide to [secrets management for AI agents](https://anomity.ai/blog/secrets-management-for-ai-agents/).

## MCP servers, skills and tools the agents inherit

Symphony launches the ordinary `codex` binary as the host user. Whatever that Codex installation is configured with, such as MCP servers, skills, plugins and model settings, applies to every ticket the orchestrator runs, alongside the tools and skills the repository itself provides. OpenAI's post notes that its agents rely on the harness of skills and context built into its repository. That makes the orchestrator host one of the most capable machines in the company: a single place where an MCP server with production access, or a skill pulled from a public registry, is exercised many times a day without a person reviewing each call.

Symphony's spec also defines an optional SSH worker extension that runs agents on a pool of remote hosts. Its own list of problems to consider starts with environment drift: each host needs the expected agent binary, authentication and prerequisites. In security terms, every worker is another machine whose agent configuration, MCP servers and stored credentials need to be known and kept consistent.

## Audit trails and visibility

The spec requires structured logs and recommends a runtime snapshot; the Elixir build adds an optional dashboard and a JSON API under `/api/v1/`. When Codex asks for operator input, approval or an MCP elicitation, the Elixir build keeps the issue claimed and marks it blocked. Its README notes that this blocked state lives in memory only and is cleared on restart, after which the issue can be dispatched again. The orchestrator's view is built for operating the system, not as a security record.

The questions a security team will be asked after an incident are different. Which machines were running agents? Which MCP servers and skills were configured on them? Which credentials could they reach? What did a given agent run, and on whose instruction? Pull requests and ticket comments show results. They do not show the commands, tool calls and configuration that produced them.

## A hardening checklist for orchestrated coding agents

- Run on dedicated hosts or VMs under a dedicated OS user, with the workspace root on its own restricted volume, as the spec recommends. Do not run an orchestrator on a developer's daily laptop.
- Start from the restrictive defaults , not the sample WORKFLOW.md . Turn on network access only where builds need it, and prefer an egress allowlist to open internet.
- Gate dispatch with required_labels and a narrow project, team or board scope, so only reviewed tickets reach an agent.
- Scope every token. Use a service identity for the tracker, a fine-grained or app-based GitHub credential limited to the target repositories, and nothing else in the agent's environment. Avoid inherit=all .
- Treat WORKFLOW.md and its hooks as code that runs with privilege. Protect them with code owners and required review.
- Pin the agent's MCP servers and skills on orchestrator hosts, and review changes to them the way you review dependency changes.
- Keep humans at the merge. Use a handoff state such as Human Review and branch protection so agent pull requests cannot land without approval.
- Ship logs off the host and keep them longer than the orchestrator's memory.

For a broader rollout plan, our [Codex fleet governance guide](https://anomity.ai/blog/rolling-out-openai-codex-fleet-governance-guide/) covers managed configuration, and [OpenAI's Agents API and the managed harness](https://anomity.ai/blog/openai-agents-api-managed-harness-governance/) looks at the same governance questions when the harness moves to the vendor.

## How Anomity fits

Symphony makes it easy to go from a few agents on a few laptops to many agents on any machine with a tracker token. You cannot govern what you cannot see. Anomity's lightweight **Endpoint Sensor** runs on managed Windows, macOS and Linux machines and inventories AI agents, MCP servers, extensions, plugins, skills, hooks, CLIs and secrets. Applied to orchestrator and worker hosts, that shows where the Codex CLI runs, which MCP servers and skills it is configured with, and which plaintext credentials it could reach. The sensor sends metadata only, never source code or prompts, and redacts secrets on the endpoint ([fleet inventory](https://anomity.ai/#features)).

On agents that expose a hook, Anomity can **allow, deny or log** each tool call before it runs ([runtime governance](https://anomity.ai/#runtime-governance)), and every decision and configuration change lands in a queryable **90-day audit trail** that routes to your SIEM, Slack, email or Jira ([outcomes](https://anomity.ai/#outcomes)). That gives you a record that survives an orchestrator restart. Anomity is SOC 2 Type II and complements your EDR, DLP and GRC tooling rather than replacing it. To see which machines in your fleet are running coding agents and what they can reach, [book a 30-minute demo](https://anomity.ai/#early-access).

Share: Copied

## Frequently asked questions

What is OpenAI Symphony?
Symphony is an agent orchestrator that OpenAI open-sourced under the Apache 2.0 license. It continuously reads work from an issue tracker, creates an isolated workspace for each eligible issue, and runs a Codex session in that workspace until the work reaches a handoff state such as Human Review. The core of the project is a language-agnostic SPEC.md; OpenAI also publishes an experimental Elixir implementation and encourages teams to have a coding agent build their own version from the spec.

Which issue trackers does Symphony support?
The OpenAI announcement and the spec are written around Linear. The Elixir reference implementation's README lists adapters for Linear, GitHub Issues, Jira Cloud, Asana and GitLab, each exposing a provider-native tool to the agent: linear_graphql, github_api, jira_rest, asana_api and gitlab_api.

Does Symphony sandbox the coding agents it runs?
Only partly, and by design. The spec requires each agent's working directory to be its own per-issue workspace under a configured root, with sanitized directory names, but it explicitly does not mandate sandbox or approval controls beyond what Codex and the host OS provide. Each implementation is expected to document its own posture. The Elixir build defaults to Codex's workspace-write sandbox with approval requests rejected when you omit the settings, while the sample WORKFLOW.md in the repository sets approval_policy to never and turns network access on.

Can a ticket prompt-inject a Symphony agent?
The ticket's title, description, labels and URL are rendered into the prompt the agent receives, so ticket content is agent input. Symphony's spec tells implementers not to assume tracker data, repository contents, prompt inputs or tool arguments are trustworthy just because they come from a normal workflow, and suggests filtering which projects, labels or boards can dispatch work. We are not aware of a documented vulnerability in Symphony itself; the risk is the general one of letting untrusted text drive an agent that holds credentials and can run commands.

How does Symphony handle tracker credentials?
Symphony runs the tracker tools in its own host process with the configured credential and unsets the declared token environment variables before launching Codex, so the agent can call the tracker without seeing the token. The README warns not to put a literal token in a repository-owned WORKFLOW.md the agent can read. The limit is scope: the README says raw tool calls can reach whatever the configured token can access, and for Linear and Asana the configured project scopes the scheduler's reads, not the agent's tool calls.

Is Symphony ready for production use?
OpenAI positions it as a reference implementation it does not plan to maintain as a standalone product. The repository README calls it an engineering preview for trusted environments, and the Elixir README describes the implementation as prototype software for evaluation that is presented as-is. Teams that adopt the pattern should treat hardening as their own work.

How does Anomity help teams running orchestrated coding agents?
Anomity's Endpoint Sensor inventories the AI artifacts on each managed Windows, macOS and Linux machine, including coding agents such as the Codex CLI, the MCP servers in their configs, skills, plugins, hooks, and plaintext secrets it recognizes, sending metadata only with secrets redacted on the endpoint. That shows which machines run agents, how they are configured, and what they could reach. On agents that expose a hook, Anomity can allow, deny or log a tool call before it runs, and decisions land in a 90-day audit trail that routes to SIEM, Slack, email or Jira.

## Related posts

[Insights ### OpenAI's Harness Engineering Playbook - What It Means for Securing Codex Agents OpenAI built a product with zero hand-written code by engineering the harness around Codex. What harness engineering is and how to secure and govern it. Anomity Research · Nov 13, 2026 · 9 min](https://anomity.ai/blog/openai-harness-engineering-codex-security-governance/)

[Research ### A GitHub Issue Could Steer OpenAI's Codex Toward Its Own npm Release - The Depi Chain Explained Depi showed how a GitHub issue fed to OpenAI's Codex labeler could lead to the credentials needed to publish @openai/codex on npm. What happened, what to change. Anomity Research · Nov 12, 2026 · 8 min](https://anomity.ai/blog/openai-codex-issue-labeler-prompt-injection-npm-publishing-chain/)

[Guide ### OpenAI Codex Use Cases: A Practical Guide for Engineering Teams (2026) A practitioner guide to OpenAI Codex use cases - PR review, refactors, migrations, security scans - and the sandbox and approval settings each one needs. Anomity Research · Jun 4, 2026 · 9 min](https://anomity.ai/blog/openai-codex-use-cases-guide/)

## Structured data

```json
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "OpenAI Symphony Security: Governing Codex Agents That Take Work From Your Issue Tracker",
  "description": "OpenAI's open-source Symphony gives every open ticket its own Codex agent. How it works, what its spec leaves to you, and how to secure orchestrated coding agents.",
  "datePublished": "2026-11-13",
  "dateModified": "2026-11-13",
  "author": {
    "@type": "Person",
    "name": "Anomity Research",
    "jobTitle": "Anomity Research"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Anomity",
    "url": "https://anomity.ai/",
    "sameAs": [
      "https://www.linkedin.com/company/anomity",
      "https://github.com/Anomity-ai",
      "https://www.wikidata.org/wiki/Q140763940"
    ],
    "logo": {
      "@type": "ImageObject",
      "url": "https://anomity.ai/anomity-logo.png"
    }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://anomity.ai/blog/openai-symphony-codex-orchestration-security/",
    "relatedLink": [
      "https://anomity.ai/blog/openai-harness-engineering-codex-security-governance/",
      "https://anomity.ai/blog/openai-codex-issue-labeler-prompt-injection-npm-publishing-chain/",
      "https://anomity.ai/blog/openai-codex-use-cases-guide/"
    ]
  },
  "image": {
    "@type": "ImageObject",
    "url": "https://anomity.ai/assets/blog/covers/coding-agents.jpg",
    "width": 1200,
    "height": 630
  },
  "articleSection": "Guide",
  "wordCount": 1960,
  "timeRequired": "PT10M",
  "inLanguage": "en",
  "url": "https://anomity.ai/blog/openai-symphony-codex-orchestration-security/",
  "keywords": "OpenAI Symphony security, OpenAI Symphony, OpenAI Codex, Codex App Server, Agent Orchestration, Prompt Injection, Coding Agents, Sandboxing, agentic AI security"
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is OpenAI Symphony?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Symphony is an agent orchestrator that OpenAI open-sourced under the Apache 2.0 license. It continuously reads work from an issue tracker, creates an isolated workspace for each eligible issue, and runs a Codex session in that workspace until the work reaches a handoff state such as Human Review. The core of the project is a language-agnostic SPEC.md; OpenAI also publishes an experimental Elixir implementation and encourages teams to have a coding agent build their own version from the spec."
      }
    },
    {
      "@type": "Question",
      "name": "Which issue trackers does Symphony support?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "The OpenAI announcement and the spec are written around Linear. The Elixir reference implementation's README lists adapters for Linear, GitHub Issues, Jira Cloud, Asana and GitLab, each exposing a provider-native tool to the agent: linear_graphql, github_api, jira_rest, asana_api and gitlab_api."
      }
    },
    {
      "@type": "Question",
      "name": "Does Symphony sandbox the coding agents it runs?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Only partly, and by design. The spec requires each agent's working directory to be its own per-issue workspace under a configured root, with sanitized directory names, but it explicitly does not mandate sandbox or approval controls beyond what Codex and the host OS provide. Each implementation is expected to document its own posture. The Elixir build defaults to Codex's workspace-write sandbox with approval requests rejected when you omit the settings, while the sample WORKFLOW.md in the repository sets approval_policy to never and turns network access on."
      }
    },
    {
      "@type": "Question",
      "name": "Can a ticket prompt-inject a Symphony agent?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "The ticket's title, description, labels and URL are rendered into the prompt the agent receives, so ticket content is agent input. Symphony's spec tells implementers not to assume tracker data, repository contents, prompt inputs or tool arguments are trustworthy just because they come from a normal workflow, and suggests filtering which projects, labels or boards can dispatch work. We are not aware of a documented vulnerability in Symphony itself; the risk is the general one of letting untrusted text drive an agent that holds credentials and can run commands."
      }
    },
    {
      "@type": "Question",
      "name": "How does Symphony handle tracker credentials?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Symphony runs the tracker tools in its own host process with the configured credential and unsets the declared token environment variables before launching Codex, so the agent can call the tracker without seeing the token. The README warns not to put a literal token in a repository-owned WORKFLOW.md the agent can read. The limit is scope: the README says raw tool calls can reach whatever the configured token can access, and for Linear and Asana the configured project scopes the scheduler's reads, not the agent's tool calls."
      }
    },
    {
      "@type": "Question",
      "name": "Is Symphony ready for production use?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "OpenAI positions it as a reference implementation it does not plan to maintain as a standalone product. The repository README calls it an engineering preview for trusted environments, and the Elixir README describes the implementation as prototype software for evaluation that is presented as-is. Teams that adopt the pattern should treat hardening as their own work."
      }
    },
    {
      "@type": "Question",
      "name": "How does Anomity help teams running orchestrated coding agents?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Anomity's Endpoint Sensor inventories the AI artifacts on each managed Windows, macOS and Linux machine, including coding agents such as the Codex CLI, the MCP servers in their configs, skills, plugins, hooks, and plaintext secrets it recognizes, sending metadata only with secrets redacted on the endpoint. That shows which machines run agents, how they are configured, and what they could reach. On agents that expose a hook, Anomity can allow, deny or log a tool call before it runs, and decisions land in a 90-day audit trail that routes to SIEM, Slack, email or Jira."
      }
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://anomity.ai/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://anomity.ai/blog/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "OpenAI Symphony Security: Governing Codex Agents That Take Work From Your Issue Tracker",
      "item": "https://anomity.ai/blog/openai-symphony-codex-orchestration-security/"
    }
  ]
}
```
