🤖 AI

What Is Your Agent's GPA? A Framework for Evaluating Agent Goal-Plan-Action Alignment

This paper introduces the Agent GPA framework, a scalable and generalizable evaluation system that uses automated prompt optimization to generate domain-specific LLM judges for measuring Goal-Plan-Action alignment, thereby effectively identifying and localizing agent failures across diverse benchmarks with high accuracy and agreement with human evaluators.

Original authors: Allison Sihan Jia, Daniel Huang, Nikhil Vytla, Seung Won Wilson Yoo, Nirvika Choudhury, Shayak Sen, John C. Mitchell, Anupam Datta

Published 2026-03-31

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Allison Sihan Jia, Daniel Huang, Nikhil Vytla, Seung Won Wilson Yoo, Nirvika Choudhury, Shayak Sen, John C. Mitchell, Anupam Datta

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you hire a brilliant, hyper-intelligent robot assistant to solve a complex problem, like planning a cross-country road trip or fixing a broken piece of software. You give it a goal, and it goes to work. But sometimes, it fails.

The problem with most current ways of testing these robots is that they only look at the final result. Did the robot get the right answer? Yes or No. If the answer is "No," you're left scratching your head: Why did it fail? Did it get confused at the start? Did it pick the wrong map? Did it drive off a cliff even though it had a good map?

This paper introduces a new way to grade these AI agents called Agent GPA (Goal-Plan-Action). Think of it not as a single final grade, but as a detailed report card that breaks down exactly where the student (the robot) went wrong.

The Three Pillars of the Report Card

The authors argue that every time an AI agent works, it goes through three mental stages. The "GPA" framework checks each one individually:

Goal (The Destination): Did the robot understand what you actually wanted?
- Analogy: Imagine you ask a travel agent to "book a hotel in Paris." If the agent books a hotel in London because it misheard you, that's a Goal Failure. The destination was wrong from the start.
Plan (The Map): Did the robot come up with a good strategy to get there?
- Analogy: The agent understood "Paris," but its plan was to "walk there." That's a Plan Quality Failure. The map was terrible, even if the destination was right.
Action (The Driving): Did the robot actually follow the map and drive the car correctly?
- Analogy: The agent had a great plan to drive to Paris, but it forgot to put gas in the car, or it took a wrong turn at the first exit. That's an Action Failure.

The "Specialist Teachers" vs. The "Generalist"

In the past, researchers used one giant "Judge" (a single AI) to look at the whole process and say, "You failed." This is like having one teacher grade your math, history, and art homework all at once. They might miss the specific reason you got the math wrong because they are too busy looking at the art.

The Agent GPA framework uses a team of specialist judges.

One judge only looks at the Goal.
One judge only looks at the Plan.
One judge only looks at the Actions (like tool usage or code writing).

Why is this better?
The paper found that this team of specialists caught 95% of the errors that human experts found, whereas the single "Generalist" judge only caught about 55%. It's like having a team of doctors: a cardiologist, a neurologist, and a dermatologist are much better at diagnosing a complex illness than one general practitioner trying to do it all alone.

The "Auto-Grader" Magic

You might ask, "But don't we need humans to grade these reports?"
The paper says: No, not anymore.

They used a clever trick called Prompt Optimization. Imagine you have a robot teacher. Instead of writing the grading rules yourself, you let the robot write and rewrite its own grading rules until it gets really good at spotting mistakes.

They tested this on public datasets (like coding challenges and research tasks).
The "Auto-Graded" rules performed just as well, or even better, than rules written by human experts.
This means we can scale this up to test millions of AI agents without needing a massive army of human reviewers.

The "Consistency" Check

One big problem with AI judges is that they are sometimes inconsistent. If you ask the same AI to grade the same homework twice, it might give you an "A" the first time and a "C" the second time. That's frustrating.

The authors used a technique called Evolutionary Optimization (like natural selection for computer code) to fix this. They let the AI "evolve" its grading instructions over and over, keeping the versions that were most consistent.

Result: They improved the consistency of their grading by up to 38%. Now, the AI judge is much more reliable, like a strict but fair teacher who always gives the same grade for the same work.

The Bottom Line

This paper gives us a microscope for AI agents. Instead of just saying "It failed," we can now say:

"The agent understood the goal perfectly, but its plan was inefficient, and it made a specific error when calling a tool."

This allows engineers to fix the exact part of the robot's brain that is broken, rather than just guessing. It turns AI development from a game of "guess and check" into a precise engineering discipline.

In short: Agent GPA is the ultimate report card for AI, using a team of specialist, self-improving robots to tell us exactly why our AI assistants are failing, so we can teach them to do better.

1. Problem Statement

The rapid advancement of agentic AI systems (LLMs that can reflect, plan, and execute tools) has outpaced the development of robust evaluation methodologies. Existing approaches suffer from three critical limitations:

Outcome Bias: Many methods focus solely on the final result, missing intermediate failures or providing no actionable insights into why an agent failed.
Monolithic Evaluation: Current "LLM-as-a-Judge" approaches often rely on a single, monolithic prompt to evaluate an entire agent trace. This lacks the resolution to diagnose specific root causes (e.g., distinguishing between a bad plan and a bad tool call).
Scalability and Ground Truth: High-quality evaluation often requires expensive human annotation or ground-truth references, which are unavailable for open-ended, real-world tasks.
Lack of Granularity: There is a need for a framework that can isolate failures at the intersection of Goal Setting, Plan Formulation, and Action Execution to enable targeted debugging and improvement.

