README.md

metadata

license: cc-by-4.0
language:
  - en
pretty_name: APEX-Accounting
tags:
  - benchmarking
  - agent-evaluation
  - rubric-grading
  - accounting
  - finance
  - bookkeeping
  - professional-services
task_categories:
  - text-generation
  - question-answering
size_categories:
  - n<1K
annotations_creators:
  - expert-generated
language_creators:
  - expert-generated
source_datasets:
  - original
configs:
  - config_name: default
    data_files:
      - split: dev
        path: data/dev.jsonl
task_ids:
  - task-planning
  - conversational
dataset_info:
  features:
    - name: task_id
      dtype: string
    - name: task_name
      dtype: string
    - name: world_id
      dtype: string
    - name: prompt
      dtype: string
    - name: context_files
      sequence: string
    - name: rubric
      list:
        - name: id
          dtype: string
        - name: criterion_type
          dtype: string
        - name: description
          dtype: string
    - name: gold_output
      dtype: string
    - name: metadata
      struct:
        - name: category
          dtype: string
        - name: subcategory
          dtype: string
        - name: output_type
          dtype: string
        - name: world_entity_type
          dtype: string
        - name: estimated_completion_hours
          dtype: float64
        - name: author_role
          dtype: string
        - name: reviewer_role
          dtype: string
  splits:
    - name: dev
      num_examples: 10

APEX-Accounting

APEX-Accounting is a benchmark built by Mercor in partnership with Ramp to assess whether frontier models can do the real work of accountants: reconciling accounts, accruing expenses, posting transactions, and producing reports. Tasks run inside self-contained synthetic company worlds, each an accounting system loaded with data plus spreadsheets, PDFs, and other documents. Every task was authored and solved by practicing accountants and bookkeepers, who also wrote its grading rubric.

This repository is the public sample dev set: one world and 10 tasks. The scored benchmark (160 tasks across 10 held-out worlds) is closed and not published. As APEX-Accounting is a closed benchmark, leaderboard evals can be run for any frontier model on request (apex@mercor.com).

• Launch post: Introducing the AI Productivity Index for Accounting
• Leaderboard: mercor.com/apex/apex-accounting-leaderboard
• Paper: APEX-Accounting (arXiv:2607.27189)

10 task sample dev set at a glance

• This release: 10 tasks from one world, World 9 (Sterling, Marsh & Associates LLP), a Philadelphia boutique law firm. Broadly representative of the held-out set.
• Task categories: Reconciliation · Data Entry · Variance Analysis · Schedules & Accruals.
• Rubrics: binary, outcome-based criteria; 8.9 per task across the 10 dev-set tasks, 13.7 across the held-out set.
• Grading: LM-as-judge (DeepSeek-v4-Flash)
• Headline metric: Mean Criteria@3, the percentage of rubric criteria met, averaged over 3 runs per task.
• License: CC BY 4.0.

Repository contents

data/dev.jsonl          10 task records, one JSON object per line (loads as the `dev` split)
tasks/                  the same 10 records as formatted per-task JSON, for browsing
world/                  the world's 90 source files, shared by every task
  apps_data/quickbooks/   7 accounting-system exports
  filesystem/            83 workpapers, statements, registers, and invoices
task_files/             16 task-specific files (used for 8 of the 10 tasks)

from datasets import load_dataset
ds = load_dataset("mercor/apex-accounting", split="dev")

The world and task files sit outside data/ so they stay browsable in the Hub UI rather than being parsed as dataset rows. To fetch everything, including the files:

hf download mercor/apex-accounting --repo-type dataset --local-dir apex-accounting

Every file a task references is included: each context_files entry resolves under world/ or that task's own task_files/ directory.

Running the tasks

To execute and evaluate agents we use the open source Archipelago: Archipelago, a minimal port of our internal framework for running and evaluating AI agents against RL environments. It includes the Loop Harness used for the APEX-Accounting leaderboard runs, so these tasks can be run against the same execution loop.

This repository provides the tasks, rubrics, and world data. The environment an agent actually sees is assembled at run time. Be aware:

