> ## Documentation Index
> Fetch the complete documentation index at: https://docs.extend.ai/llms.txt
> Use this file to discover all available pages before exploring further.
>
> ## API version
> The current API version is `2026-02-09`, served at the site root (no version prefix in URLs).
> If this page URL contains `/2025-04-21/` or `/2024-12-23/`, you are reading an older API version.
> Prefer the current docs at https://docs.extend.ai/llms.txt unless the user explicitly needs that older version.
> Do not treat older-version pages as the source of truth for new integrations.

# Running Evaluation Sets

> Start an evaluation set run against a processor version, poll it to completion, and read accuracy metrics using the SDK (Python, TypeScript, Java, Go) or Extend Studio. Covers evaluationSetRuns.create, evaluationSetRuns.retrieve, and evaluationSetItems.update.

An evaluation set run scores one processor version against every item in an [evaluation set](/evaluation/creating-evaluation-sets) and returns aggregate metrics: overall accuracy plus a per-field (extractors), per-class (classifiers), or precision/recall (splitters) breakdown. Running well-maintained sets is the most reliable way to check that a configuration change improved a processor before you publish it. Evaluation sets can also be run against workflows to score end-to-end output; this page covers processor runs.

## Via the API

A run is asynchronous: `create` returns immediately with a run in `PENDING` state, and you poll `retrieve` until the status is terminal.

### Start the run

Pass the evaluation set ID and, optionally, the processor and version to evaluate. If you omit `entity`, the set's default processor runs at its **draft** version. `version` accepts `"draft"`, `"latest"`, or a published version string such as `"1.0"`. To run a subset, pass `evaluationSetItemIds`.

#### Python

```python
from extend_ai import Extend

client = Extend()

run = client.evaluation_set_runs.create(
    evaluation_set_id="ev_2LcgeY_mp2T5yPaEuq5Lw",
    entity={"id": "ex_Xj8mK2pL9nR4vT7qY5wZ", "version": "draft"},
)
print(run.id, run.status)  # "bpr_..." "PENDING"
```

#### TypeScript

```typescript
import { ExtendClient } from "extend-ai";

const client = new ExtendClient();

let run = await client.evaluationSetRuns.create({
  evaluationSetId: "ev_2LcgeY_mp2T5yPaEuq5Lw",
  entity: { id: "ex_Xj8mK2pL9nR4vT7qY5wZ", version: "draft" },
});
console.log(run.id, run.status); // "bpr_..." "PENDING"
```

#### Java

```java
import ai.extend.ExtendClient;
import ai.extend.resources.evaluationsetruns.requests.EvaluationSetRunsCreateRequest;
import ai.extend.resources.evaluationsetruns.types.EvaluationSetRunsCreateRequestEntity;
import ai.extend.types.EvaluationSetRun;

ExtendClient client = ExtendClient.builder().build();

EvaluationSetRun run = client.evaluationSetRuns().create(
    EvaluationSetRunsCreateRequest.builder()
        .evaluationSetId("ev_2LcgeY_mp2T5yPaEuq5Lw")
        .entity(EvaluationSetRunsCreateRequestEntity.builder()
            .id("ex_Xj8mK2pL9nR4vT7qY5wZ")
            .version("draft")
            .build())
        .build());
System.out.println(run.getId() + " " + run.getStatus()); // "bpr_... PENDING"
```

#### Go

```go
package main

import (
	"context"
	"fmt"
	"log"
	"time"

	extend "github.com/extend-hq/extend-go-sdk"
	client "github.com/extend-hq/extend-go-sdk/client"
)

func main() {
	c := client.NewClient()
	ctx := context.Background()

	run, err := c.EvaluationSetRuns.Create(ctx, &extend.EvaluationSetRunsCreateRequest{
		EvaluationSetID: "ev_2LcgeY_mp2T5yPaEuq5Lw",
		Entity: &extend.EvaluationSetRunsCreateRequestEntity{
			ID:      "ex_Xj8mK2pL9nR4vT7qY5wZ",
			Version: extend.String("draft"),
		},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(run.ID, run.Status) // "bpr_..." "PENDING"
}
```

### Poll until the run finishes

`status` moves `PENDING` → `PROCESSING` → one of the terminal states `PROCESSED`, `FAILED`, or `CANCELLED`. Metrics are only meaningful once the status is `PROCESSED`. A run over a large set can take several minutes; poll every few seconds.

#### Python

