Continual-Learning-Exam/CLE-Lite

CLE Lite

Evaluating how agents acquire, retain, and reuse experience across professional workflows.

CLE Team
20 Professional Tasks · 5 Connected Levels per Task · 100 Assignments

CLE Lite is a 20-task release of Continual Learning Exam (CLE). Each task follows a professional workflow across five assignments, called levels (t1 through t5). Later levels build on earlier work, add new evidence, and test whether an agent can use what it has learned.

This is the public home of CLE Lite. Browse 100 task cards in the Dataset Viewer above: each card includes the assignment, expected inputs and outputs, and an input-file inventory. Agent-facing files are available in CLE Lite Workspaces. Complete packages, including the runtime and grading material, are available in CLE Lite Full after access approval.

News · Start here · About CLE · Quick start · Tasks · Evaluation · Results · Citation

📰 News

• 2026-10-25 · Paper released. The CLE paper is now available on arXiv and Hugging Face Papers.
• 2026-10-22 · Two evaluation modes. Run all five levels with Direct, or use CLE to advance only after passing each level. CLE supports both Trial 1 and Trial 2. See the Quick start for commands.
• 2026-10-20 · CLE Lite released. Explore 20 professional tasks and 100 connected levels, with public task cards and task inputs.

🧭 Start here

I want to…	Start with	Access
Read the 100 assignments	Task Cards	Public
Inspect the files supplied to agents	Task Inputs	Public
Download a task package	CLE Lite Full	Approval required
Run an agent and score its work	Quick start and evaluation guide	Archive access, Linux, Docker, and model access

📖 About CLE

Continual Learning Exam (CLE) measures whether agents can learn from experience and use it in later work. Built by 50+ domain experts, the benchmark contains 120 human-authored tasks, spanning 89 professional roles across 12 domains.

Explore the interactive breakdown →

Each task is a ladder of five connected assignments, giving 600 levels in total. Passing a level unlocks the next; files, environment state, and accumulated experience carry forward. Human-authored rubrics determine whether each submission passes.

Explore this example → · Benchmark design

The overview figures describe the full CLE benchmark. This repository contains CLE Lite: 20 tasks and 100 levels.

🚀 Quick start

CLE Lite supports two evaluation modes: Direct and CLE. Both use the same tasks and grading rubrics. The difference is when submissions are graded and whether the agent must pass a level before continuing.

• Direct — attempt all five levels, then grade. The agent works through all five levels without receiving grading feedback during execution. The runtime saves each level's submission and grades those saved versions afterward. Tasks are evaluated independently. Choose this mode to examine performance across every level.
• CLE — pass each level before continuing. Each submission is graded immediately. The agent advances only after passing every rubric check for the current level. If it fails after using its allowed submissions, the task ends and unreached levels count as failed. Choose this mode to follow CLE's level-by-level evaluation protocol.

CLE mode provides two submission settings:

Setting	Submissions and feedback
Trial 1	One submission per level, with no diagnostic feedback.
Trial 2	After a failed first submission, the agent receives feedback identifying unmet rubric categories and may revise and resubmit once. Both submissions share the level's execution time budget.

Start with run to evaluate a single task. Use stream --setting cle to evaluate an ordered sequence of tasks while retaining the agent's conversation and configured memory between tasks. Steps 1–3 cover a single task; step 4 shows the optional task stream.

Before you start

The solver is the agent that performs the task. The judge evaluates its submissions against the grading rubrics. The packaged runtime currently runs the solver through Codex; the examples use GPT-6.1-Sol. You select the judge separately in step 2.

You will need:

• Environment: Linux x86-64, Bash, Docker with Compose, curl, Python 3.10+, uv, and Node.js 22+.
• Access: approved access to CLE Lite Full and a Codex login with access to the solver model. The OpenRouter judge option also requires an OpenRouter API key.
• Resources: at least 30 GB of disk space for a single example task, with additional space for task streams. Evaluations using the full execution budget can take hours. Both the solver and the model-based judge consume inference usage.

Run the commands in Bash, in the same shell and working directory, so the paths and variables defined during setup remain available.

1. Download and prepare a task

uv tool install huggingface_hub
hf auth login
hf download Continual-Learning-Exam/CLE-Lite-Full \
    --repo-type dataset --revision 26ab77e5085476d59dc8c243b928e5b8ac490ef4 \
    --include 'runtime/*' --local-dir .

TASK=008-operations-research-analyst
DATA_REVISION=803301ec01b26ab594a5ab3cdcd855a14dcc26e1
BUNDLE="./CLE-Lite/$TASK/harbor"
RUNTIME_ENV="./.cle-runtime-$TASK"

uv run --no-project --with huggingface_hub python runtime/cle_lite.py download \
    --task "$TASK" --directory ./CLE-Lite --revision "$DATA_REVISION"