• Filesystem layout. At run time the agent browses a single flat filesystem: the contents of world/filesystem/ are mounted at the root, together with that task's own files from task_files/<task>/. The directory split in this repository is for browsing, not the layout the agent sees.
• Tools are not included. At run time the harness injects the tool layer the agent works through: the accounting-software interface and the other tools it calls. That is not part of this release. What ships in world/apps_data/quickbooks/ is the underlying accounting-system data as static exports, which the tool layer reads; on the leaderboard the agent queries it through those tools rather than opening the files directly.
• Run limits. Leaderboard runs allow a maximum of 500 steps and 5 million tokens per task, where a step is one model turn that may include reasoning and one or more tool calls. The harness tells the model at each step how many steps and tokens remain. On reaching either limit the model is instructed to submit a final answer and given one additional turn to do so; failing to submit scores zero.
• Grading. The judge is DeepSeek-v4-Flash at temperature 0.1, using a GEPA-optimized grading template that is not released. It grades one criterion at a time, receiving the task prompt, the criterion text, and the model's final output (never the trajectory log), and returns a binary Met / Not Met plus a short explanation.

Splits and release policy

Split	Count	Published?	Used for leaderboard?	Purpose
Benchmark / test	160	No (held out, never released)	Yes	Closed benchmark; leaderboard evals available on request
Dev / validation	10	Yes (this repo, CC BY 4.0)	No	Task-format inspection, agent development, training support

Motivation

Accounting is one of the largest categories of knowledge work, generating approximately $700 billion in revenue globally with close to 1.6 million people employed in the US alone, yet almost no public evaluation measures whether AI agents can actually do it. Existing finance benchmarks test isolated question-answering: a single figure, a single formula, a multiple-choice fact. None of them put an agent inside a company's books and ask it to reconcile, accrue, classify, and analyze the way a controller or staff accountant does every month.

APEX-Accounting closes that gap. Each agent is handed a full set of books (a general ledger loaded into an accounting system, bank and credit-card statements, contracts, payroll exports, and close checklists) and asked to do the month-end work a professional normally does by hand. Because month-end close is labor-intensive, recurring, and economically significant, the benchmark measures capability where the stakes for reliable automation are highest, and where a plausible-but-wrong answer is a liability rather than a rounding error.

Data schema

Each task contains the following elements. Each task is associated with one world:

• Prompt: the instruction posed to the agent, written the way an accountant would receive it on the job. It is concise, with a clear expectation of the final output, does not explain methods a competent accountant would already know, and names files only when they are unintuitive or unexpected. The prompt is the complete task input; the agent receives no file list and must locate its own evidence in the world's file system.
• World: the company environment the task runs against, comprising the accounting-system instance plus the shipped filesystem of supporting documents.
• Input files: the artifacts the task author identified as required to fully solve the task. These are task metadata used for dataset statistics and QA, not given to the agent. Every value needed for the answer is derivable from them, together with the rest of the world.
• Golden response: the expert's own answer, representing an industry-quality output that scores 100% against the rubric.
• Rubric: binary (Pass/Fail), unweighted criteria grading each substantive ask in the prompt.

Data fields

Field	Type	Required	Description	Visible to model?	Visible to judge?
task_id	string	✓	Stable unique identifier	✗	✗
prompt	string	✓	Agent instruction; the complete task input	✓	✓
world_id	string	✓	Environment pointer; mounts the accounting-system instance and shipped filesystem	✓ (as the environment)	✗
context_files	array	✓	Input-file manifest for the task; metadata only, and the agent is not given this list. Each name resolves under world/ or task_files/<task>/	✗	✗
rubric	array	✓	Binary criteria; each carries an id, a criterion_type (Reasoning (numerical) or Reasoning (qualitative)), and a description stating the acceptable value or range	✗	✓ (criterion text)
gold_output	string	✗	The expert's reference answer, scoring 100% against the rubric	✗	✗
metadata	object	✗	Category, subcategory, output type, world entity type, the author's estimate of real-world completion hours, and author/reviewer roles	✗	✗

Dataset design

The sections below describe how APEX-Accounting as a whole was built. Unless stated otherwise, figures refer to the 160-task held-out benchmark rather than the 10 tasks released here; the dev set was authored under the same process and quality controls.

Rubric design

Each rubric criterion must satisfy four requirements: Self-contained, Easy to interpret, Aligned with prompt, and Outcome-based.

• Self-contained: Gradable without reference to other criteria.
• Easy to interpret: One fact or judgment per criterion, so partial credit is not lost to compound requirements.
• Aligned with prompt: Grading only what the prompt asks for.
• Outcome-based: Grading only the final answer, not the process; acceptable ranges handle legitimate rounding differences.

Task categories

