---
title: "Introducing Operator-1: an Autonomous Document Extraction Agent"
description: "Operator-1 is an autonomous document extraction agent that saturates three extraction benchmarks in accuracy and learns with every run."
author: "Joe Bajor, Jing Reyhan"
category: "Product"
published: 2026-10-07
updated: 2026-10-07
canonical: https://www.extend.ai/resources/introducing-operator-1
---

# Introducing Operator-1: an Autonomous Document Extraction Agent

Today, we’re launching Operator-1, an autonomous document extraction agent. Operator-1 is SOTA on several 3rd party benchmarks and sets the new standard for accuracy on complex documents.

**TL;DR**

- **What’s new:** Operator-1 is an autonomous extraction agent that solves challenges within complex documents, such as long table extraction, large files with thousands of pages, dense diagrams and images, and more.
- **How:** A specialized agent runs within a purpose-built workspace, has access to document processing tools (parsing, search, code execution, validations), and learns via persistent memory.
- **Best fit use cases:** Long tables in financial statements, legal documents that run thousands of pages, and document packets that need nested JSON to preserve relationships.
- **Results:** Operator-1 sets a new standard for complex extraction, saturating three benchmarks with scores of 99.3% on LongArray-Extract, 99.88% on LongExtractionBench, and 96.57% on ExtractBench.
## Operator-1 sets a new performance record across three extraction benchmarks

Operator-1 sets a new standard for complex document extraction, saturating three benchmarks: 99.3% on LongArray-Extract, 99.88% on LongExtractionBench, and 96.57% on ExtractBench. Each benchmark uses a different dataset and evaluation methodology; two of the three benchmarks were published by third parties.

