Dynatrace Buys Arize for $915M: Why Agents Need a New Kind of Observability

Most teams can get an AI agent to work in a demo. Far fewer can keep one working in production, where a single stateful agent touches dozens of tools, remembers context across sessions, and can quietly fail in ways that still look healthy on a latency dashboard. That is precisely the gap Dynatrace moved to close on October 1, 2026, when it completed its acquisition of Arize, an AI observability and evaluation platform. The $915 million deal is more than M&A news: it is a signal that observability for AI is becoming a discipline of its own, distinct from the application performance monitoring we already know. Here is what shipped, why engineers should care, and how to instrument your own agents this week.

AI observability now treats the agent trace, not the request, as the primary object

The deal, in plain facts

According to the Dynatrace press release, the acquisition closed on October 1, 2026. Dynatrace describes itself as the leading AI-powered observability platform and Arize as an AI observability and evaluation platform delivering continual learning for agents. The transaction was valued at $915 million in cash and stock. Per Dynatrace investor release, that breaks down into roughly $815 million in cash plus replacement equity awards for Arize employees joining the company. Crucially, both products stay standing: Arize will continue supporting Phoenix, its open-source platform, and AX, its enterprise product, while those capabilities are integrated into Dynatrace over time. Dynatrace has also said it intends to keep backing Phoenix and to contribute to OpenInference.

# The deal, in one object. Numbers come straight from Dynatrace's
# press release and investor release, both dated October 1, 2026.

DYNATRACE_ARIZE = {
    "closed": "2026-10-01",
    "value_usd_m": 915,
    "cash_usd_m": 815,
    "rest": "replacement equity awards for Arize employees",
    "acquirer": "Dynatrace (NYSE: DT) - AI-powered observability",
    "target": "Arize - AI observability & evaluation platform",
    "products_that_continue": ["Arize AX (enterprise)", "Phoenix (open source)"],
    "open_source_commitment": "continue backing Phoenix + contribute to OpenInference",
}

# The headline for engineers: evaluation and observability are merging
# into one lifecycle instead of living in two separate tool silos.

The visibility gap it closes

The strategic logic shows up in Dynatrace own research. In a study of 919 agentic AI leaders cited on the company blog, 51 percent named technical challenges in managing and monitoring agents at scale as a top barrier to production, and 45 percent said they lack clear rules for when agents may act autonomously versus when a human must intervene. Those two numbers describe the same blind spot: you cannot govern what you cannot see. Traditional APM tells you an endpoint is up and latency is fine, but a hallucinating agent that calls the wrong tool and returns a confident wrong answer passes every classic health check. Observability for agents has to answer different questions.

# Why this matters, from Dynatrace's own study of 919 agentic AI
# leaders. The two numbers describe the same blind spot: you cannot
# govern what you cannot see.

VISIBILITY_GAP = {
    "surveyed": 919,
    "barrier_monitoring_agents_at_scale_pct": 51,
    "lack_clear_rules_for_autonomy_pct": 45,
}

# Classic APM tells you an endpoint is up and latency is fine.
# It will not tell you that the agent called the wrong tool and
# returned a confident wrong answer. That is the gap.

def health_flags(latency_ms, error_rate, answer_correct):
    return {
        "apm_says_ok": latency_ms < 800 and error_rate < 0.01,
        "actually_ok": answer_correct,
    }

Evaluation and production monitoring are finally in the same loop

What Arize actually brings

The core idea behind Arize is to treat the LLM trace as the primary object. Its toolkit captures what context a model retrieved, which tools an agent called, and whether the result held up, which are the three questions a normal span graph cannot answer. Arize AX is the managed enterprise platform; Phoenix is the open-source project that developers run locally. Because Arize is a strong backer of OpenInference, an open instrumentation spec, you can emit LLM spans over OpenTelemetry rather than adopting a proprietary agent SDK just to get traces. That openness is the part worth caring about: it means the telemetry you collect today survives the next framework migration.

