Microsoft AgentRx: What the Framework Gets Right and Where It Falls Short

Microsoft AgentRx is a systematic debugging framework for AI agents, released in March 2026 by Microsoft Research. Where most agent debugging relies on manual log inspection and ad-hoc hypothesis testing, AgentRx introduces a structured six-stage diagnostic pipeline that transforms raw agent trajectories into actionable failure reports. The open-source framework has demonstrated a 23.6% improvement in failure localization and a 22.9% gain in root-cause attribution — numbers that represent a genuine step change from the "read the logs and guess" status quo.

The pipeline works through a precise sequence: Trajectory IR converts raw execution traces into a normalized intermediate representation, making agent behavior analyzable regardless of the underlying framework. Static Invariants identify expected behavioral patterns from the task specification. Dynamic Invariants derive runtime constraints from the agent's actual execution. The Checker cross-references static expectations against dynamic reality. The Judge evaluates whether deviations constitute genuine failures. The Report synthesizes everything into structured diagnostics with localized failure points and attributed root causes.

AgentRx was validated against a benchmark of 115 annotated failed trajectories spanning Tau-bench, Magentic-One, and Flash domains. The framework's nine-category failure taxonomy — covering issues from tool invocation errors to planning breakdowns to hallucinated capabilities — provides a vocabulary for agent failure that the field has lacked. Instead of "the agent didn't work," teams can now identify "the agent exhibited a Category 4 planning regression at step 17."

But here's the gap: AgentRx diagnoses beautifully — and then forgets everything it diagnosed.

What AgentRx Does With Debugging Memory Today

Microsoft AgentRx excels at within-analysis persistence. The six-stage pipeline maintains context as it progresses from raw trajectory to final report. The Checker knows what the Static Invariants established. The Judge has access to the Checker's deviation findings. The Report synthesizes the full pipeline's output. Within a single debugging session, the stages build on each other coherently.

What AgentRx does not provide is cross-session debugging intelligence. When one debugging analysis completes and the next begins, the framework starts from scratch. The nine-category taxonomy is static — it doesn't learn which failure categories dominate a particular agent deployment. The root-cause patterns identified in analysis one don't inform analysis two. A team debugging their customer service agent for the fiftieth time re-derives the same tool invocation failures that were diagnosed and fixed — then regressed — in prior analyses.

The 115-trajectory benchmark demonstrates this limitation at scale. Each trajectory is analyzed independently. The framework doesn't recognize that trajectories 12, 34, and 87 share a common root cause in how the agent handles ambiguous tool responses. It doesn't surface that Category 6 failures (hallucinated capabilities) cluster around specific model-task combinations. AgentRx treats each failed trajectory as novel even when the failure pattern is a known recurring issue.

This is the difference between agent debugging as a point-in-time activity and debugging as a compounding discipline. The former diagnoses individual failures; the latter builds institutional knowledge about why agents fail and how to prevent it. AgentRx delivers the former with remarkable precision but has no mechanism for the latter.

The MemU Agentic Memory Framework: Debugging Intelligence That Persists

The MemU Agentic Memory Framework provides the persistent debugging memory layer that AgentRx and similar diagnostic tools lack. Where AgentRx analyzes individual failure trajectories, MemU preserves the patterns, root causes, and resolution strategies across every analysis.

Diagnosing agent failures is necessary. Remembering what you diagnosed — and what fixed it — is what turns debugging from a repetitive cost into a compounding advantage. Agent debugging demands both precision and persistence.

Consider an AgentRx analysis that identifies a Category 3 tool invocation failure where the agent passes malformed JSON to an API endpoint. With the MemU Agentic Memory Framework, that diagnosis persists: the failure pattern, the root cause, and the fix. When a similar malformed-JSON pattern appears three deployments later, the system surfaces the prior diagnosis instantly instead of running the full six-stage pipeline from scratch.

The MemU Agentic Memory Framework integrates via REST API alongside any debugging and observability workflow. Key capabilities for debugging contexts:

• Failure pattern accumulation: Every AgentRx diagnosis feeds the memory graph. Root causes, failure categories, and resolution strategies persist as structured knowledge — not just logs, but queryable relationships between failure types, agent configurations, and task domains.
• Cross-deployment trend detection: MemU surfaces recurring failure patterns across deployments. When the same Category 4 planning regression appears in three consecutive releases, the system flags it as a systemic issue rather than treating each occurrence as novel.
• Resolution memory: Past fixes link to the failure patterns they addressed. When a known failure pattern recurs, MemU retrieves not just the diagnosis but the intervention that resolved it previously.

Head-to-Head: MemU vs. AgentRx Alone

AgentRx alone: Systematic, rigorous diagnostic pipeline. The six-stage architecture transforms raw trajectories into precise failure reports with localized attribution. The 23.6% improvement in failure localization and 22.9% in root-cause attribution represent real advances in agent debugging. But every analysis is independent. No pattern accumulation, no cross-session learning, no resolution memory. The framework diagnoses the same failure type with equal effort whether it's the first occurrence or the hundredth.

AgentRx + MemU Agentic Memory Framework: The same diagnostic rigor, now backed by persistent debugging intelligence. Every diagnosis enriches a knowledge graph of failure patterns. Recurring issues surface instantly. Resolution strategies accumulate alongside the failures they addressed. Agent debugging transforms from repetitive point-in-time analysis into a compounding discipline where each failure makes the system smarter about preventing the next one.

Empowering AgentRx: Better Together

Combining AgentRx's diagnostic pipeline with persistent memory through the MemU Agentic Memory Framework unlocks debugging workflows neither system achieves alone:

• Proactive failure prevention: Before deployment, query the memory graph for failure patterns associated with the agent's configuration and task domain. Address known vulnerabilities before they produce failures.
• Accelerated triage: When a failure occurs, MemU matches the trajectory's early signals against known failure patterns. Instead of running the full six-stage pipeline, the system can suggest likely root causes from historical matches within seconds.
• Taxonomy evolution: AgentRx's nine-category failure taxonomy becomes dynamic. As MemU accumulates deployment-specific failure patterns, new sub-categories emerge organically — Category 3a for JSON serialization failures versus Category 3b for authentication token expiry.
• Cross-team debugging knowledge: Debugging insights from one team's agent deployments transfer to another team facing similar architectures. Resolution strategies become organizational assets rather than tribal knowledge.

Get Started with MemU

Microsoft AgentRx brings scientific rigor to agent debugging with its six-stage diagnostic pipeline and structured failure taxonomy. What it doesn't provide is memory — the ability to retain, query, and build on prior debugging intelligence. The MemU Agentic Memory Framework adds that persistence layer, transforming individual diagnoses into compounding debugging knowledge.

Visit memu.pro to explore the Agentic Memory Framework API, or check out the GitHub repository to build agent systems that learn from every failure.

Tags: Microsoft AgentRx, agent debugging, agentic memory, AI agent memory, failure diagnosis, root-cause analysis, debugging intelligence, MemU AI