Skill

---
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

```bash
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
```python
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
```python
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:
```python
from IPython.display import SVG
SVG(draw_molecule("c1ccc(cc1)c2ccc(cn2)C#N"))
```

In a terminal: `chafa aspirin.svg`.

### Visualize a reaction
```python
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
```python
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
```python
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

```python
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.