The required output for every task is a message sent in the console. Each task is assigned to one of four categories:

• Reconciliation: tie two sources together, identify differences, and explain or correct the breaks.
• Data Entry: post or update transactions, journal entries, vendor bills, and invoices.
• Variance Analysis: compare actuals against budget, prior periods, or expectations and explain the drivers.
• Schedules & Accruals: build or update supporting schedules, calculate accruals, and carry the right balances into the close.

Difficulty and selection

Tasks were selected by filtering from a pool of worlds, with tasks already quality controlled for realism and diversity, based on three frontier models (Claude-Opus-4.8, GPT-5.5, and Gemini-3.1- Pro Preview) achieving low scores when graded. We adopted this design to ensure that only worlds with challenging tasks are selected for the benchmark.

Because the dev world was the easiest of the 11 qualifying worlds, model scores run somewhat higher on it than on the held-out set (see Dev set vs. held-out set).

World design

A world is a self-contained synthetic company at a fixed point in its month-end close: a US-GAAP accrual-basis business with its own entity type, chart of accounts, revenue model, prior-period balances, and the set of source documents an accountant would pull from that company's systems. Worlds are 1 : N with tasks: one company environment backs many independent tasks. Held-out worlds comprise 73.1 files on average.

Worlds were built in four stages: a cross-world scoping pass assigning each world a high-level profile, balanced across the full set; a detailed per-world specification describing every file, every task, and a trap register cataloging each seeded contradiction; iteration on a single reference document until its formatting and style were realistic, then a per-world style guide derived from it; and validation of every file against the spec and style guide so they read as coming from one company. Every document is novel and screened against public sources, so no world can be found online or memorized in advance.

World assets

• Source files: the company's documents as static exports, predominantly .xlsx, .csv, and .pdf, with occasional .docx/.txt. 90 files are shared across all tasks; a further 16 belong to individual tasks (memos, draft workpapers, contract addenda) and ship under task_files/.
• Task metadata: per task, the category, the input-file manifest the task author identified as necessary to fully solve it, and the expert's estimate of real-world completion time.

The public dev world (World 9)

Sterling, Marsh & Associates LLP is a Philadelphia-based boutique law firm completing its December 2024 month-end close under US GAAP accrual accounting. The world focuses on law-firm-specific close workflows around Clio-based billable hours and WIP, hourly, flat-fee, and contingency revenue recognition, IOLTA trust accounting, retainer deposits and earned-fee transfers, client cost advances, realization adjustments, partner guaranteed payments and profit allocations, contract attorney accruals, and matter-level profitability.

Statistic	Value
Tasks	10
Total rubric criteria	89 (mean 8.9 per task, median 5.5)
Unique world files	90
Spreadsheets / PDFs / accounting-system files	34 / 46 / 10
Task-specific files	16, across 8 of the 10 tasks
Mean files per task	5.6 (median 5.5)

Sample dev set vs. held-out set

Because the released world in the dev set is the easiest of the 11 qualifying worlds, scores run higher on it. Mean Criteria@3 on the 10 dev-set tasks, alongside each model's held-out score:

Model	Held-out (n = 160)	Dev set (n = 10)	Difference
Claude-Fable-5 (Max)	56.4%	67.9%	+11.5
Muse-Spark-1.1 (xHigh)	52.6%	52.4%	−0.2
GPT-5.6-Sol (Max + Pro)	51.5%	62.3%	+10.8
Claude-Opus-4.8 (Max)	48.0%	61.8%	+13.8
GLM-5.2 (Max)	42.7%	44.1%	+1.4
Grok-4.5 (High)	40.8%	51.1%	+10.3
Kimi-K2.7-Code (High)	37.0%	38.0%	+1.0
Gemini-3.1-Pro (High)	32.4%	37.0%	+4.6
Qwen3.5-397B-Fp8 (enable_thinking=True)	24.4%	27.6%	+3.2

Dev-set results are not comparable to leaderboard results and should not be reported as APEX-Accounting scores.

Intended use and licensing

This repository (the 10-task dev set) is released under CC BY 4.0, comprising prompts, rubrics, golden responses, task metadata, and the world's source files. It is intended for inspecting the task and rubric format, developing and evaluating agent implementations, and supporting accounting-specific model training and agent development.

The 160-task scored benchmark is closed. Leaderboard evals can be run for any frontier model on request via apex@mercor.com. The harness itself is open source; see Running the Tasks.