A year ago, “AI observability” meant tracing LLM calls and looking at dashboards. The category has since fractured into four distinct segments: developer observability tools, governance platforms, agent security vendors, and infrastructure incumbents bolting on AI monitoring.
Microsoft open-sourced the Agent Governance Toolkit. ServiceNow acquired Traceloop, then Veza and Armis, and launched AI Control Tower. Cisco announced its acquisition of Galileo. ClickHouse acquired Langfuse. Palo Alto Networks acquired Portkey and relaunched it as the Prisma AIRS AI Gateway. Mintlify acquired Helicone. Dynatrace signed an agreement to acquire Arize. CrowdStrike acquired Seraphic and SGNL. Arthur AI launched Agent Discovery & Governance. Datadog shipped native LLM observability, now rebranded Agent Observability, and added inline enforcement with AI Guard.
Observability is table stakes. Every tool on this page captures traces. The question that matters now: what happens before the next step executes? Who enforces cost budgets mid-run? Who scans for PII in real time? Who governs MCP tool calls across your organization? Who stops a runaway agent at 3am — not alerts you about it on Monday?
Waxell covers the full arc. Here’s how that stacks up.
How Buyers Actually Choose
Most teams aren’t actually choosing between five tools that all look the same. They’re choosing between four different bets: buy a dedicated observability tool, buy a dedicated governance/compliance platform, buy an evaluation tool built for the agent dev lifecycle, or use what’s already bundled into the cloud platform they’re on. Nine acquisitions in the past year — Cisco → Galileo, ClickHouse → Langfuse, Palo Alto Networks → Portkey, ServiceNow → Traceloop, Veza and Armis, Mintlify → Helicone, CrowdStrike → Seraphic and SGNL, and Dynatrace → Arize, signed and pending — aren’t just a consolidation story. For a buyer, they’re a signal: the vendor you evaluate today may be a different company, on a different roadmap, in six months. Here’s how those four bets actually stack up.
Observability Platforms
Traces, costs, and logs of every LLM and tool call — the baseline most buyers already have covered.
Most of this group shows what happened without deciding what happens next — Langfuse says so in its own docs, calling itself "the ex-post evaluation of the effectiveness of these measures." But the exceptions have multiplied since we first wrote this page, and they are worth naming honestly. Portkey's gateway kills a failing request outright. Datadog's AI Guard denies tool calls inline. LangSmith's LLM Gateway caps spend and redacts PII on model calls. Helicone's proxy rejects flagged prompts before they reach the model. Arize AX intercepts and rewrites LLM outputs at run time. What none of them do is enforce deterministic, declarative policy across an agent's whole execution — halting on cost mid-run across a full spawn tree, governing what the agent retrieves, or blocking a tool call on a rule you wrote rather than a model's judgement.
The same observability depth, plus enforcement built into the SDK itself — policy blocking, budget halting, PII redaction — not bolted onto a proxy or gated to a security add-on.
AI Governance (GRC)
Risk registers, policy documentation, and regulatory mapping — EU AI Act, NIST AI RMF, ISO 42001 — for a compliance or GRC buying committee.
This category used to mean paperwork, not runtime control. That is no longer a safe generalisation about any name in it. CrowdStrike's Falcon Guardian (renamed from Falcon AIDR in September 2026; claimed 99% efficacy, under 100ms), Straiker's Defend AI (claimed 98%+ accuracy, under 300ms) and Holistic AI's Operative Agents all claim live in-production blocking. OneTrust's AI Governance page now carries a "Programmatically Enforce Controls" pillar promising to "block or allow actions by policy" and "MCP policy enforcement with audit logs" — though the enforcement appears to run through partner platform integrations rather than a gateway they operate. Credo AI's Agent Governor enforces "inside the agentic loop, on invocations, before any action runs," but it is a design-partner research preview with no production SLA, and their own product page still lists CI/CD, CASB and API-gateway enforcement as "planned." None of the six publish pricing or offer self-serve signup.
The same real-time enforcement claim these three make — with transparent pricing and a self-serve SDK instead of an enterprise security sales cycle.
Vendor-Bundled / Platform-Native
Governance bundled into a cloud or identity stack the buyer may already own.
Real capability, real lock-in. AWS's AgentCore Policy (GA March 2026, with Bedrock Guardrails folded into it that June) is one of the closest matches to Waxell's own pitch found in this research — Cedar-based, default-deny, per-request tool-call authorization — but it only covers traffic through AWS's own AgentCore Gateway (its separate Bedrock Guardrails product works across any model, including self-hosted and non-AWS ones). Microsoft's governance value is priced into an existing M365 E3 + Azure bill, not a standalone purchase. IBM's Governance Graph requires the broader watsonx ecosystem. None of the three travel with you off their platform.
Framework and cloud neutrality — the same governance whether you're on AWS, Azure, GCP, or none of the above — plus simpler pricing than IBM's per-VPC-core metering or AWS's five-plus separately billed components.
Where does Waxell fit in the market?
Deep Comparisons
Each comparison below goes beyond the feature matrix — covering positioning, use-case fit, and when the other tool might be the right choice.
FAQ
What's the difference between AI agent observability and AI agent governance?
Observability captures what agents did — traces, LLM calls, tool invocations, costs. Governance controls what agents are allowed to do next. Every tool on this page provides some form of observability, and a growing number now enforce something during execution — Microsoft AGT, Arthur AI, Datadog, Portkey, Helicone, Arize AX, Galileo and Credo AI among them. What differs is what gets enforced and how. Most intervene on content — a prompt, an output, a model call — or on a model’s judgement of intent. Waxell enforces declarative policy on the agent’s actions: which tool it may call, what it may spend across its whole spawn tree, what it may retrieve, and when a human has to approve. The distinction matters: a dashboard that shows you a $4,000 spend spike on Monday morning is observability. A budget control that halts the agent at $500 on Friday night is governance.
How does Waxell compare to Microsoft's Agent Governance Toolkit (AGT)?
AGT is an open-source library (MIT license, per its current GitHub license file) with a documented four-stage pipeline — pre-input, pre-tool, post-tool, pre-output — that includes tool-call interception, output sanitization, rate limiting, and human-in-the-loop approval gates. Policies are authored in YAML/OPA/Cedar and can be hot-reloaded at runtime without a restart. What AGT doesn't have: a no-code UI for policy authorship (every change still goes through engineering), mid-execution cost tracking and enforcement across an agent's full spawn tree, data-retrieval-layer governance, or durable execution across session boundaries. Waxell covers that remaining arc, with policies managed through the platform UI — no YAML, no deployments, no restart required — built for the people who own governance, not just the people who can write it.
Is Waxell a replacement for LangSmith?
It depends on your stack. If you're all-in on LangChain and need deep LangGraph-native tracing, LangSmith's integration is purpose-built for that. If you use multiple frameworks — or if you need runtime governance, enforced cost controls, PII detection, or MCP governance — Waxell covers capabilities that LangSmith doesn't. Some teams run both: Waxell for governance and enforcement, LangSmith for LangChain-specific evaluation workflows.
How does Waxell compare to Datadog for AI agent monitoring?
Datadog connects AI agent traces to infrastructure metrics, APM data, and user sessions — correlation depth that standalone AI tools can’t match — and its built-in Sensitive Data Scanner adds real PII detection and redaction at no extra cost. If your primary need is correlating agent behavior with backend infrastructure performance, Datadog’s integration is strong. Waxell is purpose-built for agent governance: 50+ enforced policy categories, runtime cost controls, tool-access blocking, kill switches, durable execution, and MCP tool-call governance — Datadog also enforces now — AI Guard denies tool calls inline, in limited preview. The difference is the mechanism: AI Guard asks a model whether an action looks dangerous and returns a natural-language rationale; Waxell evaluates the action against declarative policy categories that produce the same answer every time and leave an enforcement record an auditor can read. Datadog monitors, scans, and judges; Waxell monitors and enforces.
What does Waxell do that Arthur AI doesn't?
Arthur AI leads on agent discovery and evaluation — automatically scanning compute environments to find and catalog every AI application, plus a full evaluation suite (datasets, continuous evals, human annotation) and built-in PII detection via its free Evals Engine. Waxell leads on runtime governance and execution — policy enforcement with 50+ structured categories, mid-execution cost enforcement across an agent's full spawn tree, MCP gateway governance, durable execution with checkpoint and resume, and a coordination layer for third-party agents. Arthur discovers and evaluates; Waxell governs and enforces.
Can I use Waxell alongside another observability tool?
Yes. Waxell instruments at the SDK level and doesn't conflict with proxy-level tools (Helicone, Portkey) or framework-native tools (LangSmith). Some teams use Waxell for governance and enforcement while keeping a secondary tool for evaluation or experiment tracking.
Does Waxell support MCP governance?
Yes — at two levels. The Waxell MCP Gateway fronts 160+ upstream connectors with preventive controls: deny, redact, require approval, rate-limit, or cost-cap any tool call before it reaches the upstream server. Waxell Connect provides MCP governance for third-party agents, including rug-pull detection when upstream tools silently change their capabilities.
What compliance frameworks does Waxell support?
Waxell includes HIPAA, SOC 2, and PCI-DSS compliance profiles out of the box, with data residency options in US East and EU West. The platform maps to NIST AI RMF, the EU AI Act, and ISO/IEC 42001:2023, with industry overlays for financial services (Treasury FS AI RMF, SEC, FINRA), healthcare (HIPAA, 42 CFR Part 2), and other regulated sectors.
How is Waxell different from a gateway tool like Helicone or Portkey?
Modern gateways do more than watch. Portkey — now the Prisma AIRS AI Gateway under Palo Alto Networks — kills a failing request with a 446 status code and runs a documented “runtime policy enforcement” layer that stops unauthorized tool invocations before they execute. Helicone rejects flagged prompts pre-execution. So the old “gateways only see HTTP requests” answer no longer holds. What a gateway still can’t see is inside the agent: Waxell instruments at the SDK and runtime level — it sees agent reasoning, policy evaluation, cost attribution at every node, parent-child relationships between agents, and the full causal graph of execution. A gateway can rate-limit API calls; Waxell can enforce that a specific agent cannot exceed $50 across its entire spawn tree, halt an agent mid-run when it attempts to call an unauthorized tool, or pause execution for human approval before a financial transaction completes.
How long does it take to set up Waxell?
Observe: two lines of Python. Runtime: two decorators. Connect: zero code — add your existing tools and start. MCP Gateway: one endpoint. Most teams are running within a single session.
Can Waxell govern agents I didn't build — like Claude Code, Cursor, or custom GPT workflows?
Yes. That's what Waxell Connect does. It provides governance and coordination for third-party agents with no SDK and no code changes — including shared context, automatic handoffs, human-in-the-loop routing, and rug-pull detection.