python3 runtime/cle_lite.py setup --bundle "$BUNDLE" --env "$RUNTIME_ENV"

npm install --global --prefix ./.cle-tools @openai/codex@0.160.0
export PATH="$(pwd)/.cle-tools/bin:$PATH"
codex login --device-auth

docker build -t cle-lite-codex-worker:0.160.0-cle2 \
    -f runtime/codex-worker.Dockerfile runtime
export CLE_CODEX_DOCKER_IMAGE=cle-lite-codex-worker:0.160.0-cle2
export CLE_CODEX_AUTH_FILE="$HOME/.codex/auth.json"
export CLE_CODEX_TRANSPORT=https

The first download retrieves the runtime scripts; the download command then retrieves the selected task, verifies its recorded file hashes, and restores required permissions and timestamps. setup installs the task's recorded Python and package versions with Harbor 0.22.0. The runtime and task data are pinned to separate revisions; record both when reporting results.

If already logged in to Codex, skip codex login and point CLE_CODEX_AUTH_FILE at the existing login file.

2. Configure the judge

Choose one judge configuration. This choice is independent of Direct or CLE mode.

DeepSeek V4 Flash via OpenRouter

Use an OpenRouter API key to access DeepSeek V4 Flash:

read -r -s -p 'OpenRouter API key: ' OPENROUTER_API_KEY
export OPENROUTER_API_KEY
JUDGE_BACKEND=openrouter
JUDGE_MODEL=deepseek/deepseek-v4-flash

GPT-6.1-Sol via Codex

This option uses the Codex login configured in step 1:

JUDGE_BACKEND=codex
JUDGE_MODEL=gpt-6.1-sol
export CLE_CODEX_REASONING_EFFORT=low

The low effort setting applies to both the solver and the Codex judge. To use the runtime defaults instead, run unset CLE_CODEX_REASONING_EFFORT before evaluation.

3. Run one task

Choose one command below. Each command starts a separate evaluation of task 008. Use a new --results directory every time you run an evaluation.

Direct

python3 runtime/cle_lite.py run \
    --setting direct --bundle "$BUNDLE" --env "$RUNTIME_ENV" \
    --agent codex --model openai/gpt-6.1-sol \
    --judge-backend "$JUDGE_BACKEND" --judge-model "$JUDGE_MODEL" \
    --codex-auth "$CLE_CODEX_AUTH_FILE" --results ./results/direct-008-01

CLE · Trial 1

python3 runtime/cle_lite.py run \
    --setting cle --trial 1 --bundle "$BUNDLE" --env "$RUNTIME_ENV" \
    --agent codex --model openai/gpt-6.1-sol \
    --judge-backend "$JUDGE_BACKEND" --judge-model "$JUDGE_MODEL" \
    --codex-auth "$CLE_CODEX_AUTH_FILE" --results ./results/cle-trial1-008-01

CLE · Trial 2

python3 runtime/cle_lite.py run \
    --setting cle --trial 2 --bundle "$BUNDLE" --env "$RUNTIME_ENV" \
    --agent codex --model openai/gpt-6.1-sol \
    --judge-backend "$JUDGE_BACKEND" --judge-model "$JUDGE_MODEL" \
    --codex-auth "$CLE_CODEX_AUTH_FILE" --results ./results/cle-trial2-008-01

Inspect these files in the selected results directory:

File	Contents
run.json	Submissions, grading decisions, feedback delivered to the solver, and execution events.
summary.json	Completion and cumulative level pass rates. Rates are fractions from 0 to 1; multiply by 100 for percentages.

The examples use each task's packaged execution budget. Set --agent-timeout-sec SECONDS to change the per-level budget; the value is saved in the results.

4. Optional: evaluate an ordered task sequence

Use a CLE task stream to evaluate how the agent carries experience from one task to the next. The example task list runs 008 → 019. The agent retains its conversation and configured memory, while each task starts with its own files and application services.

🔁 Show task preparation and stream commands

After completing steps 1 and 2, prepare both tasks listed in runtime/lite-example-tasks.json:

for TASK in 008-operations-research-analyst 019-computer-research-scientist; do
    uv run --no-project --with huggingface_hub python runtime/cle_lite.py download \
        --task "$TASK" --directory ./CLE-Lite --revision "$DATA_REVISION"
    python3 runtime/cle_lite.py setup \
        --bundle "./CLE-Lite/$TASK/harbor" --env "./.cle-runtime-$TASK"
done

Choose one Trial. Each Trial starts a separate stream with its own initial agent state and results directory.

CLE stream · Trial 1

python3 runtime/cle_lite.py stream \
    --setting cle --trial 1 --task-list runtime/lite-example-tasks.json \
    --agent codex --model openai/gpt-6.1-sol \
    --judge-backend "$JUDGE_BACKEND" --judge-model "$JUDGE_MODEL" \
    --codex-auth "$CLE_CODEX_AUTH_FILE" --results ./results/cle-stream-trial1-01

