AIAny

Codex: Evaluating Large Language Models Trained on Code

Showed that fine-tuning a GPT model on public GitHub code yields a capable program synthesizer, and introduced HumanEval — the docstring-to-function benchmark that still anchors code-generation evaluation. A production variant powers GitHub Copilot.

Introduction

The headline isn't that a language model can write code — it's how the paper measures it. By releasing HumanEval, a set of hand-written programming problems graded by actually running unit tests rather than matching text, this work reset how the field judges code models, and that benchmark outlived the model itself.

Key Findings
  • Functional correctness, not text overlap. On HumanEval, Codex solves 28.8% of problems pass@1 while GPT-3 solves 0% — a gap that exists only because pre-training on natural language alone doesn't teach executable code.
  • Sampling is a lever. Drawing 100 samples per problem and ranking them lifts the solve rate to 70.2%. Repeated sampling turns a mediocre single-shot model into a strong one, a pattern that recurs across later reasoning work.
  • Honest about failure modes. The paper documents misaligned outputs, sample inefficiency, and the safety and economic implications of code generation — unusually candid for a capabilities release.
Why It Matters

Codex is the bridge between research LLMs and a product millions use: a distinct production version powers GitHub Copilot. It also made "evaluate by execution" the default for code, shaping successors like MBPP, MultiPL-E, and SWE-bench.

Who Should Read It

Great fit if you build or evaluate coding assistants and want the origin of pass@k and execution-based grading. Look elsewhere if you want a current model — Codex is deprecated and modern code models are far stronger — but the evaluation methodology here is still load-bearing.

Information

  • Websitearxiv.org
  • OrganizationsOpenAI
  • AuthorsMark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan
  • Published date2021/07/07

More Items

A zero-data self-evolution framework that co-trains a Challenger, Solver, and Judge so LLMs can iteratively improve on both verifiable and unverifiable tasks without human labels. Uses role-asymmetry and subtask-amplification preference pairs to train the Judge and sustain improvement.

Trains compact conversational agents to adapt at runtime to changing 'Harness' configurations (Skills, Hooks, prompts, tools) using Harness-Aware Training (HAT): Harness-State Augmentation, on-policy distillation, and RL to preserve generality while meeting low-latency deployment constraints.

Analyzes how to generate useful interaction data for LLM agents and proposes the ACE lens — Accuracy, Complexity, divErsity — while factorizing agentic data as (E, q, τ, v). Surveys verification, difficulty calibration, and coverage strategies and outlines implications for training and benchmarks.