Evaluating Agents with MLflow Scorers and SME Feedback

What it is

Before an agent goes live you measure it. MLflow 3 runs the agent over an evaluation dataset with mlflow.genai.evaluate, records a trace of every step, and applies scorers that grade each answer.

Scorers are either built in LLM judges (correctness, safety, groundedness and more) or custom scorers you write. Subject matter experts add the human signal that judges and datasets are built from.

How it works

Tracing

A trace records each span of a request: retriever calls with the chunks returned, LLM calls with prompts and token counts, tool calls and latency. Turn it on with autologging for your library, such as mlflow.langchain.autolog(), or decorate your own functions with @mlflow.trace.

Traces are how you debug a bad answer. If the retrieved chunks do not contain the fact, fix retrieval; if they do and the answer is still wrong, fix the prompt or the model.

Running an evaluation

from mlflow.genai.scorers import Correctness, RelevanceToQuery, Safety, Guidelines
data = [{"inputs": {"question": "What is Delta Lake?"},
         "expectations": {"expected_facts": ["open table format", "ACID transactions"]}}]
results = mlflow.genai.evaluate(
    data=data, predict_fn=lambda question: agent.invoke(question),
    scorers=[Correctness(), RelevanceToQuery(), Safety(),
             Guidelines(name="polite", guidelines="The answer must be polite.")])

predict_fn is called with the keys of inputs as arguments. Each row gets a score and a written rationale from every scorer, and the run shows aggregates you can compare across versions.

Judges that need ground truth

Ground truth lives in expectations, as expected_facts or expected_response. Judges without ground truth can also run on live traffic, which has no expected answers.

Custom scorers

When no built in judge measures what the business needs, write a code based scorer with the @scorer decorator. It may read inputs, outputs, expectations and the trace, and returns a bool, a number, a yes or no string, or a Feedback object.

from mlflow.genai.scorers import scorer

@scorer
def cites_source(outputs) -> bool:
    return "[source:" in str(outputs)

Use code for checks a rule can decide (format, length, a required field, latency from the trace). Use a Guidelines judge for criteria that need judgment, written in plain language.

Incorporating SME feedback

A label schema of type expectation captures the correct answer, which becomes ground truth in your evaluation dataset. A schema of type feedback captures a rating or a category, which shows where the agent fails and what guidelines to write. Reviewers must be provisioned in the Databricks account and need edit access to the experiment.

Choosing an LLM by metrics

Run every candidate model through the same evaluation dataset and scorers, then compare quality scores with latency and token cost from the traces. Pick the smallest model that meets the quality bar; move up in size only when a measured metric fails.

Architecture matters too. A reasoning model can raise correctness on multi step questions at the price of latency and tokens, while a smaller instruction tuned model often matches it on simple extraction.

How the exam asks about this

• "There is no labeled dataset yet; check that answers are on topic and safe." Use RelevanceToQuery and Safety, which need no ground truth.
• "Every answer must end with a ticket number in a fixed format." Write a custom code scorer with @scorer.
• "Domain experts must correct answers so the team can build a test set." Run a labeling session with an expectation label schema.