CLE stream · Trial 2

python3 runtime/cle_lite.py stream \
    --setting cle --trial 2 --task-list runtime/lite-example-tasks.json \
    --agent codex --model openai/gpt-6.1-sol \
    --judge-backend "$JUDGE_BACKEND" --judge-model "$JUDGE_MODEL" \
    --codex-auth "$CLE_CODEX_AUTH_FILE" --results ./results/cle-stream-trial2-01

Tasks run in the order specified by the task-list file. Its paths are relative to that file. See the evaluation guide for custom task lists and the state retained between tasks.

🗂️ Tasks

For a guided introduction to the broader benchmark, the interactive task browser presents selected public examples with file previews. Use this dataset's Task Cards to browse all 100 CLE Lite assignments.

Related datasets

Dataset	Contents	Access
CLE-Lite — this repository	100 level records with instructions, expected inputs and outputs, software, and file inventories	Public
CLE-Lite-Workspaces	Files supplied to agents, level instructions, source notices, and provenance	Public
CLE-Lite-Rubrics	Evaluation rubrics and reference answers	Approval required
CLE-Lite-Full	Complete task packages, container environments, runtime, evaluation material, and reference solutions	Approval required

Package layout

In CLE Lite Full, task directories are named <number>-<occupation>. Each contains one Harbor package, harbor/, with the container environment, the five task steps, verifier hooks and reference material, beside NOTICE.md and PROVENANCE.md for the third-party files it contains. The Quick start downloads and runs this package.

📦 View the equity research task's directory structure

001-equity-research-analyst/
├── NOTICE.md                  # Third-party sources and terms
├── PROVENANCE.md              # Source, version, retrieval time, hash and licence of every workspace file
└── harbor/
    ├── task/
    │   ├── task.toml          # Harbor configuration, resources and five linked steps
    │   ├── instruction.md     # Initial assignment
    │   ├── steps/             # Per-level instructions: t1/ through t5/
    │   ├── environment/       # Dockerfile, Compose configuration and workspace assets
    │   ├── tests/             # Verifier entry point and separate verifier environment
    │   └── solution/          # Reference-solution entry point
    ├── private/               # Judge-side checks, reference material and task metadata
    ├── build.json             # Build record
    └── freeze.json            # Frozen-file hashes

✅ Evaluation

The CLE main experiment evaluates 120 tasks in a fixed serial order, retaining the agent's harness state across tasks. Each level is graded when submitted and passes only when every rubric item is satisfied. Passing unlocks the next level. A failure after the submission budget is exhausted ends that task; unreached levels count as failed.

• Trial 1: one submission per level, without diagnostic feedback.
• Trial 2: a failed first submission receives feedback identifying unmet rubric categories, followed by one opportunity to revise and resubmit.

The full CLE results below use these metrics:

Metric	Definition
Completion	Levels cleared divided by all 600 levels, expressed as a percentage.
L1–L5	For each level k, the percentage of the 120 tasks whose first k levels are all cleared. L5 is full-task completion.
Gain	Trial 2 completion minus Trial 1 completion, in percentage points.

CLE Lite scoring and execution rules

The Quick start explains how to select Direct or CLE mode. Both use the released tasks and their original grading checks.

• Progression: in CLE mode, the task ends when the agent exhausts its allowed submissions without passing, or runs out of execution time. Unreached levels count as failed.
• Time budget: each level uses the execution budget recorded in its task package. Trial 2 submissions share that budget. Grading time is excluded.
• Feedback: Trial 2 identifies unmet rubric categories, the section titles of the level's rubric (for example Fiscal quarters and trailing year); see feedback categories for how this maps to the task checklist. Private rubrics, reference answers, and judge logs stay outside the solver workspace.
• Errors: runs interrupted by infrastructure or judge errors are marked invalid.

For a CLE Lite evaluation, completion = cleared levels / (5 × number of selected tasks). For example, clearing seven levels across two tasks gives 7/10, or 70% completion. L1–L5 use the same cumulative definition as the table above, with the selected tasks as the denominator. Values in summary.json are fractions from 0 to 1.

Direct mode also reports the fraction of rubric checks passed and the number of consecutive levels passed starting at t1.

📊 Full CLE results

These results cover the full CLE benchmark: 120 tasks and 600 levels. They are reproduced from the project README.

The full CLE evaluation compares 17 configurations spanning 11 model variants and 4 harnesses: Claude Code, Codex, Hermes-Agent, and OpenClaw. Each row identifies the model and its harness; results reflect the complete configuration.

Trial 1 allows one submission per level. Trial 2 adds diagnostic feedback after a failed submission and one opportunity to revise.

Completion Rate · Gain

Completion Rate

