ether0-chemistry-rewards

name	ether0-chemistry-rewards
description	Open-weights chemistry reasoning model + verifiable reward functions from FutureHouse's ether0 (arXiv 2506.17238). Use to score model-generated chemistry outputs (SMILES validity, molecular completion, synthesis reasoning) against ground truth, or to run the open-weights ether0 model itself for chemistry reasoning. Also useful for visualizing molecules and reactions from SMILES.
metadata	{"skill-author":"Compiled from FutureHouse ether0 (Apache-2.0)","upstream":"https://github.com/Future-House/ether0"}

ether0 — Chemistry Reasoning Model & Reward Functions

ether0 is FutureHouse's open-weights chemistry reasoning model, trained via SFT + RLVR (reinforcement learning with verifiable rewards) on a curated chemistry benchmark. The companion repo ships the reward functions used during training — directly usable for grading any chemistry-LLM output against ground truth.

Use this skill for:

• Scoring chemistry model outputs (e.g. evaluating GPT-4 / Claude on the ether0 benchmark)
• Running the ether0 model itself for chemistry reasoning (open-weights on Hugging Face)
• Drawing molecules and reactions from SMILES via ether0.data.draw_molecule / draw_reaction
• Building your own chemistry RL training loop (the rewards are the verifiable component)

Resources:

• Paper: https://arxiv.org/abs/2506.17238
• Model: https://huggingface.co/futurehouse/ether0
• Benchmark: https://huggingface.co/datasets/futurehouse/ether0-benchmark

Install

pip install git+https://github.com/Future-House/ether0.git
# or
git clone https://github.com/Future-House/ether0.git && cd ether0 && uv sync

Python 3.11+, Apache-2.0.

Recipes

Score a model's molecular completion

from ether0.rewards import valid_mol_eval

partial = "O=C(OC1C(OC(=O)C=2C=CC=CC2)C3(O)C(C)(C)CCCC3(C)C4CC=5OC=CC5C(C)C14"
good_completion = ")C=6C=CC=CC6"
bad_completion  = "CCC"

assert valid_mol_eval(good_completion, partial)        # True
assert not valid_mol_eval(bad_completion, partial)     # False — invalid SMILES

The full reward suite lives in ether0.rewards and covers tasks like SMILES validity, exact-match products, structural similarity, atom-economy of proposed reactions, etc.

Visualize a molecule

from ether0.data import draw_molecule

svg = draw_molecule("CC(=O)Oc1ccccc1C(=O)O")   # aspirin
with open("aspirin.svg", "w") as f:
    f.write(svg)

In Jupyter:

from IPython.display import SVG
SVG(draw_molecule("c1ccc(cc1)c2ccc(cn2)C#N"))

In a terminal: chafa aspirin.svg.

Visualize a reaction

from ether0.data import draw_reaction
svg = draw_reaction("CC1CNCC1c1nc2c(cnn2C(C)C)c(=O)[nH]1.COc1ccc(C=O)cn1>>")
open("rxn.svg", "w").write(svg)

Run the ether0 model directly

from transformers import AutoModelForCausalLM, AutoTokenizer

tok = AutoTokenizer.from_pretrained("futurehouse/ether0")
model = AutoModelForCausalLM.from_pretrained("futurehouse/ether0", device_map="auto")

prompt = "Propose a synthesis route from benzaldehyde to cinnamic acid."
ids = tok(prompt, return_tensors="pt").to(model.device)
out = model.generate(**ids, max_new_tokens=512)
print(tok.decode(out[0], skip_special_tokens=True))

Needs ~16 GB VRAM in fp16 (or quantize for smaller). Compatible with vLLM / TGI for production serving.

Evaluate any LLM on the ether0 benchmark

from datasets import load_dataset
from ether0.rewards import score_response

test = load_dataset("futurehouse/ether0-benchmark", split="test")
scores = []
for row in test.select(range(50)):       # first 50 questions
    pred = your_llm(row["question"])     # your model under test
    scores.append(score_response(pred, row))
print(f"Mean score: {sum(scores)/len(scores):.2f}")

When to use ether0 vs alternatives

Use case	Pick
Score a chemistry model's outputs against ground truth	ether0.rewards (this skill)
Generate molecules / synthesis routes interactively	Phoenix (hosted) or run ether0 model
Render SMILES → SVG quickly with no other deps	ether0.data.draw_molecule
Train your own chemistry agent with verifiable rewards	ether0 + NeMo-RL or HF TRL

Demo-friendly first call

from ether0.data import draw_molecule
open("caffeine.svg", "w").write(draw_molecule("CN1C=NC2=C1C(=O)N(C)C(=O)N2C"))
print("Wrote caffeine.svg")

Caveats

• Repo deliberately ships rewards + utilities, not training code. Use NeMo-RL or HF TRL for the SFT/RL phases.
• Some reward functions require rdkit (installed transitively); a few "exotic" ones spin up a small remote server (ether0.remotes).
• The open-weights ether0 model is research-grade — for production chemistry use Phoenix on the platform.