Scan your whole stack
Latest version: v1.26.2
agent-framework was last scanned on 17 Nov 2026 at version 1.26.2. Risk score 100 of 100 (critical). Confirmed as malicious by OX Research. The AI review also flagged it as malicious.
Malicious release. agent-framework 1.26.1 (PyPI, wheel only, uploaded 2026-11-17 20:35 UTC) adds a credential stealer that 1.26.0 does not contain. The wheel adds agent_framework_meta.pth (a single line, "import agent_framework_meta"), which Python runs at every interpreter start, and agent_framework_meta/_telemetry.py, started in a detached child process. It collects environment variables with names containing TOKEN, SECRET, PASSWORD, KEY, AZURE, AWS, GITHUB, HF_, OPENAI, NPM, PIP or CI_, the environment of other processes (/proc/*/environ), credential files (~/.azure, .npmrc, .netrc, .git-credentials, .docker/config.json, Hugging Face token, Azure DevOps agent .credentials, .env files), Azure DevOps OIDC tokens and Azure managed-identity tokens (169.254.169.254, IDENTITY_ENDPOINT). The data is compressed, base64-encoded and POSTed to https://webhook.site/d381fd80-ec62-42ad-8f5c-d1b15103c9bb (User-Agent af-runtime-diagnostics/1); the URL is base64-encoded in the code and all errors are silenced. Wheel sha256 d27fa34414e6201d5e03e559ef634f020057554d7b3f4898dd5d7cd3e989e110. Last clean release: 1.26.0. Treat any environment that installed 1.26.1 as exposed and rotate the credentials reachable from it. OX Research confirmed versions 1.26.1, 1.26.2 as malicious.
| Version | Published | Status |
|---|---|---|
| 1.26.2 LATEST | 17 Nov 2026 | Malicious 5 rules fired |
| 1.26.1 | 17 Nov 2026 | Malicious 3 rules fired |
| 1.26.0 | 12 Nov 2026 | No rules fired |
| 1.25.0 | 7 Nov 2026 | Not shown |
| 1.24.0 | 30 Oct 2026 | Not shown |
Findings for v1.26.2. The score is a capped sum of the weights of the rules that fired — not CVSS, not exploitability, and not a probability. It is not comparable across packages with different scan coverage.
An automated AI review assessed the package's behavior as likely malicious, based on code excerpts, package metadata and the other findings for this package. It is an automated assessment, not a confirmed result on its own, and should be reviewed.
HIGHand 2 more
The score reflects OX Research's verdict, not this version's rules. Other versions have their own rules, not their own score.
The publisher’s own README, as collected from the registry.
We recommend two common installation paths depending on your use case.
If you are exploring or developing locally, install the standard framework package set:
pip install agent-framework
This installs the core and the standard integration packages. Experimental Lab modules are installed separately
with pip install agent-framework-lab.
If you only need specific integrations, you can install at a more granular level. This keeps dependencies lighter and focuses on what you actually plan to use. Some examples:
# Core only
# includes Azure OpenAI and OpenAI support by default
# also includes workflows and orchestrations
pip install agent-framework-core
# Core + Microsoft Foundry integration
pip install agent-framework-foundry
# Core + Microsoft Copilot Studio integration (preview package)
pip install agent-framework-copilotstudio --pre
# Core + both Microsoft Copilot Studio and Microsoft Foundry integration
pip install --pre agent-framework-copilotstudio agent-framework-foundry
This selective approach is useful when you know which integrations you need, and it is the recommended way to set up lightweight environments. Released packages such as agent-framework, agent-framework-core, and agent-framework-foundry no longer require --pre, while preview connectors such as agent-framework-copilotstudio still do.
Supported Platforms:
Python 3.11 or later is required. Supported environments are subject to the integration-specific limits below.
pip install agent-framework resolves and imports on Python 3.15, but it does
not provide exactly the same feature set as Python 3.14:
| Area | Python 3.15 impact |
|---|---|
| Declarative Power Fx | agent-framework-declarative is installed, but its powerfx dependency is not. YAML values beginning with = produce a warning and remain unchanged instead of being evaluated. Declarative agents or workflows that rely on expressions may therefore use invalid literal values or fail later. |
Set as environment variables, or create a .env file at your project root:
OPENAI_API_KEY=sk-...
OPENAI_MODEL=...
...
AZURE_OPENAI_API_KEY=...
AZURE_OPENAI_ENDPOINT=...
AZURE_OPENAI_MODEL=...
...
FOUNDRY_PROJECT_ENDPOINT=...
FOUNDRY_MODEL=...
For the generic OpenAI clients (OpenAIChatClient and OpenAIChatCompletionClient), configuration
resolves in this order:
credential or azure_endpointOPENAI_API_KEY / explicit OpenAI API-key parametersAZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEYThis means mixed shells default to OpenAI when OPENAI_API_KEY is present. To force Azure routing,
pass an explicit Azure input such as credential=AzureCliCredential().
You can also override environment variables by explicitly passing configuration parameters to the chat client constructor:
from agent_framework.openai import OpenAIChatClient
client = OpenAIChatClient(
api_key='',
azure_endpoint='',
model='',
api_version='',
)
See the following setup guide for more information.
Create agents and invoke them directly:
import asyncio
from agent_framework import Agent
from agent_framework.openai import OpenAIChatClient
async def main():
agent = Agent(
client=OpenAIChatClient(),
instructions="""
1) A robot may not injure a human being...
2) A robot must obey orders given it by human beings...
3) A robot must protect its own existence...
Give me the TLDR in exactly 5 words.
"""
)
result = await agent.run("Summarize the Three Laws of Robotics")
print(result)
asyncio.run(main())
# Output: Protect humans, obey, self-preserve, prioritized.
You can use the chat client classes directly for advanced workflows:
import asyncio
from agent_framework import Message
from agent_framework.openai import OpenAIChatClient
async def main():
client = OpenAIChatClient()
messages = [
Message("system", ["You are a helpful assistant."]),
Message("user", ["Write a haiku about Agent Framework."])
]
response = await client.get_response(messages)
print(response.messages[0].text)
"""
Output:
Agents work in sync,
Framework threads through each task—
Code sparks collaboration.
"""
asyncio.run(main())
Chat clients support async context managers for deterministic cleanup:
from agent_framework import Agent, Message
from agent_framework.openai import OpenAIChatClient
async with OpenAIChatClient() as client:
response = await client.get_response([Message("user", ["Hello!"])])
# Alternatively, let the agent enter and exit its chat client's context.
async with Agent(client=OpenAIChatClient(), instructions="Be helpful.") as agent:
response = await agent.run("Hello!")
Calling clients without a context manager remains supported; use await client.close() when finished.
Context exit releases connections created by the connector, including on exceptions. Caller-supplied SDK clients,
HTTP transports, and credentials remain caller-owned. In particular, closing an Azure SDK connection does not
close the credential supplied to it. Scope credentials outside the agent or client that uses them:
from azure.identity.aio import AzureCliCredential
async with AzureCliCredential() as credential:
async with OpenAIChatClient(
azure_endpoint="https://YOUR-RESOURCE.openai.azure.com",
model="YOUR-DEPLOYMENT",
credential=credential,
) as client:
response = await client.get_response([Message("user", ["Hello!"])])
Treat closing a resource-owning client as the end of its lifetime; reopening is SDK-dependent. Avoid overlapping
agent contexts sharing a connector-owned connection, since exiting either agent closes that connection. To share
an SDK client across agents, inject it into their chat clients and manage its lifetime outside those agent contexts.
BaseChatClient provides default context methods and a no-op close(), so custom subclasses do not need to
implement lifecycle methods unless they own resources. Protocol-only chat clients do not need context methods.
Inherited context exit also supports existing subclasses whose close() is synchronous.
Enhance your agent with custom tools and function calling:
import asyncio
from typing import Annotated
from random import randint
from pydantic import Field
from agent_framework import Agent
from agent_framework.openai import OpenAIChatClient
def get_weather(
location: Annotated[str, Field(description="The location to get the weather for.")],
) -> str:
"""Get the weather for a given location."""
conditions = ["sunny", "cloudy", "rainy", "stormy"]
return f"The weather in {location} is {conditions[randint(0, 3)]} with a high of {randint(10, 30)}°C."
def get_menu_specials() -> str:
"""Get today's menu specials."""
return """
Special Soup: Clam Chowder
Special Salad: Cobb Salad
Special Drink: Chai Tea
"""
async def main():
agent = Agent(
client=OpenAIChatClient(),
instructions="You are a helpful assistant that can provide weather and restaurant information.",
tools=[get_weather, get_menu_specials]
)
response = await agent.run("What's the weather in Amsterdam and what are today's specials?")
print(response)
"""
Output:
The weather in Amsterdam is sunny with a high of 22°C. Today's specials include
Clam Chowder soup, Cobb Salad, and Chai Tea as the special drink.
"""
if __name__ == "__main__":
asyncio.run(main())
You can explore additional agent samples here.
Coordinate multiple agents to collaborate on complex tasks using orchestration patterns:
import asyncio
from agent_framework import Agent
from agent_framework.openai import OpenAIChatClient
async def main():
# Create specialized agents
writer = Agent(
client=OpenAIChatClient(),
name="Writer",
instructions="You are a creative content writer. Generate and refine slogans based on feedback."
)
reviewer = Agent(
client=OpenAIChatClient(),
name="Reviewer",
instructions="You are a critical reviewer. Provide detailed feedback on proposed slogans."
)
# Sequential workflow: Writer creates, Reviewer provides feedback
task = "Create a slogan for a new electric SUV that is affordable and fun to drive."
# Step 1: Writer creates initial slogan
initial_result = await writer.run(task)
print(f"Writer: {initial_result}")
# Step 2: Reviewer provides feedback
feedback_request = f"Please review this slogan: {initial_result}"
feedback = await reviewer.run(feedback_request)
print(f"Reviewer: {feedback}")
# Step 3: Writer refines based on feedback
refinement_request = f"Please refine this slogan based on the feedback: {initial_result}\nFeedback: {feedback}"
final_result = await writer.run(refinement_request)
print(f"Final Slogan: {final_result}")
# Example Output:
# Writer: "Charge Forward: Affordable Adventure Awaits!"
# Reviewer: "Good energy, but 'Charge Forward' is overused in EV marketing..."
# Final Slogan: "Power Up Your Adventure: Premium Feel, Smart Price!"
if __name__ == "__main__":
asyncio.run(main())
For more advanced orchestration patterns including Sequential, Concurrent, Group Chat, Handoff, and Magentic orchestrations, see the orchestration samples.
Find threats in your stack.
OX Radar can check high-priority threats, like critical package CVEs, against your context.
Each incident is marked Detected or Not Detected with a remediation plan and proof all tracked in the Response Center.
The probe returned only these fields for this server — auth requirement, protocol and tool list weren’t observed, so they’re not shown (never guessed).
The publisher’s own links, as the registry reports them. These are not sources for the assessment on this page.