Ranked by Trial 2 completion across all 600 levels.

Rank	Model	Harness	Completion Rate
🥇	Claude Opus 5	Claude Code	47.67%
🥈	Claude Sonnet 5	Claude Code	40.17%
🥉	Gemini 3.7 Flash	Hermes-Agent	33.67%
4	GPT-5.6-Sol	Codex	33.17%
5	GPT-5.6-Terra	Codex	33.17%
6	Doubao-Seed-Evolving	Hermes-Agent	30.00%
7	DeepSeek V4 Pro	Hermes-Agent	27.33%
8	Hy3	Hermes-Agent	27.33%
9	Qwen3.8-Max	Hermes-Agent	26.67%
10	GPT-5.6-Luna	Codex	25.33%
11	Gemini 3.7 Flash	OpenClaw	24.00%
12	GLM 5.3	Hermes-Agent	24.00%
13	Doubao-Seed-Evolving	OpenClaw	21.17%
14	Qwen3.8-Max	OpenClaw	19.83%
15	Hy3	OpenClaw	14.00%
16	GLM 5.3	OpenClaw	11.50%
17	DeepSeek V4 Pro	OpenClaw	10.00%

Gain

Ranked by Trial 2 − Trial 1, in percentage points. Ties are ordered by Trial 2 completion, then model name.

📈 Show Trial 1, Trial 2, and gains for all 17 configurations

Rank	Model	Harness	Gain (pp)	Trial 1	Trial 2
🥇	Claude Sonnet 5	Claude Code	+13.17	27.00%	40.17%
🥈	Doubao-Seed-Evolving	Hermes-Agent	+9.67	20.33%	30.00%
🥉	Gemini 3.7 Flash	Hermes-Agent	+8.33	25.33%	33.67%
4	Hy3	Hermes-Agent	+7.00	20.33%	27.33%
5	Doubao-Seed-Evolving	OpenClaw	+6.67	14.50%	21.17%
6	Claude Opus 5	Claude Code	+5.50	42.17%	47.67%
7	DeepSeek V4 Pro	Hermes-Agent	+5.50	21.83%	27.33%
8	GPT-5.6-Sol	Codex	+5.33	27.83%	33.17%
9	GPT-5.6-Terra	Codex	+5.33	27.83%	33.17%
10	Gemini 3.7 Flash	OpenClaw	+5.33	18.67%	24.00%
11	GLM 5.3	OpenClaw	+5.33	6.17%	11.50%
12	GPT-5.6-Luna	Codex	+5.00	20.33%	25.33%
13	Hy3	OpenClaw	+4.17	9.83%	14.00%
14	Qwen3.8-Max	OpenClaw	+1.67	18.17%	19.83%
15	GLM 5.3	Hermes-Agent	+1.50	22.50%	24.00%
16	Qwen3.8-Max	Hermes-Agent	+1.00	25.67%	26.67%
17	DeepSeek V4 Pro	OpenClaw	−1.33	11.33%	10.00%

Explore the interactive leaderboard → · Download results (CSV)

📄 Data sources and terms

Task inputs draw on public source data and documents. The people, organisations, and correspondence used to frame the scenarios are fictional. Third-party materials retain their original terms; consult each package's NOTICE.md and PROVENANCE.md for sources, permissions, and retrieval details.

To preserve the benchmark for evaluation:

• Do not include the tasks or reference material in training corpora.
• Do not expose evaluation rubrics or reference answers to an agent being evaluated.
• Do not publicly redistribute the rubrics or reference answers.

🤝 Questions and contributions

Use GitHub Issues for setup questions, documentation improvements, and reproducibility reports. Include the task directory, level, dataset revision, and relevant error message so the maintainers can reproduce the issue. Keep evaluation answers and private reference material out of public reports.

The project repository tracks release milestones. The CLE Team page lists contributors.

📝 Citation

If you use CLE Lite, please cite the CLE paper:

@misc{zhao2026continuallearningexambenchmarking,
  title = {Continual Learning Exam: Benchmarking Long-Horizon RSI and Experiential Learning in LLM Agents},
  author = {Haoyu Zhao and Sitian Tu and Yuxuan Huang and Huichi Zhou
            and Zhangyue Yin and Jiahao Huang and Jingyuan Xu and Tianmiao Shi
            and Jin Shi and Nianxi Zhang and Yangmiao Zhang and Zhuolang Chan
            and Huiyan Hu and Chenchao Sheng and Yaqing Luo and Yue Chen
            and Huaxiu Yao and Meng Fang and Jun Wang},
  year = {2026},
  eprint = {2610.33956},
  archivePrefix = {arXiv},
  primaryClass = {cs.LG},
  url = {https://arxiv.org/abs/2610.33956}
}

Download BibTeX · View on arXiv

Please also identify CLE Lite, the dataset revision, model, and evaluation harness used in your experiments.