Developers and build systems that installed two malicious Microsoft Agent Framework releases may have exposed valuable credentials. Versions 1.26.1 and 1.26.2 on PyPI ran a credential stealer whenever Python started, even if the package was never imported. The malware targeted cloud, source-code, registry and continuous-integration secrets while allowing the legitimate framework to keep working. Both releases were removed, and 1.26.0 was identified as the safe version.
What Happened
Two malicious versions of Microsoft’s official Agent Framework package were published to PyPI on November 17, 2026. Version 1.26.1 appeared first, followed by version 1.26.2. Both were removed from availability later that evening. The most recent identified safe version was 1.26.0.
The package is an open-source toolkit for building and coordinating AI agents. The malicious releases retained the legitimate framework dependency, allowing expected functionality to continue while credential-stealing code ran in the background.
The attack used Python .pth files placed in the site-packages directory. Python processes these files when the interpreter starts, so the payload could execute whenever Python ran in the affected environment. A developer did not need to import Agent Framework for the stealer to activate.
The first release searched environment variables, configuration files and other processes for secrets. Targets included Azure, AWS, GitHub, Docker, Hugging Face, OpenAI and package-management services. It also attempted to collect Azure managed identity access tokens and Azure DevOps tokens.
The second version changed the trigger files and expanded collection to GitHub Actions environments and OpenID Connect tokens. Both versions sent collected information to the same attacker-controlled webhook endpoint.
The exact initial route used to gain publishing access remained unresolved in one report. Separate research said the attacker appeared to have compromised a client certificate and private key used by Microsoft’s internal release pipeline, but how those credentials were obtained was not known.
Why It Matters
Development environments and continuous-integration runners routinely hold credentials that can modify source code, publish packages, deploy applications or access cloud resources. A credential stealer executing in those environments can therefore create consequences well beyond the host where the package was installed.
The automatic startup behavior increases the risk. Teams cannot safely conclude that they were unaffected simply because application code never imported the package. If Python started in an environment containing one of the malicious versions, the payload may have run.
The package also continued to provide legitimate functionality. That reduces the chance that developers would notice an immediate failure and makes conventional troubleshooting less likely to reveal the compromise.
Identity exposure is the central issue. Rolling back to a safe package removes the malicious code but does not invalidate secrets that may already have been collected. Cloud tokens, repository credentials, registry credentials and workload identities must be assessed according to what the affected environment could access.
The incident is particularly relevant to AI development teams because fast-moving frameworks are often adopted directly into automated build and deployment systems. Trust in the package name or publisher is not enough when the release channel itself may have been abused.
What to Watch
Organizations should determine whether versions 1.26.1 or 1.26.2 appeared in dependency lockfiles, virtual environments, container images, build logs or package caches. The second version used different filenames, so searches limited to the first release’s artifacts may miss exposure.
Egress records should be checked for the identified webhook path. A completed transfer is stronger evidence of data loss than a blocked attempt. However, absence of a successful connection does not eliminate the need to confirm whether the payload executed and what it could access.
Teams should watch cloud, source-control and package-registry logs for unexpected use of identities available to affected hosts or runners. Particular attention is warranted for managed identities, federated credentials and workflows permitted to request identity tokens.
The unresolved initial compromise path also matters. Further reporting may clarify how publishing access was obtained and whether additional packages or release credentials require review. Until that is established, organizations should avoid assuming the event was limited to an ordinary developer account takeover.
What Defenders Should Do
Find exposure: Search lockfiles, package inventories, virtual environments, containers and CI logs for Agent Framework versions 1.26.1 and 1.26.2. Pin deployments to the identified safe 1.26.0 release until an approved later version is validated.
Contain safely: Isolate affected environments and avoid starting Python or pip within them until evidence is preserved and the environment can be secured. Rebuild from a known-clean source rather than relying only on uninstalling the package.
Confirm execution: Look for the .pth and Python files associated with both malicious versions. Because the payload ran at Python startup, any interpreter activity in the affected environment is relevant.
Review egress: Search proxy, DNS and network logs for the supplied webhook destination. Distinguish blocked or rejected requests from completed transfers.
Rotate credentials: Replace every secret reachable from affected hosts or runners, including cloud sessions, development tokens, source-control credentials, registry credentials and package-publishing secrets. Review managed identities and federated trust relationships that could have been used without a stored password.
Audit activity: Examine cloud sign-ins, administrative actions, repository events, workflow activity and package publication for unexpected behavior. Give special attention to identities available in automated pipelines, where access may be broad and activity may initially resemble normal automation.
The Larger Lesson
Software supply-chain incidents are increasingly identity incidents. The malicious package was valuable not merely because it could run code, but because it ran where organizations keep the credentials that build and deliver software.
Automatic execution also challenges common assumptions about dependency risk. A package does not need to be imported or visibly used to cause harm when installation can place startup hooks in the runtime environment.
The durable response is to reduce the amount and lifetime of privilege available to development systems. Package pinning, controlled promotion, isolated builds, restricted egress and narrowly scoped workload identities cannot guarantee that every dependency is safe, but they can limit what a compromised dependency can steal or do.