| Benchmark | What it tests | Score |
| --- | --- | --- |
| [LongArray-Extract](https://www.extend.ai/resources/long-array-extraction-benchmark) | Accurate and complete extraction of long arrays from real-world documents | 99.3% |
| [LongExtractionBench](https://www.micro1.ai/benchmark/long-extraction) | Filling JSON schemas from long documents | 99.88% |
| [ExtractBench](https://arxiv.org/abs/2607.29677) | Structured extraction across business documents | 96.57% |
### LongArray-Extract (Aggregate accuracy)

| Model | Accuracy score |
| --- | --- |
| Operator-1 | 99.3% |
| Extend MAX | 99.2% |
| Reducto Deep Extract | 97.4% |
| Gemini 3.1 Pro · direct | 47.3% |
| GPT-5.5 · direct | 31.6% |

### LongExtractionBench (Leaf accuracy)

| Model | Accuracy score |
| --- | --- |
| Operator-1 | 99.88% |
| Reducto Deep Extract | 99.3% |
| GPT-5.5 · direct | 96.2% |
| Gemini 3.1 Pro · direct | 96.2% |
| Extend MAX | 92.8% |
| LlamaExtract | 88.9% |

### ExtractBench (Overall value F1)

| Model | Accuracy score |
| --- | --- |
| Operator-1 | 96.57% |
| LlamaIndex Agentic Plus v2.5 | 96.38% |
| LlamaIndex Agentic v2.5 | 95.8% |
| LlamaIndex Cost Effective v2.5 | 93.9% |
| Reducto Deep Extract | 90.44% |
| GPT-5.5 · direct | ~88.7% |
| Extend MAX | 86.29% |
| Gemini 3.1 Pro · direct | ~78.2% |

Published benchmark results, not a new head-to-head evaluation. Direct model baselines use single-shot extraction. ExtractBench includes LlamaIndex’s [October 1 v2.5 results](https://www.llamaindex.ai/blog/introducing-extract-v2-5). For Operator-1’s ExtractBench result, we normalize null and empty responses because both indicate no extracted value for downstream applications. This yields 96.57%, compared with 96.4% without normalization. We plan to submit this scorer change as a PR to the ExtractBench repository.

LongArray-Extract was published by Extend. It is open source and independently reproducible, and we encourage you to evaluate it on your own documents. LongExtractionBench was published by micro1 and co-designed by Reducto. ExtractBench was published by LlamaIndex.

## What Operator-1 solves

Existing extraction solutions break down on complex extraction tasks that require the highest levels of accuracy — financial tables that stretch for thousands of rows, long legal documents with related context scattered throughout, healthcare charts with dense figures and diagrams.

This is because traditional extraction relies on naive approaches (e.g. simple chunking, single-pass extraction with a model). This works on simple documents, but doesn’t handle hard edge cases found in many domains and is slow and expensive.

### Long tables

We heard from many teams that extracting data from large tables (e.g. in finance or insurance) with hundreds or thousands of rows often runs into issues with skipped entries, duplicate information, or incorrect data.

Operator-1 parses documents to identify table structures, executes scripts to map and extract data, and even inspects page breaks to ensure that data isn’t lost across boundaries. It can even run validations to check its work iteratively (e.g. sum the line items and ensure it adds up to the total).

### Lengthy documents

Documents with hundreds or thousands of pages are challenging to extract from because information is typically scattered across multiple sections. Operator-1 parses documents and searches across the text to identify the right pages in files that run thousands of pages. 

### Dense images and diagrams

Some documents can contain very dense images, diagrams, or charts (such as those within healthcare or construction).

Operator-1 can zoom in/out of images and crop regions of a page to better inspect text hidden within these areas.

## How we built Operator-1

Operator-1 is a specialized agent that runs within a dedicated workspace we built specifically for document extraction. It has access to tools like:

| Tool | What Operator-1 uses it for |
| --- | --- |
| Inspection | View page breaks and other page region crops |
| Parsing | Makes document content available for extraction |
| Code execution | Writes and executes scripts to validate and transform data according to the extraction task at hand. |
| Search | Uses command-line and custom search tools to find and connect information across thousands of pages |
| Validations | Checks results against the task’s requirements and triggers another attempt when a check fails |
| Memory and runbooks | Remembers the code and approach that worked for a document type for subsequent extractions |
Operator-1 works in a workspace with document tools: visual inspection of figures and tables; script writing and code execution; reading across pages to retain context; and extraction into the requested schema.

## Pricing & availability

Operator-1 is available today in the Extend dashboard and API. It’s included on all our plans, including PAYG, Scale, and Enterprise. Operator-1 charges a fixed 5 credits per page.

Memory and runbooks let Operator-1 reuse an approach that worked for a document type. As Operator-1 learns from previous runs of a document type within your tenant, it can reuse successful strategies and work more efficiently over time.

## Get started for free

We’re on a mission to help our customers automate every document. Put Operator-1 to work on your hardest documents: [Try Extend](https://dashboard.extend.ai/).

### Start building with Operator-1

Set EXTEND_API_KEY for the SDKs and replace YOUR_DOCUMENT_URL with a publicly reachable document URL. The example extracts a total; replace the schema with the fields you need.

#### Python

Install and authenticate

```bash
pip install extend-ai
export EXTEND_API_KEY="YOUR_API_KEY"
```

Use a key from the Developers page. The SDK reads EXTEND_API_KEY and waits for the extraction to finish.

Run your extractor

```python
from extend_ai import Extend

result = Extend().extract_runs.create_and_poll(
    config={
        "base_processor": "extraction_operator",
        "schema": {
            "type": "object",
            "properties": {"total": {"type": ["number", "null"]}},
        },
    },
    file={"url": "YOUR_DOCUMENT_URL"},
)
print(result.output.value if result.output else result.status)
```

#### TypeScript

Install and authenticate

```bash
npm install extend-ai
export EXTEND_API_KEY="YOUR_API_KEY"
```

Use a key from the Developers page. The SDK reads EXTEND_API_KEY and waits for the extraction to finish.

Run your extractor

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

const result = await new ExtendClient().extractRuns.createAndPoll({
  config: {
    baseProcessor: "extraction_operator",
    schema: {
      type: "object",
      properties: { total: { type: ["number", "null"] } },
    },
  },
  file: { url: "YOUR_DOCUMENT_URL" },
});
console.log(result.output?.value ?? result.status);
```

#### CLI

Install and sign in

```bash
curl -fsSL https://extend.ai/install.sh | sh
extend setup
```

The setup wizard opens browser sign-in or accepts an API key. Replace document.pdf with your file path.

Extract from a local document

```bash
extend extract document.pdf \
  --config '{"baseProcessor":"extraction_operator","schema":{"type":"object","properties":{"total":{"type":["number","null"]}}}}' \
  > result.json
```

#### MCP

Connect your client

```json
{
  "mcpServers": {
    "extend": {
      "url": "https://mcp.extend.ai/mcp"
    }
  }
}
```

Add this to Cursor’s MCP configuration, then complete the Extend OAuth sign-in. Other clients have their own setup steps.

Attach a document and ask your agent

```text
Use Operator-1 (extraction_operator) to extract
data from the attached PDF. Wait for the run to finish
and return the extracted values as JSON.
```

[SDK documentation](https://docs.extend.ai/sdks)

[CLI guide](https://docs.extend.ai/cli)

[MCP setup](https://docs.extend.ai/mcp)