```python
import time

TERMINAL = {"PROCESSED", "FAILED", "CANCELLED"}

while run.status not in TERMINAL:
    time.sleep(5)
    run = client.evaluation_set_runs.retrieve(run.id)

if run.status != "PROCESSED":
    raise RuntimeError(f"Evaluation run {run.id} ended with status {run.status}")
```

#### TypeScript

```typescript
const TERMINAL = new Set(["PROCESSED", "FAILED", "CANCELLED"]);

while (!TERMINAL.has(run.status)) {
  await new Promise((resolve) => setTimeout(resolve, 5_000));
  run = await client.evaluationSetRuns.retrieve(run.id);
}

if (run.status !== "PROCESSED") {
  throw new Error(`Evaluation run ${run.id} ended with status ${run.status}`);
}
```

#### Java

```java
import ai.extend.types.BatchRunStatus;
import java.util.Set;

Set<BatchRunStatus> terminal = Set.of(
    BatchRunStatus.PROCESSED, BatchRunStatus.FAILED, BatchRunStatus.CANCELLED);

while (!terminal.contains(run.getStatus())) {
    Thread.sleep(5_000);
    run = client.evaluationSetRuns().retrieve(run.getId());
}

if (!run.getStatus().equals(BatchRunStatus.PROCESSED)) {
    throw new IllegalStateException(
        "Evaluation run " + run.getId() + " ended with status " + run.getStatus());
}
```

#### Go

```go
for run.Status != extend.BatchRunStatusProcessed &&
	run.Status != extend.BatchRunStatusFailed &&
	run.Status != extend.BatchRunStatusCancelled {
	time.Sleep(5 * time.Second)
	run, err = c.EvaluationSetRuns.Retrieve(ctx, run.ID, &extend.EvaluationSetRunsRetrieveRequest{})
	if err != nil {
		log.Fatal(err)
	}
}

if run.Status != extend.BatchRunStatusProcessed {
	log.Fatalf("evaluation run %s ended with status %s", run.ID, run.Status)
}
```

### Read the metrics

`metrics` is a discriminated union on `type`. Every variant carries `numFilesTotal`, `numFilesProcessed`, and latency percentiles; the accuracy fields depend on the processor:

| `metrics.type` | Accuracy fields                                                                                                                                                                                                            |
| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `EXTRACT`      | `accuracy` (aggregate across reviewed fields) and `fieldMetrics`, a map from schema field path to `{ countTotal, countPresent, countExpected, countAccurate, accuracy }`. Nested fields are flattened to dot-joined paths. |
| `CLASSIFY`     | `accuracy` (share of files whose predicted class matched) and `classificationMetrics`, a map from classification type to per-class precision, recall, and F1.                                                              |
| `SPLITTER`     | `precision`, `recall`, `f1`, plus `numSplitsExpected`, `numSplitsPredicted`, `numSplitsCorrect`.                                                                                                                           |

Array fields are scored with the cell-level method described in [Calculating Array Accuracy](/evaluation/calculating-array-accuracy).

#### Python

```python
metrics = run.metrics

if metrics.type == "EXTRACT":
    print(f"Overall accuracy: {metrics.accuracy:.1%}")
    for field, m in sorted(
        (metrics.field_metrics or {}).items(), key=lambda kv: kv[1].accuracy or 0
    ):
        print(f"  {field}: {m.accuracy:.1%} ({m.count_accurate}/{m.count_expected})")
```

#### TypeScript

```typescript
const metrics = run.metrics;

if (metrics.type === "EXTRACT") {
  console.log(`Overall accuracy: ${((metrics.accuracy ?? 0) * 100).toFixed(1)}%`);
  for (const [field, m] of Object.entries(metrics.fieldMetrics ?? {}).sort(
    ([, a], [, b]) => (a.accuracy ?? 0) - (b.accuracy ?? 0),
  )) {
    console.log(`  ${field}: ${((m.accuracy ?? 0) * 100).toFixed(1)}% (${m.countAccurate}/${m.countExpected})`);
  }
}
```

#### Java

```java
import ai.extend.types.ExtractEvaluationSetRunMetrics;

run.getMetrics().getExtract().ifPresent((ExtractEvaluationSetRunMetrics metrics) -> {
    System.out.printf("Overall accuracy: %.1f%%%n", metrics.getAccuracy().orElse(0.0) * 100);
    metrics.getFieldMetrics().orElse(java.util.Map.of()).forEach((field, m) ->
        System.out.printf("  %s: %.1f%% (%.0f/%.0f)%n",
            field,
            m.getAccuracy().orElse(0.0) * 100,
            m.getCountAccurate().orElse(0.0),
            m.getCountExpected().orElse(0.0)));
});
```

#### Go

