Two malicious versions of the Microsoft Agent Framework Python package were published to PyPI with credential-stealing code, exposing cloud and CI/CD secrets of anyone who installed them.
SecurityWeek reported the story in an article by senior managing editor Eduard Kovacs, Microsoft Agent Framework Releases Poisoned With Credential Stealer. The attack happened on November 17 and was independently analyzed by researchers at OX Security, Wiz, Endor Labs, and SafeDep. If your developers build AI agents, if your pipelines run on GitHub Actions or Azure DevOps, or if you operate in a regulated industry where a leaked cloud credential is a reportable incident, this story deserves your attention. The framework is designed for developing AI agents and multi-agent applications, which places it squarely in the tooling many organizations are adopting right now as agentic AI moves from experiment to production.
Key Takeaways
- Two malicious versions of the agent-framework package, 1.26.1 and 1.26.2, were released to PyPI roughly 33 minutes apart on November 17 in a supply chain attack.
- The malware executed automatically whenever the Python interpreter started, even if the application never explicitly imported the compromised package, and stole secrets from environment variables, configuration files, and other running processes.
- The malicious code targeted Azure managed identity tokens and Azure DevOps authentication tokens, and the second release expanded the stealing functionality to GitHub Actions.
- Both malicious versions have been quarantined on PyPI, and version 1.26.0 remains the latest clean release; Microsoft has acknowledged the incident and an investigation is underway.
- How the packages were published remains unknown. A newly created PyPI maintainer account named vibiret, registered on the day of the attack, had publishing permissions, but its involvement has not been confirmed.
What happened: the facts in detail
A trusted package, poisoned in place
Microsoft Agent Framework is a Python package for building AI agents and multi-agent applications. The affected package, agent-framework, draws approximately 190,000 downloads per month on PyPI. That download volume matters: it means the package sits in thousands of developer environments, build servers, and container images, any of which was a potential victim if it pulled the wrong version during the window of the attack.
On November 17, two malicious versions, 1.26.1 and 1.26.2, were published to PyPI. They were released roughly 33 minutes apart. Both have since been quarantined on PyPI, and version 1.26.0 remains the latest clean release. In other words, anyone who pinned to 1.26.0 and never upgraded was safe. Anyone whose build tooling automatically grabbed the newest version during that window was not.
Malware that behaved like the real thing
What made this attack particularly dangerous is that the malicious distributions retained the legitimate framework components while introducing additional code that attempted to steal credentials. Applications continued to function normally despite the compromise. There was no crash, no error, no broken feature to tip off a developer that something was wrong. The framework did what it was supposed to do, and the theft happened quietly alongside it.
Researchers at OX Security, Wiz, Endor Labs, and SafeDep independently analyzed the malware. Their analyses converged on the same core finding: the code exploits a Python startup mechanism to execute automatically in an affected environment. The malware runs whenever the Python interpreter starts, even if the application does not explicitly import the compromised package. That is a significant escalation over ordinary malicious packages, which typically only do harm when imported by name. Here, merely having the poisoned version installed in the environment was enough to activate it.
What the malware stole
The targets included secrets stored in environment variables and configuration files, as well as credentials belonging to other running processes. It also attempted to obtain Azure managed identity tokens and Azure DevOps authentication tokens, either of which could provide access to cloud resources. The second malicious release, 1.26.2, expanded the credential-stealing functionality to GitHub Actions.
For a business reader, the significance is straightforward. Modern development environments are dense with credentials: tokens that let a build pipeline push code, deploy infrastructure, or assume a cloud identity. A single stolen token can be the difference between an incident confined to one laptop and an intrusion that reaches production cloud resources. This malware went after exactly those high-value credentials, and it did so in the environments where they are most concentrated: developer workstations, CI/CD pipelines, and container images.
Discovery, quarantine, and response
Microsoft has acknowledged the incident. An Agent Framework maintainer confirmed in a GitHub discussion that the compromised releases were removed from PyPI and that an investigation was underway. PyPI quarantined both malicious versions. Organizations were advised to check developer environments, CI/CD pipelines, and container images for the compromised versions, replace affected installations with verified packages, rotate potentially exposed credentials, investigate suspicious cloud activity, and rebuild affected environments.
At the time of the SecurityWeek report, Microsoft's Agent Framework repository on GitHub was inaccessible. Several other Microsoft repositories, including ONNX Runtime projects, had similarly disappeared, but it is unclear whether those incidents are related.
Microsoft Agent Framework: why this attack technique matters technically
The Microsoft Agent Framework attack is worth understanding in some depth, because the technique generalizes far beyond this one package.
First, consider the startup mechanism. Python supports code that runs automatically when the interpreter starts, through mechanisms such as site-specific startup hooks. The malware in the poisoned releases exploited one of these. Practically, that means the infection was not tied to any particular application. A developer could have the package installed, never write a line of code that imports it, and still have the credential stealer execute every time they ran Python at all. Any script, any test suite, any build step that invoked Python in that environment triggered the malware. This is why the remediation guidance extends beyond uninstalling a package: the malware's execution was decoupled from the package's use.
Second, consider what "the application kept working" means for detection. Supply chain attackers have learned that breaking things gets them caught quickly. By preserving the legitimate framework components and only adding theft code, the attackers maximized dwell time. A developer could have run the poisoned version for days in a working project while their Azure tokens and GitHub Actions secrets were harvested. The absence of symptoms is not evidence of absence.
Third, consider the credential targets. Azure managed identity tokens are particularly valuable because managed identities are designed to let workloads authenticate to cloud resources without stored passwords. A token that grants access to cloud resources, captured from a running process, gives an attacker a foothold that looks, from the cloud side, like a legitimate workload. Azure DevOps tokens and GitHub Actions credentials similarly open doors to source code, build systems, and deployment pipelines. An attacker holding those can potentially modify code, poison future releases, or move laterally into production infrastructure. This is the classic supply chain compounding effect: steal the credentials that let you attack the next software supply chain.
Fourth, consider the distribution channel. PyPI is the default package repository for Python, and modern dependency management tooling often resolves to the newest available version automatically. A package with roughly 190,000 downloads per month is exactly the kind of target where attackers get the best return on a single malicious upload. The agent-framework case follows a pattern security teams have seen repeatedly across open source ecosystems: compromise the publishing path rather than the code itself, and let the ecosystem's own automation distribute the malware.
For organizations building with AI agents, the broader lesson is that agentic AI tooling is now a supply chain attack surface of its own. Agent frameworks, connectors, and orchestration libraries carry privileged credentials by design, because agents need to authenticate to the systems they act on. We have written about this risk pattern in Zero-Trust AI: How to Secure Autonomous Agents in the Modern Enterprise and about protecting the development tooling itself in Keeping Coding Agents Safe with AI Supply Chain Guards. The agent-framework incident is a concrete demonstration of why those controls matter.
What the evidence does and does not show
Good incident analysis is honest about the limits of what is known. Several important questions remain open, and the sources are explicit about that.
The publication method is unknown
The method used to publish the malicious packages remains unknown. Two facts point toward an upload outside the normal release process. Unlike legitimate releases, which included both built and source distributions, the malicious versions contained only built packages. And Wiz found no corresponding releases or malicious code in Microsoft's main source repository. Together, those findings suggest the packages may have been uploaded outside the normal release process, but the suggestion is exactly that: a suggestion. Whether an insider was involved, a maintainer account was compromised, or some other publishing path was abused has not been established.
The vibiret account is a lead, not a conclusion
SafeDep identified a PyPI maintainer account named vibiret, created on the day of the attack, with publishing permissions for the affected package and five related projects. However, the account's involvement in the malicious uploads has not been confirmed. It is a significant lead: an account created the same day, holding publish rights across six projects, is a striking coincidence. But striking coincidences are not proof, and no source has confirmed who controlled the account or how it obtained publishing permissions.
Scope of exposure is not yet quantified
The sources do not state how many organizations downloaded the malicious versions, how many credentials were actually stolen, or what the attackers did with any credentials they obtained. The 190,000 monthly download figure describes the package's normal popularity, not the number of victims of versions 1.26.1 and 1.26.2 specifically. The window between publication on November 17 and quarantine was short, but short windows can still be damaging when build systems pull packages automatically. No source in this reporting quantifies actual downloads of the malicious versions or confirmed downstream compromise.
The GitHub repository situation is unresolved
Microsoft's Agent Framework repository on GitHub was inaccessible at the time of writing, and several other Microsoft repositories, including ONNX Runtime projects, had similarly disappeared. It is unclear whether these incidents are related. Readers should resist the temptation to connect dots the reporting does not connect. The repository disappearances may share a cause with the PyPI attack, or they may be entirely separate events. The sources do not say.
The investigation is ongoing
Microsoft has acknowledged the incident and confirmed through an Agent Framework maintainer in a GitHub discussion that an investigation was underway. Until that investigation produces findings, claims about attribution, motive, or the full mechanics of the attack would be speculation. What is established is the malware's behavior, confirmed by four independent research teams, and the remediation steps that follow from it. For a regulated business, that established core is enough to act on, and Part 2 of this analysis will cover exactly what to do: how to check whether you were exposed, how to respond if you were, and how to harden your software supply chain so the next incident of this kind does not reach your credentials.
Compliance and Risk Implications for Regulated Organizations
A poisoned package in a widely used AI framework is not just an engineering problem. For regulated businesses, it is a compliance event with specific obligations attached. If the malicious versions of the agent-framework package ran anywhere in your environment, credentials may have left your perimeter, and that fact can trigger duties you cannot opt out of.
Consider what the malware targeted: secrets in environment variables and configuration files, credentials belonging to other running processes, Azure managed identity tokens, Azure DevOps authentication tokens, and, in the second release, GitHub Actions credentials. For a defense contractor, that list overlaps directly with the environments where controlled unclassified information lives. For a healthcare organization, stolen cloud identity tokens can open paths to systems containing electronic protected health information. The exposure is not hypothetical; the code was designed to harvest exactly these assets.
The compliance logic follows from the incident, not from any new rule. NIST SP 800-171's Incident Response family requires an operational incident handling capability and the tracking, documenting, and reporting of incidents. DFARS 252.204-7012 requires reporting a cyber incident affecting covered defense information to DoD within 72 hours of discovery via dibnet.dod.gov, using a DoD-approved medium assurance certificate obtained in advance. If you discover this package in a system handling covered defense information, the clock is already running. The HIPAA Breach Notification Rule, at 45 CFR 164.404, 164.406, and 164.408, imposes its own assessment and notification duties when protected health information may have been exposed. PCI DSS environments face analogous expectations around credential protection and incident response.
There is also an audit dimension. An assessor reviewing your environment after this incident will ask what you installed, how you verified it, and how you detected the compromise. "We trusted PyPI" is not an answer that maps to any control. The absence of a software bill of materials, of dependency pinning against verified hashes, and of egress monitoring from build environments will read as gaps regardless of whether you were actually compromised. NIST SP 800-171 requires FIPS-validated cryptography to protect the confidentiality of CUI, and stolen identity tokens bypass encryption entirely; the control that mattered here was identity and credential hygiene, not crypto strength.
Finally, note the DOJ Civil Cyber-Fraud Initiative settlements on record, including Raytheon at $8.4 million in May 2025 and Georgia Tech in September 2025. Misrepresenting your security posture to the government carries financial consequences. If a compromised package ran in a CUI environment and you did not investigate, your self-assessment score in the Supplier Performance Risk System may no longer be accurate.
What This Means for Regulated Industries
Defense Contractors
Start with the question that matters: did versions 1.26.1 or 1.26.2 of agent-framework run on any system inside your CUI boundary, including developer workstations, CI/CD runners, and container images? If yes, treat it as a potential incident under DFARS 252.204-7012. That means reporting to DoD within 72 hours of discovery, preserving affected system images and monitoring data for at least 90 days, and submitting isolated malicious software to the government. The malware's pursuit of Azure managed identity tokens is particularly relevant for contractors operating in Azure Government or GCC High environments, where those tokens can gate access to CUI workloads.
Your SPRS score is also in play. If the incident revealed that a control you scored as implemented, such as supply chain risk management or incident response, was not actually operating, your NIST SP 800-171 self-assessment needs correction. Under the CMMC Program rule, 32 CFR Part 170, accuracy matters, and the DOJ settlements show that inflated self-assessments carry real cost. A readiness engagement that produces a live POA&M and honest gap analysis is cheaper than a False Claims Act investigation.
Healthcare Organizations
The exposure here runs through identity. Stolen Azure tokens and process credentials can lead to the systems that store, process, or transmit electronic protected health information. Under the HIPAA Security Rule at 45 CFR Part 164, you are required to conduct a Risk Analysis under 45 CFR 164.308(a)(1)(ii)(A), and an incident like this belongs in that analysis: if your AI development tooling can harvest cloud credentials, your risk analysis should say so and document the mitigations.
If PHI may have been accessed, the Breach Notification Rule drives a four-factor risk assessment and potential notification duties. Do not wait for certainty. The Change Healthcare breach, which ultimately reached 192.7 million individuals in the final HHS filing of July 31, 2025, showed how third-party and supply chain failures cascade through healthcare. Business associates accounted for about 66% of breached healthcare records in 2024, which means your AI vendors and development partners are part of your breach surface whether you count them or not.
Legal Practices
Law firms hold client confidences that carry ethical and, increasingly, contractual protection duties. If your innovation team or e-discovery operation has been experimenting with AI agent frameworks, this incident is a reason to inventory that experimentation now. A credential stealer in a Python package on a lawyer's workstation can reach the same cloud tenants that hold client files. Client engagement letters and cyber insurance applications increasingly ask specifically about AI tooling and software supply chain controls; answer those questions with evidence, not assurances.
The practical steps are the same as for any regulated business: verify installed package versions, rotate exposed credentials, and document what you found and did. That documentation is what you produce when a client's outside counsel sends a security questionnaire or when a bar-level data breach question arises.
Financial Services
Financial institutions face examiner scrutiny on third-party risk and operational resilience, and a supply chain compromise in development tooling sits squarely in both categories. The malware's targeting of CI/CD credentials is the sharpest edge: a compromised build pipeline can silently insert code into the software you ship to customers and partners. If your institution builds AI-driven applications, whether for fraud detection, customer service agents, or back-office automation, treat the integrity of your AI dependency chain as a supervisory-relevant risk.
Rotate Azure, GitHub Actions, and CI/CD credentials if there is any chance of exposure, and review cloud audit logs for anomalous token use. Regulators will ask what you detected and when; your ability to answer from logs rather than memory is itself a control.
Your Action Plan for This Month
- Inventory every installation of the agent-framework package. Search developer workstations, CI/CD pipelines, container images, and virtual environments for versions 1.26.1 and 1.26.2. Version 1.26.0 is the latest clean release on PyPI.
- Assume execution means exposure. The malware runs whenever the Python interpreter starts, even if the application never explicitly imports the package. If either malicious version ran anywhere, treat credentials on that host as compromised.
- Rotate credentials immediately. Prioritize Azure managed identity tokens, Azure DevOps authentication tokens, GitHub Actions secrets, environment variables, and configuration file secrets on affected systems. Rotate first, investigate second; rotation is cheap, exfiltration is not.
- Review cloud and CI/CD audit logs. Look for anomalous token issuance, unusual repository activity, and unexpected authentication from your build environments. This is how you determine whether exfiltration actually occurred.
- Rebuild affected environments from verified images. Quarantine is not enough; the malware's persistence mechanism lives in the Python startup path. Rebuild hosts and pipelines from trusted sources rather than cleaning in place.
- Determine your reporting obligations. Defense contractors: if covered defense information was potentially affected, prepare the DFARS 252.204-7012 report to DoD within 72 hours of discovery. Healthcare organizations: run the breach risk assessment under the Breach Notification Rule. Document your timeline either way.
- Pin and verify dependencies going forward. Pin exact versions with hash verification, and note the telltale from this attack: the malicious distributions contained only built packages, while legitimate releases included both built and source distributions. Treat deviations from a project's normal release pattern as a red flag.
- Restrict who can publish and who can install. Review maintainer access on packages your organization depends on, and gate production installs through an internal repository that mirrors only verified versions. SafeDep identified a PyPI maintainer account created on the day of the attack with publishing permissions for the affected package and five related projects; that account's role is unconfirmed, but the pattern shows how quickly new accounts can be weaponized.
- Extend the sweep to your AI tooling generally. If you run coding agents, agentic frameworks, or AI development stacks, audit their dependency trees and the credentials they can reach. Our related analysis on keeping coding agents safe with AI supply chain guards covers this discipline in depth.
- Update your incident response plan with a supply chain scenario. NIST SP 800-61 Rev. 3 frames incident response as part of broader risk management aligned to the NIST Cybersecurity Framework 2.0. If your plan has no playbook for a compromised dependency, write one now, before you need it.
How Petronella Technology Group, Inc. Helps
Petronella Technology Group, Inc. works with defense industrial base and healthcare clients that face exactly this class of risk, and our services map directly to the response this incident demands.
Our managed detection and response service provides 24/7 threat monitoring, AI-powered analytics, and human-led investigation, with cloud coverage across Microsoft 365, Azure, AWS, and Google Workspace that detects unauthorized access, suspicious API activity, and configuration drift. That is precisely the visibility needed to spot stolen-token use after a supply chain compromise. Our AI-augmented hybrid SOC runs ten-plus production AI agents on our own private AI cluster, with guardrails that ensure the AI never closes a ticket on its own and never touches production systems without human authorization, and every action is logged for CMMC and HIPAA audit. A Digital Forensics Examiner is on staff, and MDR reporting is designed to provide the evidence auditors need for HIPAA, CMMC, PCI DSS, SOC 2, and NIST 800-171 verification.
On the compliance side, our compliance services cover CMMC readiness, HIPAA, SOC 2, and NIST SP 800-171 programs, including the incident response documentation and risk analysis work this incident triggers. Every practitioner on our compliance team holds the CMMC-RP designation, and we are a Cyber AB Registered Provider Organization, RPO #1449. For organizations building AI systems on regulated data, our private AI practice designs clusters where the data boundary, secrets handling, egress control, and audit logging are engineered in from the start, so AI development never has to depend on blind trust in a public package registry. For teams that need senior security leadership without a nine-month executive search, our vCISO practice delivers a written current-state assessment within 30 days and a 90 to 180 day remediation roadmap.
For more on securing agentic systems, see our analyses of zero-trust AI and securing autonomous agents and zero trust for agentic data sharing.
Related reading
- LiteLLM Supply Chain Breach Delivers Stealer and Backdoor
- Poisoned Update Attacks and AI DevOps Defense
- Keeping Coding Agents Safe with AI Supply Chain Guards
- Raccoon Stealer Malware: How It Works and How to Stop It
Sources
- Microsoft Agent Framework Releases Poisoned With Credential Stealer
- Virtual Cybersecurity Events 2026
- SecurityWeek Podcast
- Industrial Control Systems (ICS) Cybersecurity Conference
- Cross-Sector Cybersecurity Performance Goals
- SP 800-61 Rev. 3, Incident Response Recommendations and Considerations for Cybersecurity R
Frequently Asked Questions
Which versions of the Microsoft Agent Framework package were malicious?
Versions 1.26.1 and 1.26.2 of the agent-framework Python package on PyPI were malicious and have been quarantined. Version 1.26.0 remains the latest clean release. The two malicious versions were released roughly 33 minutes apart on November 17.
Did the malicious Microsoft Agent Framework package steal credentials even if my app never imported it?
Yes. According to the independent analyses by OX Security, Wiz, Endor Labs, and SafeDep, the malware exploited a Python startup mechanism so it executed whenever the Python interpreter started, even without an explicit import of the compromised package. Any environment where the malicious version was installed should be treated as exposed.
What credentials did the malware target?
It targeted secrets in environment variables and configuration files, credentials belonging to other running processes, Azure managed identity tokens, and Azure DevOps authentication tokens. The second malicious release expanded the functionality to GitHub Actions credentials.
Do I need to report this to the government if I find the package in my environment?
It depends on your sector and what the package could reach. Defense contractors may need to report under DFARS 252.204-7012 within 72 hours of discovery if covered defense information was potentially affected. Healthcare organizations must assess potential PHI exposure under the HIPAA Breach Notification Rule. Document your findings and timeline regardless of sector.
Was Microsoft's source repository compromised?
Wiz found no corresponding releases or malicious code in Microsoft's main source repository, suggesting the packages may have been uploaded outside the normal release process. The method used to publish the malicious packages remains unknown, and a newly created maintainer account named vibiret had publishing permissions, though its involvement has not been confirmed. Microsoft's Agent Framework repository on GitHub was inaccessible at the time of writing.
How can I verify my Python dependencies are safe going forward?
Pin exact versions with hash verification, install through an internal mirror of verified packages, and watch for release anomalies such as missing source distributions. Check developer environments, CI/CD pipelines, and container images against known-bad versions, and rebuild any environment where a malicious package ran rather than attempting to clean it.
If you need help scoping your exposure or your response, call Penny, our AI assistant, at 919-348-4912 to book a consultation, or reach Petronella Technology Group, Inc. through our contact form.
Free online course from the Petronella Technology Group, Inc. Training Academy
Getting Started with Claude Code
Your first AI coding session in 90 minutes.
Price: Free
Free, practical, and specific to regulated environments. We will email it to you.
No spam. Unsubscribe anytime.