2. Methodology: The Agent GPA Framework

The authors propose the Agent GPA (Goal-Plan-Action) framework, which decomposes agent evaluation into a factorized suite of specialized LLM judges. Instead of a single evaluator, the framework uses distinct metrics to assess specific components and their intersections.

Core Metrics

The framework defines seven specific metrics:

Goal Fulfillment (GF): Does the final output satisfy the user's intent?
Plan Quality (PQ): Is the initial plan optimal, feasible, and does it select the right tools? (Evaluated before execution).
Tool Selection (TS): Did the agent choose the most appropriate tool for each subtask?
Plan Adherence (PA): Did the agent execute the steps exactly as planned?
Tool Calling (TC): Were the tool inputs syntactically valid, and were outputs interpreted correctly?
Logical Consistency (LC): Is the reasoning grounded in prior context? Does the agent acknowledge errors and follow system instructions?
Execution Efficiency (EE): Is the path to the solution free of redundancies, loops, or wasted resources?

Technical Implementation

Factorized Judges: A suite of specialized LLM judges is deployed, each targeting a specific metric. This allows for precise localization of errors (e.g., identifying that an agent failed due to Tool Calling syntax rather than Plan Quality).
Prompt Engineering & Optimization:
- Generic Component: Domain-invariant definitions of metrics.
- Custom Component: Domain-specific instructions (agent architecture, few-shot examples) to adapt the judge to specific systems.
- Automation: The authors use GEPA (Reflective Prompt Evolution) to automatically optimize prompts for new domains, reducing the need for manual engineering.
- Consistency Optimization: They employ OpenEvolve (an evolutionary coding agent) to iteratively refine prompts, using score variance as a fitness objective to minimize stochasticity in LLM judgments.
Datasets: The framework was validated across three distinct benchmarks:
1. TRAIL/GAIA: Multi-agent reasoning (117 traces).
2. TRAIL/SWE-bench: Single coding agent (31 traces).
3. Snowflake Intelligence: Enterprise data analytics agent (17 traces).

3. Key Contributions

Novel Evaluation Framework: Introduction of the GPA framework, which shifts evaluation from outcome-based to process-based, categorizing failures into Goal, Plan, and Action dimensions.
Factorized Judge Architecture: Demonstration that specialized, modular judges significantly outperform monolithic baselines in both error identification and localization.
Automated Generalizability: A methodology using automated prompt optimization (GEPA) to adapt evaluation criteria to unseen agent architectures and domains without labor-intensive manual tuning.
Consistency Enhancement: A systematic approach using evolutionary algorithms (OpenEvolve) to reduce evaluation noise and improve inter-rater reliability of LLM judges.

4. Key Results

The paper presents extensive empirical validation across the three datasets:

Validity & Error Localization:
- On the TRAIL/GAIA test set, the GPA judge suite identified 95.0% of human-annotated errors and correctly localized 85.8% of them.
- In contrast, a standard monolithic baseline achieved only 54.8% identification and 49.1% localization.
- The GPA framework showed strong alignment with human evaluators, achieving 73.1% accuracy agreement on TRAIL/GAIA and 82.3% on the Snowflake Intelligence dataset.
Generalizability (GEPA):
- Automated prompt optimization (GEPA) matched or exceeded manually crafted prompts.
- On TRAIL/GAIA, GEPA improved Plan Quality recall from 52.4% to 76.2% and Logical Consistency from 83.6% to 88.8%.
- On the unseen TRAIL/SWE-bench dataset, GEPA-optimized judges improved Logical Consistency recall from 49.8% to 83.1% and Tool Calling from 55.5% to 84.7%, outperforming manual prompts.
Consistency (OpenEvolve):
- Initial LLM judges showed varying stability (Krippendorff's $\alpha$ ).
- Applying OpenEvolve to high-variance metrics significantly reduced noise. For Plan Quality, $\alpha$ improved from 0.628 to 0.814. For Tool Calling on SWE-bench, it improved from 0.539 to 0.743 (a 38% increase).

5. Significance and Impact

Targeted Debugging: By isolating failures to specific intersections (e.g., Plan vs. Action), the framework provides actionable insights for developers to fix specific architectural weaknesses rather than retraining entire models.
Scalability: The combination of factorized judges and automated prompt optimization (GEPA/OpenEvolve) offers a scalable path to evaluating diverse agent systems without relying on expensive human annotation or ground truth.
Reliability: The work demonstrates that LLM judges can be made highly consistent and reliable through evolutionary optimization, making them viable for production-grade evaluation pipelines.
Paradigm Shift: It moves the field away from "did the agent get the right answer?" toward "how did the agent think and act?" fostering the development of more interpretable and trustworthy agentic systems.

In conclusion, the Agent GPA framework provides a rigorous, generalizable, and automated paradigm for diagnosing agent failures, bridging the gap between theoretical agent capabilities and reliable real-world deployment.