# Tracing an agent: OpenInference is the open spec that lets you
# emit LLM spans over OpenTelemetry, so you are not locked into a
# proprietary SDK just to get traces. Dynatrace has said it will
# keep backing OpenInference.

# pip install arize-phoenix openinference-instrumentation-openai openai
import phoenix as px
from openinference.instrumentation.openai import OpenAIInstrumentor
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

# 1. Launch a local Phoenix collector for development.
px.launch_app()

# 2. Point OpenTelemetry at it and switch on auto-instrumentation.
provider = TracerProvider()
provider.add_span_processor(
    SimpleSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:6006/v1/traces"))
)
trace.set_tracer_provider(provider)
OpenAIInstrumentor().instrument(tracer_provider=provider)

# 3. Every LLM call and tool call is now a span you can inspect:
#    context retrieved, tools called, output produced.

How to start tracing an agent

Getting traces is easier than most teams expect. Install Phoenix plus the OpenInference instrumentation package, launch a local collector, point OpenTelemetry at it, and switch on auto-instrumentation. From that moment every LLM call and every tool call becomes a span with the retrieved context, the tool arguments, and the returned output attached. In development you read these spans in the Phoenix UI; in production you point the OTLP exporter at your chosen backend. The important discipline is consistency: trace every model call and every tool call, in every environment, so a bug reproduced locally has the same shape as the incident in production.

# Evaluation is the other half. Instead of eyeballing outputs, run
# scored evals against a labelled set before you ship a prompt change.

from phoenix.evals import llm_classify, OpenAIModel
import pandas as pd

model = OpenAIModel(model="gpt-5.6", temperature=0)

TEMPLATE = (
    "Given a question and an answer, return correct, partial or incorrect. "
    "Question: {question} Answer: {answer}"
)

answers = pd.DataFrame({"question": [...], "answer": [...]})
results = llm_classify(
    dataframe=answers,
    template=TEMPLATE,
    model=model,
    rails=["correct", "partial", "incorrect"],
)

# Wire the same eval into CI so a regression fails the build, not prod.

The 51% of leaders who cite monitoring agents at scale as a blocker get a new tool

Running evals in your pipeline

Tracing tells you what happened; evaluation tells you whether it was good. The practical move is to define a small labelled set of representative inputs, write a classification template, and score outputs against rails such as correct, partial, and incorrect. Then wire that same eval into continuous integration so a prompt change that regresses quality fails the build instead of shipping. This is exactly what folding evaluation into observability enables: the same trace you debug in production becomes the fixture you assert against in CI, which is how you stop regressions from reaching users in the first place. Keep the labelled set small but genuinely representative: fifteen to thirty examples drawn from real traffic will catch most regressions long before a sprawling benchmark suite would, and it stays fast enough to run on every pull request.

# The Monday checklist. Evaluation gates belong in CI; governance
# belongs at runtime. Arize AX and Phoenix both stay available, so
# pick the surface your team already owns.

PRE_PROD_GATE = [
    "trace every LLM + tool call (OpenInference over OTel)",
    "run scored evals on a labelled set in CI",
    "fail the build on any eval regression",
    "log identity for every agent action (human or agent)",
    "set autonomy rules: when the agent must ask a human",
    "alert on trace anomalies, not just latency",
]

def ship(prompt_change):
    assert run_evals(prompt_change).passed, "eval regression blocked release"
    return deploy(prompt_change)

A Monday checklist for AI observability

If you take one thing from this deal, take the checklist. Trace every LLM and tool call with OpenInference over OpenTelemetry. Run scored evals on a labelled set in CI and fail the build on any regression. Log an identity for every agent action, human or agent, so you can answer who authorized what in seconds. Write explicit autonomy rules defining when an agent must ask a human. Alert on trace anomalies, not just latency. Arize AX and Phoenix both remain available, so start with whichever surface your team already owns, and keep the loop closed between evaluation and production monitoring.