Call the engine.
Reproduce the answer.

An engine, not a model

Most chemistry APIs wrap a trained model — fast, but approximate and different from one run to the next. Aufbau is the other kind: predictions come from bond energetics, orbital structure, and the Cahn–Ingold–Prelog rules, computed the same way every time. That single property — determinism — is what makes it worth calling as a service. A deterministic answer can be cached, verified, cited, and pipelined. A guess can't.

r = aufbau.Predict(reactants=["O=C=O", "N"])   # carbon dioxide + ammonia

r.products   →  ["CH3NO2"]           # carbamic acid — step 1 of the urea route
r.delta_h    →  +42 kJ/mol
r.address    →  "eeee16ddb8b9cb8c"     # reproducible, on any machine

Seven capabilities, one contract

A typed schema (aufbau.v1) that exposes what the engine does — never how. Every response carries a version envelope, and errors come back in-band rather than dropping the connection.

• PredictProducts of a reaction from reactant SMILES — with ΔH, structures, and a content address.
• RouteThe multi-step pathway: each elementary move, its mechanism and ΔH, and why the walk stopped.
• PredictStereoCarries stereochemistry through a reaction — a spectator center stays R/S, a reacting one is not determined.
• StereoCIP R/S stereocenters and E/Z double bonds for one molecule.
• StereoGeometry3-D coordinates whose handedness matches the CIP result — enantiomers as true mirror images.
• ConfigElectron configuration and valence for any atomic number — the computed periodic table.
• CatalystA metal's catalytic profile read straight off its d-band — no lookup table.

Three ways in

Same engine, same deterministic contract — pick the transport that fits your stack.

import grpc, aufbau_pb2 as pb
import aufbau_pb2_grpc as rpc

ch = grpc.insecure_channel("…:8080")
api = rpc.AufbauStub(ch)

s = api.Stereo(pb.MoleculeRequest(
      smiles="N[C@@H](C)C(=O)O"))
# → C#1 = "S"   (L-alanine)

# JSON in, deterministic JSON out
$ echo '{"op":"predict",
     "reactants":["N","[H]Cl"]}' \
    | aufbau-engine --serve

{ "products": ["H4ClN"],
  "favorable": true,
  "address": "…" }

Honest by construction

Where a simple model reaches its limit, the API says so rather than inventing a number. Carry stereochemistry through a reaction and a center that actually reacts comes back not determined — because deciding it would need transition-state geometry the engine doesn't model. It reports what it can derive, and refuses to fake the rest. That's the same discipline the whole project is built on.

products  →  ["C3H8ClNO2/1S"]        # the α-carbon is a spectator…
outcome   →  C stays S              # …so its configuration carries through

Run it in your own lab

The engine is headless by design — no app, no interface, no required network. Under a research-use license it can run as an on-premise Aufbau Server on a Linux box in your own building: molecules go in over a local API, computed results come out, nothing leaves — air-gapped if you need it. Because the engine is deterministic, that server returns exactly the reference answers, to the last bond, on your own hardware.

See how Aufbau fits into a CASP or retrosynthesis pipeline →

Toward a chemistry co-processor

A deterministic engine is the software precursor to something larger: because each element's behaviour follows a small fixed rule, that rule can be etched into hardware. The API is where that begins — a callable engine today, the same logic in silicon tomorrow. ◇ same request → eeee16ddb8b9cb8c

Get access

Building a retrosynthesis pipeline, a teaching tool, or a lab workflow on top of Aufbau? Tell me what you're building and what you'd want to call the engine for — research-use licensing and on-premise deployment are available, and I read every note.