Scientific papers are full of equations, parameters, initial conditions and results—but they are still usually experienced as static pages. PaperAlive is a Codex-native scientific compiler that turns supported papers into interactive, evidence-linked experiments.
It does not invent missing science and it does not force every paper into a flashy 3D scene. It extracts the evidence, checks whether the paper is computationally representable, builds a typed experiment model, runs deterministic scientific gates, reproduces supported results and opens a local interactive viewer.
A conventional visualization can make a paper easier to look at. PaperAlive is designed to make it easier to understand, test and question:
- change a reported parameter and immediately see its effect;
- compare a variation against the paper baseline;
- follow every quantitative control back to a source location;
- inspect equations, units, assumptions and validation evidence;
- export the experiment as a static offline package;
- receive an explicit refusal when the source cannot support an honest model.
The result is useful for students, educators, reviewers, researchers and curious readers who want to move from reading a claim to interacting with the model behind it.
- Codex with plugin support
- Python 3.12 or newer
- internet access once to install the pinned Python packages
- no API key, backend, account or Node.js build step
codex plugin marketplace add victus17/paperalive-codex-plugincodex plugin add paperalive@paperaliveAttach a text-based scientific PDF and write:
$paperalive Compile this paper into a validated interactive experiment.
PaperAlive returns the exact compatibility and trust status, the evidence-linked PAER, validation reports, reference results, a static site, an offline package and—after a successful compilation—a verified local URL such as http://127.0.0.1:43127/.
This repository includes a real open-access paper and a reviewed PAER example:
Clone the repository, attach the PDF from examples/repressilator/ to a new Codex task and use the prompt above. The paper contains a three-protein repressilator model with an oscillating limit cycle—an ideal example of how a static biological system can become an explorable experiment.
The source is Wu, McDermott & MacLean (2025), Data-driven model discovery and model selection for noisy biological systems, PLOS Computational Biology, DOI 10.1371/journal.pcbi.1012762, distributed under CC BY 4.0. Full attribution and the verified source hash are in examples/repressilator/ATTRIBUTION.md.
flowchart LR
A["Paper + supplements"] --> B["Evidence extraction"]
B --> C["Compatibility hard gates"]
C -->|supported| D["Typed PAER"]
C -->|insufficient evidence| X["Evidence report + refusal"]
D --> E["Symbols · units · provenance"]
E --> F["Reference simulation"]
F --> G["Reproduction checks"]
G --> H["Allowlisted renderer"]
H --> I["Offline experiment studio"]
Codex performs the evidence-aware interpretation inside the authenticated task. The bundled compiler scripts then handle extraction, validation, units, numerical reference execution, rendering, packaging and local serving with deterministic local code.
PaperAlive was designed and implemented during OpenAI Build Week as a Codex-native developer tool. GPT-5.6 in Codex was an active engineering and scientific-reasoning collaborator throughout the primary build task—not a decorative mention added to the submission. Codex carried the project from the product specification through architecture, plugin implementation, scientific guardrails, the offline experiment studio, real-paper evaluation, packaging, documentation and release verification.
| Workstream | How Codex and GPT-5.6 were used | Evidence in this release |
|---|---|---|
| Product architecture | Converted the product brief into an explicit compiler pipeline: bounded evidence extraction, compatibility gates, a typed intermediate representation, deterministic validation, independent reference execution and allowlisted rendering. | PaperAlive skill, scientific method |
| Scientific reasoning | Traced equations, symbols, parameter tables, units, initial conditions, source locations, solver settings and reproduction targets without treating a plausible guess as evidence. | PAER authoring rules, support matrix |
| Safety and failure behavior | Translated scientific-honesty requirements into hard gates: no inferred critical quantities, no author-code execution, no arbitrary executable expressions, no unsupported renderer generation and no silent downgrade of trust. | failure policy, deterministic compiler scripts |
| Plugin engineering | Implemented and iterated on the portable Codex skill, extraction and validation CLIs, unit checking, independent reference simulation, static viewer build, package creation and loopback-only preview server. | installable plugin, manifest |
| Product and interaction design | Refined the experiment studio around synchronized equation, parameter, plot, spatial and source-evidence navigation; baseline comparison; time control; explicit trust; limitations; and offline exports. | bundled static viewer under plugin assets |
| Evaluation and release | Used a real open-access Repressilator paper to exercise the complete path, audited the output, prepared the focused no-build release and documented a judge-friendly installation and test route. | sample paper and PAER, this README |
- Build a scientific compiler, not a free-form visualization generator. PaperAlive introduces PAER as a typed boundary between semantic paper understanding and execution, so a visually convincing scene can never substitute for a complete model.
- Make honest refusal a first-class product result. Missing central equations, parameters, units, initial/boundary conditions, provenance or an allowlisted adapter produces a precise evidence report instead of an invented simulation.
- Use one canonical schema. The bundled JSON Schema is the source of truth for the experiment contract; every later stage consumes the same typed structure.
- Separate model reasoning from numerical trust. GPT-5.6 interprets bounded evidence and authors the typed candidate. Local validators and independent numerical solvers—not the language model—derive structural, dimensional, reproduction and trust outcomes.
- Close every executable surface. Equation nodes, solvers, adapters and renderers come from fixed allowlists. The plugin never executes notebook cells, author code, model-generated functions,
eval, arbitrary HTML or arbitrary shaders. - Keep the delivered experiment local and portable. Once the plugin and pinned Python dependencies are installed, compilation, validation, simulation, rendering, packaging and viewing require no OpenAI API key, hosted model endpoint, backend, CDN, analytics service or font host.
- Treat provenance as interface state. Evidence is not a footnote: quantitative controls and outputs must resolve to source anchors, and the viewer exposes that path to the user.
When a user invokes $paperalive in an authenticated Codex task, GPT-5.6 performs the semantic stage that a fixed parser cannot reliably complete:
- read the bounded, hashed extraction produced by the local tool;
- resolve notation and map prose, equations and tables into an explicit symbol table;
- distinguish directly reported, transparently derived and missing quantities;
- produce the Compatibility Report and select only a supported adapter;
- author a PAER candidate with evidence anchors and status links for every quantitative element;
- repair a candidate only where the evidence determines a unique correction;
- explain ambiguity and stop when a critical scientific gap remains.
The output of that reasoning is not trusted merely because the model produced it. Deterministic local code then owns the pass/fail path:
flowchart LR
A["GPT-5.6 in Codex: bounded evidence interpretation"] --> B["Typed PAER candidate"]
B --> C["Local schema, symbol, unit and provenance gates"]
C --> D["Independent reference simulation"]
D --> E["Declared reproduction and invariant checks"]
E --> F["Allowlisted offline renderer and package"]
GPT-5.6 does not assign trust by assertion, silently fill missing science, execute the authors' code, create arbitrary renderer geometry, calculate the reference result, or run inside the exported viewer. This division of labor is the core of the product: GPT-5.6 contributes high-value semantic interpretation, while every decision that can be made deterministically remains reproducible and auditable.
The primary Codex task was used for the majority of core development and its /feedback Session ID is supplied to judges in the private Devpost field. A representative end-user task is:
$paperalive Compile this paper into a validated interactive experiment.
For the included Repressilator source, Codex reads the paper evidence and orchestrates the plugin. The local tools create the extracted evidence, Compatibility Report, canonical .paperalive.json, validation and unit reports, independent numerical reference, static site and portable offline ZIP. The included reviewed PAER and paper let judges inspect this route without inventing sample data or rebuilding a frontend.
The public repository is intentionally the focused, installable release. It contains the complete runtime plugin, pinned dependency list, prebuilt offline viewer, canonical schema, example source/PAER and licensing material; development caches and the larger internal test monorepo are excluded from the judge download.
The compiler currently supports three deliberately narrow adapters:
| Adapter | Intended use | Interactive representation |
|---|---|---|
ode-system-v1 |
Coupled deterministic ODEs | Time series and mathematically labelled phase space |
particle-system-v1 |
Deterministic particle dynamics | Physical trajectories and state inspection |
scalar-field-v1 |
Quantitative fields on a fixed grid | Heatmap, contours and surface views |
PaperAlive uses explicit compatibility outcomes:
SUPPORTED_AUTOMATICSUPPORTED_WITH_REVIEWILLUSTRATIVE_ONLYUNSUPPORTED
Its trust hierarchy is equally explicit:
| Trust | Meaning |
|---|---|
| A | Computationally Reproduced |
| B | Independently Reimplemented |
| C | Verified Interactive Model |
| D | Illustrative Interpretation |
| X | Unsupported |
Missing central equations, parameters, units, initial conditions or provenance are hard gates. PaperAlive never silently fills them with plausible values. Quantitative controls and outputs must have source evidence or be clearly marked as derived exploration.
For a supported paper, a successful run produces:
work/
├── extracted/ # hashed evidence and source locations
├── experiment.paperalive.json # canonical typed experiment model
├── validation.json # structural and semantic gates
├── units.json # dimensional validation
├── reference/ # independent numerical results
├── site/ # static offline experiment studio
└── experiment.paperalive.zip # portable package
The viewer provides interactive controls, baseline comparison, synchronized plots and spatial views where scientifically meaningful, evidence drawers, limitations, validation status and downloadable audit artifacts.
The installed plugin and generated experiment require:
- no OpenAI API key;
- no hosted model call at runtime;
- no backend or database;
- no CDN or remote font host;
- no author-code execution;
- no
evalor generated executable expressions.
The viewer is prebuilt and bundled with the plugin. Numerical simulation runs independently of the camera, render interpolation and frame rate. The generated preview server binds only to 127.0.0.1, chooses a free port, verifies the response and prints the exact stop command.
.agents/plugins/marketplace.json # Codex marketplace entry
plugins/paperalive/
├── .codex-plugin/plugin.json # plugin manifest
├── skills/paperalive/ # workflow, method and compiler scripts
└── assets/ # canonical schema + offline viewer
examples/repressilator/ # real CC BY paper + reviewed PAER
docs/ # public project visuals
This is the focused, installable release repository. It intentionally excludes the full development monorepo, build caches and internal test fixtures.
PaperAlive v1 is for sufficiently complete, text-based quantitative papers. It does not execute notebook cells or author code, infer missing coordinates, provide clinical advice, or pretend that arbitrary CFD, FEM, chemistry or black-box machine-learning papers are supported.
Scientific implementation verification is not the same as real-world validation. PaperAlive only claims observation-level validation when appropriate measurement evidence is present in the source.
PaperAlive code is released under the MIT License. Third-party packages retain their upstream licenses. The included PLOS paper is distributed under CC BY 4.0 with attribution; see Third-party notices.
PaperAlive makes scientific models explorable without making them less accountable.