OpenAI has stopped the release of the GPT-6.1 Astra model. The reason given is security concerns. According to Golem.de, tests by researchers uncovered a risk of supply chain attacks, specifically the injection of payloads into open-source code. The Decoder reports that details about the specific risks and a new schedule are not yet known. The two accounts do not necessarily contradict each other; they differ in level of detail: a risk scenario is named, but the technical design and the further roadmap are not.

Almost simultaneously, a second report was published: in connection with GPT-5.4-mini, OpenAI warns of a self-replicating prompt injection. The attack method is said to have the capabilities of a computer worm and, according to the report, was discovered during training with prompt injections.

What lies behind the terms

A prompt injection is an attack in which instructions are embedded in content that a language model processes anyway – for example in a file, a website, a ticket or a source code comment. The model does not reliably distinguish between the task it has received from the user and instructions contained in the processed material. It can therefore execute the injected instructions as if they came from the client.

Self-replicating in this context means: the injected instruction causes itself to be written into further artefacts – for example into files that the model creates or modifies. If such an artefact is later read again by an AI system, the chain continues. It is precisely this property that justifies the comparison with a computer worm.

A payload is the actual malicious component of an attack, i.e. the code or the instruction that causes something undesirable. A supply chain attack is an attack that does not directly target the target system but an upstream component: a library, a package, a build script. Anyone who integrates this component takes on the problem.

Why the combination is delicate

Individually, both topics are known. What is interesting is their connection. AI assistants today write code, open pull requests, read third-party repositories and execute commands in agent setups. This creates a cycle: models read code, generate code and feed this code back as input for other models.

In this cycle, a self-propagating instruction becomes a distribution mechanism. And if a payload lands in open-source code, the path into production systems is short, because such packages are updated automatically in many projects. The attack surface is therefore no longer just the conversation with the model, but the entire chain of dependencies, build processes and automation.

What OpenAI's decision says

A provider that withholds a finished model signals that the internally measured risks could not be caught by downstream filters. This is first of all a statement about the maturity of the protective mechanisms, not about the quality of the model. It also shows that prompt injection is still not a solved problem: there is as yet no method that cleanly and reliably separates data and instructions in a language model.

For companies, above all one consequence can be derived from this: security cannot be delegated to the model. It must arise in the architecture around the model.

Practical implications for development teams

The following measures are general security practice and not recommendations from the reports. However, they address precisely the risk class described:

  • Limit permissions: AI agents receive only the access that is necessary for the specific task – no permanent write access to production systems, no unlimited tokens.
  • Isolate execution: Generated code runs in segregated environments, not on developer machines with full network and repository access.
  • Maintain the four-eyes principle: Changes generated by AI go through the same review as human code, including a look at newly added dependencies.
  • Control dependencies: Pin versions, release updates deliberately, maintain an overview of the components used.
  • Treat inputs as untrusted: Content from tickets, websites, repositories or documents is data, not commands – even when it is formulated like instructions.
  • Log: Keep track of which agent changed which file or executed which command, and when.

Assessment with a sense of proportion

The situation also includes what is not known. There is no information on a new release date for GPT-6.1 Astra, no technical details on the vulnerabilities found and no information about concrete incidents in production environments. According to the reports, the warning about self-replicating prompt injection comes from controlled training and test scenarios. Anyone who wants to derive an acute threat picture for their own infrastructure from this should wait for further, reliable publications.

Regardless of this, the incident shifts the perspective.

The relevant question is no longer how well a model writes code, but what rights it has in doing so and who reviews the results.

What this means for web and software projects

Anyone who lets AI assistants into the development pipeline should treat them like an external component: with clearly limited rights, isolated execution and mandatory review.The benefits of code generation remain, but responsibility for dependencies, approvals and deployments stays with the team.For ongoing projects, this is a good opportunity to deliberately review the access rights of agents, the handling of package updates and the logging of automated changes.

Sources