Ask a coding agent to plot your training curves and you'll usually get something technically correct and visually wrong — default matplotlib colors, a legend covering the interesting part of the curve, three decimal places on an axis that needed one. alphaXiv, the research-paper platform behind alphaXiv.org, shipped a fix on September 1, 2026: an agent skill called orx-figures, distributed through its OpenResearch CLI, that teaches coding agents how to build figures researchers would actually put in a paper.
The framing from alphaXiv's own announcement is blunt: "Agents suck at making figures. They make things look ugly and emphasize the wrong things." The fix isn't a new model — it's a SKILL.md-format agent skill, the same portable instruction-package pattern already used across Claude Code, Cursor, and other coding harnesses, aimed squarely at one craft problem: figure quality in research output.
TL;DR
| Question | Answer |
|---|---|
| What is it? | orx-figures, an agent skill shipped inside alphaXiv's OpenResearch CLI |
| What problem does it solve? | Coding agents making ugly figures that emphasize the wrong thing |
| Format | Standard SKILL.md package with six references/*.md templates + an assets/ folder |
| Does the agent still write the code? | Yes — the skill guides which template to follow, the agent generates all plotting code itself |
| Can it decide what to emphasize? | alphaXiv says yes — it infers emphasis from the paper/project's own contents |
| Graph types covered | Learning curves, scaling laws, benchmark/ablation comparisons, Pareto trade-offs, heatmaps/confusion matrices, method diagrams |
| Cost | Free to try at openresearch.sh; skill source is open on GitHub |
| Lighter alternative | SciencePlots — a matplotlib style package, no agent or skill needed |
What's actually in the skill
We pulled the SKILL.md and its reference files directly from the openresearch-cli repository rather than taking the announcement at face value. The skill is organized around six figure categories, each with its own reference template under a references/ subdirectory:
| Template file | Figure type |
|---|---|
curves.md | Learning curves — metrics over training, with uncertainty bands |
scaling.md | Scaling-law trends across a scale dimension (params, compute, data) |
comparison.md | Benchmark and ablation comparisons across conditions |
pareto.md | Trade-off plots — quality vs. cost, reward vs. KL, and similar |
matrix.md | Heatmaps and confusion matrices |
diagram.md | Method and architecture/pipeline diagrams |
Each template carries a worked code example for that figure type, plus a shared set of non-negotiable rules the skill enforces regardless of which template gets used: build at final print size rather than resizing after the fact, export to vector formats instead of rasterizing, source every number from actual experiment logs (not placeholder or demo data left in the script), caption the figure instead of titling it, show uncertainty with the seed count stated, label every axis with units, use a colorblind-safe palette, and keep typography consistent (sans-serif) across every figure in the paper.
That list reads like a condensed version of the same restrained-emphasis principle behind good dataviz generally: a figure earns its ink by making one claim clearly, not by decorating a plot with everything the dataset contains.
Is the agent still writing the code, or just filling in a template?
This was the sharpest open question in alphaXiv's own reply thread, and the answer is a genuine hybrid rather than either extreme. Asked directly whether the skill "steers the agent toward known-good layouts and templates, or is it still generating the plot code from scratch with style rules on top," alphaXiv answered:
"It's a bit of a hybrid approach. The skill exposes different files for different graph types and each one has an example template, but the agent is still writing all of the code for graph generation."
Practically: the skill doesn't hand the agent a function to call. It directs the agent to the one relevant template for the claim the figure needs to make — the skill instructs the agent to pick a template by what the figure must argue, not by shape, and to avoid template-shopping across categories — then the agent writes the matplotlib (or equivalent) code itself, guided by that example and the eight non-negotiable rules above.
Can it decide what to emphasize, or does the researcher have to say?
The second open question cuts to the actual differentiator over a plain styling library. Asked "does the skill infer what to highlight from the paper's context, or does the researcher have to specify it," alphaXiv's answer was direct:
"The skill can infer based on the project/paper's contents what to emphasize!"
That's the part a static style sheet fundamentally cannot do. A matplotlib theme can make every plot in your repo look consistent — same fonts, same colors, same grid — but it has no opinion on whether this figure's job is to show that your method dominates on cost or that variance collapses at scale. Inferring emphasis requires reading the surrounding paper or project context, which is exactly the kind of judgment call an agent skill can carry and a hardcoded style file cannot.
The honest alternative: SciencePlots
One reply to alphaXiv's thread pointed at garrettj403/SciencePlots, a well-known matplotlib style package that "doesn't even need a skill, automatically generates class[ic] style." That's a fair comparison, not a dismissal — SciencePlots solves a real subset of the same problem.
| SciencePlots | orx-figures | |
|---|---|---|
| Mechanism | Static matplotlib style sheets (plt.style.use(['science'])) | Agent skill: reference templates + agent-written code |
| Requires an agent? | No | Yes — designed for coding agents (GPT-5.6 Sol / Codex demoed) |
| Consistent academic styling | Yes, automatically | Yes, via the eight enforced rules |
| Decides what to emphasize per figure | No — it's a style, not a judgment | Yes, per alphaXiv's stated design |
| Determinism | Fully deterministic — same input, same look | Non-deterministic — agent still writes the code |
| Setup cost | One pip install, one style call | Skill install via OpenResearch CLI |
The trade is exactly what you'd expect from a deterministic library versus a skill layered on an agent: SciencePlots guarantees the same clean IEEE/Nature-style look every time with zero agent involved, because it never has to decide what a figure is for — it only decides what a figure looks like. orx-figures gives up that guarantee in exchange for adaptability: a figure whose emphasis changes per paper, per section, per argument, at the cost of the agent occasionally getting it wrong anyway, since the code generation step is still non-deterministic.
If you only need consistent, safe defaults across every plot in a repo, a styling library is less moving parts for the same visual bar. If the emphasis genuinely needs to vary — which claim this specific figure is making — a skill that can read context is doing a job a style sheet structurally cannot.
The demo: GPT-5.6 Sol with and without the skill
alphaXiv's launch video runs the same prompt through GPT-5.6 Sol (via Codex) with and without orx-figures loaded, alternating pairs through the demo. Asked which side was which, alphaXiv confirmed: "The first is without the skill, the second is with the skill, and it alternates after that." The side-by-side is the clearest evidence of the emphasis claim in practice — same model, same prompt, same underlying data, different figure because one run had the skill's reference templates and non-negotiable rules in context and the other didn't.
What OpenResearch is, more broadly
orx-figures ships inside OpenResearch, alphaXiv's broader CLI and local-dashboard platform for running research workflows with agents. OpenResearch assigns each research direction its own agent operating in an isolated worktree, so a researcher can run multiple experimental branches — longer context windows, an optimizer sweep, an ablation study — in parallel rather than one at a time, with an option to burst onto a remote compute marketplace when local resources aren't enough. It's available as both a macOS app and a CLI, and the figures skill is one piece of a platform aimed at automating the operational side of running ML research, not just writing it up.
Why this matters beyond one skill
This is a clean, concrete instance of the same agent skills pattern explainx.ai has tracked across the ecosystem all year — a portable SKILL.md package that encodes durable judgment for one recurring craft problem, loaded only when relevant, instead of re-explaining figure conventions in every prompt. It sits next to Microsoft's Flint, which solves an adjacent but different problem: Flint is a JSON chart specification an agent emits and a rendering backend compiles, so the agent never touches raw plotting code at all. orx-figures keeps the agent writing real matplotlib-equivalent code and instead steers judgment through templates and rules — two different bets on where determinism should live in agent-generated visuals.
For anyone using coding agents in research-adjacent work — writing up experiments, building research-agent pipelines, or benchmarking on scientific tasks — the practical takeaway is a decision rule, not a recommendation to switch tools: reach for a skills-based approach like orx-figures when the emphasis or framing genuinely needs to vary paper to paper, and reach for a deterministic styling library like SciencePlots when you just need every plot in the repo to look the same, safely, without an agent in the loop at all.
Honest limitations
- Not independently benchmarked. alphaXiv's own demo is a single before/after comparison video, not a blind study across many figures or papers — treat the emphasis claim as the vendor's own description until third parties test it.
- Non-deterministic by construction. Because the agent still writes the plotting code, the same prompt can plausibly produce different results run to run — the skill reduces bad outcomes, it doesn't eliminate them the way a style sheet's determinism does.
- Requires OpenResearch CLI / Codex-class agent. This isn't a standalone Python package — you need a coding agent capable of loading and following a SKILL.md-format skill, plus alphaXiv's CLI to get it installed and pointed at your project.
- New as of today. Shipped September 1, 2026 — expect the reference templates to iterate as researchers file issues against edge cases (three-way comparisons, log-log scaling, multi-seed variance) not yet covered by the six current files.
Related on explainx.ai
- What are agent skills? A complete guide
- Flint: Microsoft's chart spec for AI agents, explained
- ChatGPT for Academic Researchers — free GPT-5.6 Sol Pro
- Perplexity Wandr benchmark — open-source research agents
- Praxist beta — open-source research agents
- Terminal-Bench Science — scientific research benchmark
- ChatGPT Work vs Codex — complete guide
- Top AI prompts for data analysis
- OpenResearch CLI on GitHub
- orx-figures skill source
- Try OpenResearch
Skill contents, repository structure, and OpenResearch platform details are accurate as of September 1, 2026, based on the live openresearch-cli repository and alphaXiv's own announcement thread — verify the current SKILL.md and reference templates directly before relying on specifics, since alphaXiv may iterate the templates as usage feedback comes in.