CVE-2026-116691: MLflow CrewAI autologging records LLM provider API keys in logged trace spans
mlflow.crewai.autolog() copies CrewAI LLM provider API keys, in plaintext, into MLflow trace spans. Anyone who can read the trace store or the OTLP destination can then take the key. Affects MLflow 2.19.0 through 3.16.x. Fixed in 3.17.0, but keys already written must be rotated and the traces cleaned.
Published Oct 27, 2026 · Analysis Oct 28, 2026
What an attacker can do
With CrewAI autologging on, MLflow walks the Agent's __dict__ in _get_agent_attributes() in mlflow/crewai/autolog.py and turns each field into a string. The llm field is a CrewAI LLM object, and its string form includes api_key. The same happens for function_calling_llm, agent_executor and crew. A second path, _construct_full_inputs(), expands the Agent's __dict__ when it appears as a call argument, so the key also lands in mlflow.spanInputs. MLflow's dedicated LLM span code already excludes api_key, which shows the leak is unintended.
The application never logs the key itself. In the reporter's test on MLflow 3.16.0 with CrewAI 1.15.18, a fake key appeared in 5 attribute locations across 2 spans in the exported OTLP data. The value is added when the span starts, so it leaks even if the provider call fails.
The attacker needs read access to the MLflow trace storage or the OTLP destination, such as other MLflow users, observability operators or a third-party telemetry vendor. They get a working LLM provider key, which allows unauthorized API use and cost on your account.
Who is affected
Affected: mlflow >= 2.19.0 and < 3.17.0, only for applications that call mlflow.crewai.autolog() and build a CrewAI LLM with an API key, for example LLM(api_key=...). Applications that do not enable CrewAI autologging are not exposed by this flaw.
Check the version and whether you call the function:
pip show mlflowgrep -rn "crewai.autolog" .mlflow
- Ecosystem
- PyPI
- Affected
- >= 2.19.0, < 3.17.0
- Fixed in
- 3.17.0
- Check
pip show mlflow
How to fix it
Upgrade to mlflow 3.17.0:
pip install --upgrade "mlflow>=3.17.0"Pull request 25845 makes mlflow.crewai.autolog() reduce CrewAI LLM objects to their model name and drop credential-like keys before anything is written to span attributes or mlflow.spanInputs.
Upgrading stops new leakage only. Rotate any provider key held by a CrewAI LLM object while autologging ran on 2.19.0 through 3.16.x. Delete or redact the affected traces in the MLflow tracking backend and in any OTLP destination they were exported to. If you cannot upgrade yet, disable the integration with mlflow.crewai.autolog(disable=True).
How to tell if you were hit
Search stored traces for your provider key prefix, for example sk-proj- or sk-, in the span attributes llm, function_calling_llm, agent_executor and mlflow.spanInputs, on both Agent spans and Task.execute_sync spans. Run the same search on whatever OTLP backend receives the traces.
The string pattern to look for is api_key='...' inside an llm_type='openai' model='...' dump. Check your provider's usage logs for calls from unfamiliar IP addresses or unexpected spikes, since a leaked key can be used anywhere.
Original advisory
From the GitHub Advisory Database (CC BY 4.0).
Summary
mlflow.crewai.autolog() leaks CrewAI LLM provider API keys into MLflow trace telemetry.
When a CrewAI Agent is instrumented with MLflow autologging, MLflow serializes the agent's __dict__ and converts its fields to strings. The llm field contains the CrewAI LLM object, whose string representation includes its api_key in plaintext.
As a result, an application that calls mlflow.crewai.autolog() can unintentionally send its LLM provider API key to the MLflow trace backend or configured OTLP destination.
The application does not need to explicitly log the credential or place it in a span attribute. The credential is extracted automatically by MLflow's instrumentation.
This was verified on MLflow 3.16.0 with CrewAI 1.15.18 using MLflow's own OTLP exporter. The fake credential appeared in 5 attribute locations across 2 spans.
Details
The primary issue is in:
mlflow/crewai/autolog.py::_get_agent_attributes()
The function walks the CrewAI Agent.__dict__ and converts agent fields to strings. tools and embedder receive special handling, but credential-bearing objects such as the following are not sanitized:
llmfunction_calling_llmagent_executorcrew
For example, agent.llm is a CrewAI LLM object. In CrewAI 1.15.18, the underlying LLM model contains api_key as a normal field. Its string representation therefore contains the credential:
llm_type='openai' model='gpt-4.1-mini' ... api_key='sk-proj-...' ...MLflow subsequently stores this string as a span attribute.
There is an important indication that this is an unintended disclosure: MLflow's dedicated LLM attribute extraction already explicitly excludes api_key in _get_llm_attributes(). The LLM span therefore does not expose the credential, while the broader Agent __dict__ serialization bypasses that protection.
There is also a second, independent serialization path in:
mlflow/crewai/autolog.py::_construct_full_inputs()
This code uses:
v.__dict__ if hasattr(v, "__dict__") else von call arguments. During CrewAI execution, the Agent object is passed as an argument, causing its __dict__ to be expanded and the credential-bearing LLM object to be included in mlflow.spanInputs.
Therefore, there are two independent leakage paths:
- Agent span attributes through
_get_agent_attributes() - Span inputs through
_construct_full_inputs()
Fixing only the Agent attribute serialization would leave the mlflow.spanInputs path vulnerable.
A safer approach would be to avoid recursively serializing arbitrary object __dict__ values. Agent telemetry should use an explicit allowlist of non-sensitive scalar fields, and credential-bearing objects such as llm, function_calling_llm, agent_executor, and crew should either be reduced to safe metadata or omitted.
Similarly, _construct_full_inputs() should not automatically expand arbitrary objects through __dict__, or the resulting values should pass through the same sanitization mechanism before being attached to a span.
PoC
Environment:
MLflow: 3.16.0
CrewAI: 1.15.18
Python: 3.12.3
opentelemetry-exporter-otlp-proto-http: 1.42.11. Direct serialization proof
The following demonstrates the vulnerability without starting a Crew, making a network request, or requiring an MLflow server:
import importlib
from crewai import LLM, Agent
autolog = importlib.import_module("mlflow.crewai.autolog")
llm = LLM(
model="gpt-4.1-mini",
api_key="sk-proj-EXAMPLE1234567890",
)
agent = Agent(
role="r",
goal="g",
backstory="b",
llm=llm,
)
attrs = autolog._get_agent_attributes(agent)
assert "sk-proj-EXAMPLE1234567890" in attrs["llm"]
print(attrs["llm"])The output contains the API key in plaintext, for example:
llm_type='openai' model='gpt-4.1-mini' ... api_key='sk-proj-EXAMPLE1234567890' ...No provider request is required.
2. End-to-end trace disclosure
The issue can also be reproduced through MLflow's actual OTLP exporter.
Configure a local OTLP HTTP receiver and set:
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://127.0.0.1:4318/v1/traces
export OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf
export CREWAI_DISABLE_TELEMETRY=trueThen run:
import mlflow
from crewai import Agent, Crew, LLM, Task
mlflow.crewai.autolog()
llm = LLM(
model="gpt-4.1-mini",
api_key="sk-proj-EXAMPLE1234567890",
)
agent = Agent(
role="Support Responder",
goal="Answer support questions",
backstory="A support agent",
llm=llm,
)
task = Task(
description="Answer the user's question",
expected_output="A response",
agent=agent,
)
crew = Crew(
agents=[agent],
tasks=[task],
)
crew.kickoff()A local OTLP receiver can decode the ExportTraceServiceRequest sent by MLflow.
The provider request is expected to fail because the credential is intentionally fake. This does not affect the vulnerability: the sensitive value is added to the MLflow span when the instrumentation starts, before the provider call succeeds or fails.
In the tested environment, the fake API key appeared in the exported telemetry in 5 locations across 2 spans, including:
Support Responder
attributes.llm
attributes.function_calling_llm
attributes.agent_executor
attributes.mlflow.spanInputs
Task.execute_sync
attributes.mlflow.spanInputsThe captured value is produced by MLflow's actual telemetry/export path rather than being manually inserted into a span.
All credentials used in the reproduction are locally generated fake values. No real API credential is required.
Impact
Type: Sensitive Information Disclosure / Credential Disclosure CWE: CWE-532 — Insertion of Sensitive Information into Log File
Any application using mlflow.crewai.autolog() with a CrewAI LLM configured with an API key can unintentionally disclose that credential through MLflow traces.
The credential is written to trace telemetry even though the application does not explicitly log it.
Anyone with access to the MLflow trace storage or configured OTLP destination may therefore obtain the provider credential. Depending on the deployment, this can include MLflow users, observability operators, or third-party telemetry providers.
The leaked credential can then potentially be used against the corresponding LLM provider account, including for unauthorized API usage and associated costs.
The issue is particularly significant because the credential crosses a trust boundary: a provider API key intended for use by the application is automatically copied into observability telemetry where a broader set of users or systems may have access.
The vulnerability does not require the developer to intentionally log the secret. The only relevant prerequisite is enabling the CrewAI autologging integration.
Patches
Fixed in MLflow 3.17.0 by #25845. mlflow.crewai.autolog() now reduces CrewAI LLM objects to their model name and drops credential-like keys before they are written to span attributes or mlflow.spanInputs.
Remediation
- Upgrade to
mlflow>=3.17.0. - Upgrading stops new leakage but does not remove credentials already written. Rotate any LLM provider key that a CrewAI
LLMobject held (for example one passed asLLM(api_key=...)) whilemlflow.crewai.autolog()was enabled on MLflow 2.19.0 through 3.16.x. - Delete or redact the affected traces in the MLflow tracking backend and in any OTLP destination they were exported to. The key appears in Agent and Crew span attributes and in
mlflow.spanInputs.
Workarounds
If you cannot upgrade yet, disable CrewAI autologging with mlflow.crewai.autolog(disable=True).
Credited to IdoGol24.
Questions
- Does upgrading to MLflow 3.17.0 remove keys already leaked?
No. The upgrade only stops new leakage. You must rotate any key that was held by a CrewAI LLM object while autologging ran, and delete or redact the stored traces.
- Am I affected if I do not use CrewAI?
No. The leak is in the CrewAI autologging integration, mlflow.crewai.autolog(). Other MLflow integrations are not named in the advisory.
- Is there a workaround if I cannot upgrade?
Yes. Disable the integration with mlflow.crewai.autolog(disable=True). Keys already written still need rotation.
- Is this exploited in the wild?
No source reports exploitation, and it is not in CISA's KEV catalog. Exposure happens passively whenever traces are stored.
References
How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. The analysis is written by an AI model from the sources listed above and checked by automated rules before it is published. Check versions against the vendor's advisory before you act. Methodology
More MLflow vulnerabilities
All MLflow entriesCVE-2026-116690
MLflow vulnerable to arbitrary file read on unauthenticated servers via prompt model version source
high7.5Oct 27, 2026CVE-2026-116692
MLflow vulnerable to remote code execution on unauthenticated servers via third-party scorer deserialization importing caller-placed artifact modules
critical9.8Oct 27, 2026CVE-2026-115886
MLflow: SSRF on unauthenticated MLflow servers via third-party scorer kwargs in the scorer invoke, register, and GenAI evaluate endpoints
medium6.5Oct 23, 2026CVE-2026-53995
MLflow FileStore trace IDs allow path traversal and arbitrary file writes
high8.2Oct 20, 2026GHSA-gqvg-gmmx-x4hm
MLFLOW_ALLOW_PICKLE_DESERIALIZATION=False safety control bypassed by mlflow.statsmodels flavor — RCE via crafted model artifact
high8.8Sep 1, 2026CVE-2026-64849
MLflow: Unauthenticated full-read SSRF in webhook delivery: _validate_webhook_url bypassed via unvalidated HTTP redirects (and DNS rebinding)
critical9.3ExploitedAug 17, 2026
