Blame for README.md

---
license: apache-2.0
pretty_name: FinanceGym
task_categories:
  - image-text-to-text
tags:
  - benchmark
  - evaluation
  - finance
  - multimodal
  - agent
  - computer-use
  - gui
  - trajectories
configs:
  - config_name: default
    data_files:
      - split: test
        path: data/test-*.parquet
---

# FinanceGym: A Dataset for Financial Multimodal Agents

<p align="center">
  <img src="./assets/financegym-teaser.png" alt="FinanceGym" width="820">
</p>

<p align="center">
  <strong>A dataset for financial multimodal agents.</strong>
</p>

<p align="center">
  <strong>59K+ training samples</strong>
  ·
  <strong>2.4K testing samples</strong>
</p>

<p align="center">
  Public test split only
  ·
  Apache-2.0
  ·
  Source snapshot: August 13, 2026
</p>

<p align="center">
  <a href="https://embodiedanalysis.com/finance-gym">Website</a>
  ·
  <a href="https://huggingface.co/datasets/embodied-analysis/FinanceGym/viewer">Dataset Viewer</a>
</p>

---

FinanceGym is a finance-oriented dataset designed to teach multimodal agents to turn financial instructions into correctly grounded actions in software interfaces. Each public example combines the task and dialogue context, preceding interaction history, step-level screenshots, the available computer-use tool schema, and a human reference action for the next step. This structure supports controlled evaluation of visual grounding, state tracking, tool use, and action selection in realistic financial workflows.

Unlike finance question-answering benchmarks that primarily test what a model knows, FinanceGym tests whether an agent can interpret an interface, follow the state of a multi-step task, and decide what to do next. The public release contains the test set and the training set is available upon request.

## Key Facts

| Item | Value |
| --- | ---: |
| Train split size | 59700 |
| Test split size | 2397 |
| Public data split | Test set open-sourced <br>Training set: contact charles@embodiedanalysis.com |
| Repository size | 1.71 GB |
| License | Apache-2.0 |

## What FinanceGym Trains and Evaluates

- **Visual grounding.** Locating controls, fields, charts, tables, and state changes in screenshots.
- **Context tracking.** Reasoning over multimodal histories containing text, images, tool calls, and tool results.
- **Computer use.** Selecting the appropriate computer-use operation and its arguments.

FinanceGym measures the execution layer of a financial multimodal agent. It is not a benchmark of financial advice quality, regulatory compliance, portfolio performance, or production safety.

## How the Data Is Created

FinanceGym is produced through an end-to-end human-demonstration pipeline designed to preserve the relationship between a financial task, the interface state, and the action taken by an operator.

1. **Task design.** Multi-step tasks are defined around the repetitive execution work found in finance-related roles, including research, data entry, calculation, reconciliation, reporting, and status tracking.
2. **Human demonstration.** Human operators complete the tasks from start to finish in isolated test environments. Task context, dialogue, step-level screenshots, interface actions, and synchronized narration are preserved.
3. **Transcription and structuring.** Operator recordings are transcribed and parsed into aligned multimodal trajectories so that each observation can be associated with its action and surrounding context.
4. **Cleaning and normalization.** Redundant interactions are removed, trajectories are normalized into a consistent action and message structure, and the resulting records are prepared for model use and inspection.
5. **Review and audit.** Screenshot, action, and narration alignment is reviewed at the step level. Manifests and distribution reports support traceability and coverage analysis.
6. **Public benchmark packaging.** The public evaluation examples are released as structured `messages`, referenced `images`, a serialized `tools` schema, and the next-action `ground_truth` target.

The documented collection workflow uses test environments separated from production networks and excludes real identities, bank-card data, login credentials, phone numbers, and email addresses.

## Financial Application Coverage

FinanceGym's task design covers the operational work behind multiple finance-related roles. Representative scenario groups from the project documentation include:

| Scenario group | Representative workflow | Related roles |
| --- | --- | --- |
| Market and investment research | Search for market information, inspect charts and tables, compare instruments, and record findings. | Finance Analyst; Financial Market Researcher; Options Market Researcher; Stock Exchange Researcher |
| Tax operations | Gather supporting records, research tax information, calculate amounts, validate a filing, and prepare submission or archiving. | Tax Information Researcher |
| Personal finance and credit | Compare financial products, research credit-card terms, use calculators, and prepare personal-finance analyses. | Personal Finance Specialist; Personal Finance Researcher; Credit Card Research Analyst |
| Budgeting and revenue | Enter and adjust assumptions, calculate totals, update budget-control sheets, prepare reports, and track revenue status. | Budget Planning & Control Specialist; Revenue Manager; Financial Specialist |
| Bills, AP/AR, and vendor operations | Enter invoice data, review bills, match records, and track vendor invoices and payments. | Bills & Payables Specialist; Invoice (AP/AR) Data Entry Specialist; Vendor Invoice & Payment Tracking Specialist |
| Bank reconciliation and expenses | Compare statements with internal records, classify expenses, check totals, and maintain expense logs. | Bank Statement & Expense Log Specialist |

These scenarios target high-frequency, standardized execution work. They do not imply that professional judgment, compliance review, or accountable human oversight can be removed from financial operations.

## Benchmark Task

For each episode, the model receives:

- system and user messages;
- previous assistant messages and tool-call messages;
- interface screenshots referenced by the conversation; and
- the available `computer_use` tool definition.

The model predicts the next computer-use action or action sequence. The prediction can then be compared with the JSON reference stored in `ground_truth`.

Example reference action:

```json
[
  {
    "action": "left_click",
    "coordinate": [504, 555]
  }
]
```