```go
if metrics := run.Metrics.Extract; metrics != nil {
	if metrics.Accuracy != nil {
		fmt.Printf("Overall accuracy: %.1f%%\n", *metrics.Accuracy*100)
	}
	for field, m := range metrics.FieldMetrics {
		// Accuracy is omitted when a field has no expected values in the set.
		if m.Accuracy == nil || m.CountAccurate == nil || m.CountExpected == nil {
			continue
		}
		fmt.Printf("  %s: %.1f%% (%.0f/%.0f)\n",
			field, *m.Accuracy*100, *m.CountAccurate, *m.CountExpected)
	}
}
```

### Update an item's expected output

When a run shows that the *expected* value was wrong rather than the processor, correct the item so future runs score against the right ground truth. Pass a complete `expectedOutput`, in the same shape you used when [creating the item](/evaluation/creating-evaluation-sets#produce-the-expected-output).

#### Python

```python
item = client.evaluation_set_items.update(
    "ev_2LcgeY_mp2T5yPaEuq5Lw",
    "evi_kR9mNP12Qw4yTv8BdR3H",
    expected_output={"value": corrected_value},
)
```

#### TypeScript

```typescript
const item = await client.evaluationSetItems.update(
  "ev_2LcgeY_mp2T5yPaEuq5Lw",
  "evi_kR9mNP12Qw4yTv8BdR3H",
  { expectedOutput: { value: correctedValue } },
);
```

#### Java

```java
import ai.extend.resources.evaluationsetitems.requests.EvaluationSetItemsUpdateRequest;
import ai.extend.types.EvaluationSetItem;
import ai.extend.types.ProvidedExtractOutput;
import ai.extend.types.ProvidedProcessorOutput;

EvaluationSetItem item = client.evaluationSetItems().update(
    "ev_2LcgeY_mp2T5yPaEuq5Lw",
    "evi_kR9mNP12Qw4yTv8BdR3H",
    EvaluationSetItemsUpdateRequest.builder()
        .expectedOutput(ProvidedProcessorOutput.of(
            ProvidedExtractOutput.builder().value(correctedValue).build()))
        .build());
```

#### Go

```go
item, err := c.EvaluationSetItems.Update(ctx,
	"ev_2LcgeY_mp2T5yPaEuq5Lw",
	"evi_kR9mNP12Qw4yTv8BdR3H",
	&extend.EvaluationSetItemsUpdateRequest{
		ExpectedOutput: &extend.ProvidedProcessorOutput{
			ProvidedExtractOutput: &extend.ProvidedExtractOutput{Value: &correctedValue},
		},
	})
if err != nil {
	log.Fatal(err)
}
```

**What the API does not expose today.** The run object carries aggregate metrics only. Per-document actual-vs-expected diffs, CSV export, run-to-run comparison, and the scoring options below (field exclusion, matcher type, null coalescing) are available in Extend Studio. If you need a per-document view in code, run the processor on each item's file yourself and diff against the item's `expectedOutput`.

## Via Extend Studio

1. Open the runner from either of two places:

   * The runner page for the processor that the evaluation set is tied to.

   ![Eval runner in Extend Studio](https://fdr-prod-docs-files-public.s3.us-east-1.amazonaws.com/extendconfig.docs.buildwithfern.com/1cab432a5ac7e737729e0803cba6be318de3c6ebe4065db5775e1cc13c14784a/assets/images/evaluations/eval_runner.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA6KXJSKKNFOCF7G4B%2F20260916%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20260916T213047Z&X-Amz-Expires=604800&X-Amz-Signature=949ddeeff342a512f427f20b2c10e2d51dd18632841bce4c83dd7da32a991daa&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)

   * The evaluation set's home page.

   ![Eval runner home screen listing evaluation sets](https://fdr-prod-docs-files-public.s3.us-east-1.amazonaws.com/extendconfig.docs.buildwithfern.com/7d9bf3108a6c55fb340e146255377ea5751072d2eda14b805b95ec8b7f4a36a3/assets/images/evaluations/eval_runner_home.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA6KXJSKKNFOCF7G4B%2F20260916%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20260916T213047Z&X-Amz-Expires=604800&X-Amz-Signature=516fdfc065be50722a7515e704ca18a5557f4ff323639aa10377974ee6815925&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)

2. Click the "Run" button on the evaluation set you want to run. This opens the run dialog.

   ![Dialog for configuring and starting an evaluation run](https://fdr-prod-docs-files-public.s3.us-east-1.amazonaws.com/extendconfig.docs.buildwithfern.com/e78a7fdc8c203aa2ad1aa6fb2e085ee74418cce4d61d90b8067bcaa9145a5827/assets/images/evaluations/eval_run_dialog.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA6KXJSKKNFOCF7G4B%2F20260916%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20260916T213047Z&X-Amz-Expires=604800&X-Amz-Signature=ebbfbbc1ecee4da9dfa0304008e2b3f1851ab73b8bc17c77558ddc4722256a40&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)

3. The defaults are the processor and version you selected in the runner. You can change the version, or the processor itself, before running. See [Advanced options](#advanced-options) below.

4. Click "Run Evaluation" to start. You are redirected to the evaluation run page, where you can watch progress.

   ![Evaluation run results with per-field accuracy scores](https://fdr-prod-docs-files-public.s3.us-east-1.amazonaws.com/extendconfig.docs.buildwithfern.com/4aafee0216f871da6a2f1e1d58dc3917f8126cfe7e2df515db2d0562e9d44939/assets/images/evaluations/eval_results.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA6KXJSKKNFOCF7G4B%2F20260916%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20260916T213047Z&X-Amz-Expires=604800&X-Amz-Signature=bec56f85fcdfecff83126b4fa7a51ab6f629c47f39151b185836eb38caaa5bc1&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)

   A metrics summary sits at the top of the page, with the list of documents and their results below. Each processor type has its own metrics view; a classifier, for instance, shows a per-type accuracy distribution and a confusion-matrix-style view.

5. Click a row to compare actual vs. expected outputs for that document.

   ![Diff view comparing expected and actual extraction outputs](https://fdr-prod-docs-files-public.s3.us-east-1.amazonaws.com/extendconfig.docs.buildwithfern.com/6ca0a56af4084d386f83f1e5e88f9ca70120e66a42e4287166aeb329748cd5fa/assets/images/evaluations/eval_diff.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA6KXJSKKNFOCF7G4B%2F20260916%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20260916T213047Z&X-Amz-Expires=604800&X-Amz-Signature=533541092b6f09dc1572b32b9ac5cf5f1bd51eb909fbf8cee04672c6f9caae5b&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)

6. Download the results as a CSV with the Export button.

   ![Exporting evaluation results to CSV](https://fdr-prod-docs-files-public.s3.us-east-1.amazonaws.com/extendconfig.docs.buildwithfern.com/c10472fffec26d1e61b03ef0c42aed4aded4273f0264a6e8057f66e0e1ba51fc/assets/images/evaluations/csv_export.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA6KXJSKKNFOCF7G4B%2F20260916%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20260916T213047Z&X-Amz-Expires=604800&X-Amz-Signature=3018fe064cd51682c7e7836e94f0cb50a69182bd0e27a29b1355e9e3597d767e&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)

7. Adopt a run's actual output as the new expected output for an item with the "Update" button.

   ![Updating an evaluation set item with a corrected expected value](https://fdr-prod-docs-files-public.s3.us-east-1.amazonaws.com/extendconfig.docs.buildwithfern.com/bde17592ec893ccacb84d505d3673b4af7de4a30d383b1278720270ab25ecbc1/assets/images/evaluations/update_eval_item.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA6KXJSKKNFOCF7G4B%2F20260916%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20260916T213047Z&X-Amz-Expires=604800&X-Amz-Signature=ac641265359c3bcd954e8b05dc53d29efe2d599619f871a145166956a9548777&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)

## Advanced options

These options are configured in the Studio run dialog and affect how metrics are calculated.

### Excluding fields (extractors only)

To exclude a field from the run's metrics, uncheck the checkbox next to it. Per-document and overall accuracy will not take this field into account.

![Excluding a field from evaluation scoring](https://fdr-prod-docs-files-public.s3.us-east-1.amazonaws.com/extendconfig.docs.buildwithfern.com/9dd2aef66feb013cfb451af65e8c2ebb3b2a0dfe7d58cc1b7d7d65e7e6455dff/assets/images/evaluations/exclude_field.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA6KXJSKKNFOCF7G4B%2F20260916%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20260916T213047Z&X-Amz-Expires=604800&X-Amz-Signature=12bd73794158f37e77f33e49d2f768b5084c13a63240d7573ad9ee29926b5600&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)

### Matcher type (extractors only)

For string fields, you can configure a custom matcher. Four are available: strict, fuzzy, LLM judge, and vector.

![Configuring a field matcher for evaluation comparisons](https://fdr-prod-docs-files-public.s3.us-east-1.amazonaws.com/extendconfig.docs.buildwithfern.com/43baf13b7b0ba3f0748b7e685307b2656c82f5d71ccea27bbcafeae0584690e8/assets/images/evaluations/matcher.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA6KXJSKKNFOCF7G4B%2F20260916%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20260916T213047Z&X-Amz-Expires=604800&X-Amz-Signature=2b2bc8176df7094510a038e6b4fae367c14f500c10bc05b82b62b0496f65b1dc&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)

#### Strict

The default matcher. Checks for exact, case-sensitive string equality.

#### Fuzzy

Uses fuzzy matching distance, allowing small differences between actual and expected output. You configure a threshold; values above it count as a match. Uses a modified [Levenshtein distance](https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance) algorithm.

*Recommended if you expect some variability, but only by a few characters.*

#### LLM Judge

Passes the actual and expected output to an LLM and asks whether they are semantically the same. By default it handles date formats (1/1/2025 vs Jan 1st 2025), abbreviations (St. vs Street), and numerals (1,000,000 vs one million).
We *highly* recommend adding a custom instruction that acts as a rubric for the model.

For example: Return true if and only if the expected and actual output have the same address, but you can ignore added or removed text.

*Recommended if the extracted values are long sentences or paragraphs, or if you expect variability and want to define custom matching rules.*

#### Vector

Embeds both values and computes cosine similarity. Semantically similar values score higher ("house" and "home"); dissimilar values score lower ("hot" and "cold"). You configure a threshold; values above it count as a match.

*Recommended if you are matching on the value's meaning.*

### Null coalescing (extractors only)

For booleans, null and false are treated as a match. For numbers, 0 and null are treated as a match. For currency, \$0.00 and null are a match.

![Null coalescing option for evaluation field comparisons](https://fdr-prod-docs-files-public.s3.us-east-1.amazonaws.com/extendconfig.docs.buildwithfern.com/0f12258d85eadeed33d15c4b26786c8ac46c74150165c0dcc97a02c3685650fb/assets/images/evaluations/null_coalescing.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA6KXJSKKNFOCF7G4B%2F20260916%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20260916T213047Z&X-Amz-Expires=604800&X-Amz-Signature=e5375d0be9cf918f50a6a1a771729b08b908df7b56a99ad61e9f0962c4ff7a44&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)

### Rate limits and file pre-processing cache (all processors)

The rate limit caps how many runs this evaluation set run executes in a time period.

Clearing the pre-processing cache re-runs pre-processing operations such as chunking and metadata extraction.

## Compare accuracy across runs

To see how a set is trending, compare accuracy across runs. Select the runs to compare and click "Compare runs" in the runs tab of the evaluation set home page.

![Comparing two evaluation runs side by side](https://fdr-prod-docs-files-public.s3.us-east-1.amazonaws.com/extendconfig.docs.buildwithfern.com/3615692721cd3bcf862ba2e818cfdfd1e0c867067b179b09ce2c499acd625c45/assets/images/evaluations/compare.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA6KXJSKKNFOCF7G4B%2F20260916%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20260916T213047Z&X-Amz-Expires=604800&X-Amz-Signature=b16a514e3b6d597b44dc2604db036510db017cb28768046839712910fd5b58f2&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)

The dialog shows color-coded accuracy metrics and whether each increased or decreased between runs. Hover over a column for the exact percentage change.

![Dialog for selecting evaluation runs to compare](https://fdr-prod-docs-files-public.s3.us-east-1.amazonaws.com/extendconfig.docs.buildwithfern.com/19dabf34b0e4bddc120527e33b9c8347f4d3bb37fe4966a17ce21ebf021c791e/assets/images/evaluations/compare_dialog.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA6KXJSKKNFOCF7G4B%2F20260916%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20260916T213047Z&X-Amz-Expires=604800&X-Amz-Signature=af3f0711453d2cb4480adaf44a9eef1cd2fe5ec59f50c8ac48b116253caa60cd&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)

## Reference

* [Create Evaluation Set Run](/api-reference/endpoints/evaluation/create-evaluation-set-run), [Get Evaluation Set Run](/api-reference/endpoints/evaluation/get-evaluation-set-run), [Update Evaluation Set Item](/api-reference/endpoints/evaluation/update-evaluation-set-item)
* [Creating Evaluation Sets](/evaluation/creating-evaluation-sets): build the set the run scores against
* [Calculating Array Accuracy](/evaluation/calculating-array-accuracy): how array and table fields are scored
* [Processors](/evaluation/processors#versioning): what `"draft"`, `"latest"`, and published versions mean
* [Composer](/optimization/composer): use evaluation sets to optimize a processor's configuration automatically