The public data also contains scrolling and drag interactions. A drag may be represented as an ordered sequence of mouse-down, mouse-move, and mouse-up actions.

## Benchmark Results

<p align="center">
  <img src="./assets/financegym-benchmark-results.png" alt="FinanceGym benchmark results across eight multimodal agents" width="100%">
</p>

### Run the evaluation

Download this dataset repository, install the evaluator dependencies, and set
an OpenRouter API key:

```bash
pip install -U huggingface_hub pyarrow requests
hf download embodied-analysis/FinanceGym --repo-type dataset \
  --local-dir FinanceGym
cd FinanceGym
export OPENROUTER_API_KEY="your-openrouter-api-key"
```

Evaluate a model once on every test example:

```bash
python run_eval.py 'data/test-*.parquet' \
  --models z-ai/glm-5v-turbo
```

The evaluator reconstructs OpenAI-compatible multimodal messages, calls the
native `computer_use` tool through OpenRouter, scores each predicted action
against `ground_truth`, and writes resumable JSONL checkpoints plus
`openrouter_rollouts/summary.json`. The default is one rollout per example;
use `--rollouts N` for repeated samples and `--concurrency N` to control API
parallelism. The key may also be supplied as `OPENROUTER_KEY` or stored in
`~/.env`.

## Dataset Structure

| Field | Type | Description |
| --- | --- | --- |
| `messages` | `list<struct>` | Multimodal interaction history with `role`, `content`, `tool_calls`, and `tool_call_id`. |
| `images` | `Sequence(Image())` | JPEG screenshots referenced by the messages, stored in message order. |
| `tools` | `string` | JSON-serialized OpenAI-compatible `computer_use` tool schema shown to the model. |
| `ground_truth` | `string` | JSON-serialized reference action list for the next step. |

Each `messages[].content` value is a list of typed parts. A text part looks like:

```json
{"type": "text", "text": "..."}
```

An image part stores an index rather than duplicating the image bytes:

```json
{"type": "image", "image_index": 0}
```

`image_index` points to the corresponding screenshot in the row's `images` field.

## Quick Start

Install the dataset client:

```bash
pip install -U datasets pillow
```

Load the public test split:

```python
import json

from datasets import load_dataset

dataset = load_dataset(
    "embodied-analysis/FinanceGym",
    split="test",
)

row = dataset[0]

print(dataset)
print(row.keys())
print(json.loads(row["ground_truth"]))
print(json.loads(row["tools"]))
```

## Coordinate Convention

Reference actions use a nominal **1000 × 1000** coordinate space, while the stored screenshots use their native resolution.

Rescale coordinates before drawing an action on a stored screenshot:

```python
ACTION_WIDTH = 1000
ACTION_HEIGHT = 1000
IMAGE_WIDTH = 1664
IMAGE_HEIGHT = 928


def action_to_image(x_action, y_action):
    x_image = x_action * IMAGE_WIDTH / ACTION_WIDTH
    y_image = y_action * IMAGE_HEIGHT / ACTION_HEIGHT
    return round(x_image), round(y_image)
```

Any published evaluation should state its rounding, clipping, coordinate-tolerance, and invalid-output rules.

## Reconstructing OpenAI-Style Multimodal Messages

Use `Image(decode=False)` to preserve the original JPEG bytes. Decoding a screenshot to PIL and saving it again would re-encode the image.

```python
import base64

from datasets import Image, load_dataset

dataset = load_dataset(
    "embodied-analysis/FinanceGym",
    split="test",
)
dataset = dataset.cast_column("images", [Image(decode=False)])


def to_openai_messages(row):
    output = []

    for message in row["messages"]:
        content = []

        for part in message["content"]:
            if part["type"] == "text":
                content.append({
                    "type": "text",
                    "text": part["text"],
                })
            else:
                image = row["images"][part["image_index"]]
                encoded = base64.b64encode(image["bytes"]).decode("utf-8")
                content.append({
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{encoded}",
                    },
                })

        reconstructed = {
            "role": message["role"],
            "content": content,
        }

        if message["tool_calls"]:
            reconstructed["tool_calls"] = message["tool_calls"]
        if message["tool_call_id"] is not None:
            reconstructed["tool_call_id"] = message["tool_call_id"]

        output.append(reconstructed)

    return output
```

## Recommended Evaluation Practice

FinanceGym provides reference next actions but does not prescribe a single official scoring formula in this dataset card. To make results reproducible, report:

- the model, checkpoint, and inference configuration;
- the prompt and message-conversion procedure;
- JSON parsing and invalid-output handling;
- action-name normalization and matching rules;
- coordinate tolerance for pointer actions;
- multi-action sequence matching rules; and
- the aggregation method used for the final score.

Evaluate only on the public `test` split and do not use its screenshots, messages, or reference actions as model-training data.

## License

This repository is released under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0).

## Citation

If you use FinanceGym in research or evaluation, please cite the dataset. Use the following provisional BibTeX entry:

```bibtex
@misc{financegym2026,
  title        = {FinanceGym: A Benchmark for Financial GUI Agents},
  author       = {{Embodied Analysis}},
  year         = {2026},
  howpublished = {Hugging Face Datasets},
  url          = {https://huggingface.co/datasets/embodied-analysis/FinanceGym}
}
```

## Contact

To contact the team, reachout to [charles@embodiedanalysis.com](charles@embodiedanalysis.com). To report a data issue, share an evaluation result, or ask about collaboration, open a thread in the [FinanceGym Community](https://huggingface.co/datasets/embodied-analysis/FinanceGym/discussions).