A private research platform

A drug is not a name. It is physchem, binding and PK — and the organ vector emerges.

Hand csb a mechanism and it computes the body around it: one whole-body PBPK field carries an arbitrary molecule — including one that has never existed — into every tissue its physiology declares, and a cited expression gate turns local exposure into per-organ effect. Statin myopathy shows up in skeletal muscle because HMGCR is there, not because anyone typed it. Underneath sits the corpus, molecule to clinic — measured from a frozen store, hash pinned, 2026‑07‑24. Every other figure below is read from the code's own registries at build time, never typed.

five benches RAPL · CLDD · CLMD · CLND · CLCD. They install csb and score against it — csb imports none of them.
csb — the core One ModelIR, — commands, — addressable body coordinates.
the corpus — the data layer — typed couplings, reached through one flag — and it never reaches back.

The body · the seven axes

Every entity gets a place in the body — on seven axes at once.

A corpus can say that two things couple. It cannot say where in a body that happens, and an effect you cannot address is not an effect you can act on. So each axis here is a fixed vocabulary, and a cardiomyocyte calcium channel is not a leaf on one of them — it carries one value on every axis simultaneously. That is what lets a coupling become an organ, and an organ become a dose decision — csb patient review runs one curated patient case across every applicable engine, from warfarin INR to renal dosing to prodrug PGx, and unifies the read-outs into a single sheet with each row flagged actionable or not.

—

addressable body coordinates — the product of all seven axes. Nothing is inferred: an entity that will not classify gets a marked extension, never a wrong bucket.

The body · scale & system

One shared field, so one changed fact moves every organ at once.

csb keeps no private graph per drug. A molecule gets one whole-body concentration field, and each organ reads its own local unbound exposure off it — so changing a single fact moves the entire vector together. Change only the route and csb reach vancomycin flips: oral cannot reach an endocardial vegetation, intravenous can. Change nothing but where the target is expressed and csb effect atorvastatin returns liver and skeletal muscle, because HMGCR sits in both. The scale axis below is ordered, so it reads as a ladder; the system axis is not, so every bar carries its own number.

the planes — structural levels, molecular at the bottom to organism at the top.
the spokes — organ systems, drawn on the organ plane.
the ties — organs sit on more than one system — one entity at two coordinates, joined.
the nodes every organ, drawn larger where its reserve is characterised — — of —.

Structural scale

finestwhole

Every organ cited — and where the reserve is missing, refused by name

Reserve characterised — — Refused, by name — —

Organs per system

The corpus · not just large

A pile of edges is a hairball. This is a grammar.

Every coupling is typed, most carry a numeric weight, and where two sources agree on direction the edge also carries a sign. Strength and sign are separate columns on purpose: an inhibition is a strong negative coupling, and a model that stores only one number has to encode it as a weak positive one. The same split runs all the way into the computation — csb's effect kernel keeps magnitude (how hard an organ is engaged) and direction (which way it moves) on two channels, because they answer different questions.

—

typed couplings, sitting under the model as evidence a computation can draw on. Not a pile of edges — every one of them typed, directed, and carrying where it came from.

The corpus · reconciled

Every source arrives in its own alphabet. They leave as one.

Each brings its own identifier space, its own schema, its own idea of what an edge is. What comes out the other side is a single grammar, in which a chemical, a gene and a phenotype are addressable the same way.

—

entity kinds, in — metaedge types. Chemical binds protein, protein sits on a pathway, disease presents a phenotype — the chain is the shape of the graph.

bars are logarithmic — on a linear axis every source below the largest would vanish

The corpus → the body · the seam

One flag pulls the whole graph into the computation.

The corpus is not a service csb calls. It is csb's own data layer: --with-corpus unions the licence-gated corpus into the cited corridor — IUPHAR and DrugCentral affinity, GTEx expression, ChEMBL PK — and cited rows win, so a computation that would have refused for want of a constant can find one without a gated row ever displacing a cited one. The dependency runs one way — csb reads the corpus, the corpus never reaches back — and the default path stays byte-identical without it, so the same command works on a checkout carrying none of the store.

—

carry a real numeric strength — — of the graph, not a bare link. A number is something a model can compute with.

The corpus — what was mrm —

typed couplings, from — reconciled sources, in — of licence-gated store.

csb effect --with-corpus one way

csb — what computes —

addressable body coordinates, across — closed axes, with — commands on the surface.

Two source tiers, never added together

One tier indexes what a thing is — a pinned, checksummed registry of identity. The other indexes what couples to it. Summing them would be a category error, so the page never does.

Both halves · why the output is usable

A refusal here is an address, not a shrug.

Laundering a label is a type error here, not a review failure: a tiered value refuses in its constructor to hold a number it may not claim, reaching for its magnitude raises LabelLaunderingError, and a chain's tier is the minimum of its hops — it can fall, never rise. When csb declines an organ it names the missing fact from a closed vocabulary of four — no_pbpk_compartment, reserve_not_characterised, expression_unknown, unknown_organ — and a free string will not compile. Those refusals ride in the payload while the exit code stays 0, so a caller can never read one as a crash. Each maps to the data source that would close it, and the one that data alone cannot close is flagged requires_code_change.

the path

is the product, not the edge. What connects two things, through what — and whether that is more than degree already explains.

uncited constants

Out of — cited affinity constants in the store — every one carrying the paper it came from, enforced at load, where a missing citation raises. And the number never travels alone: driver_quantity_kind says whether it rests on a Kd or an IC50 — not a weak Kd, but an assay-conditional quantity whose bias cannot even be signed — while measurement_spread rides beside the value and is never folded into it. None there means unknown, never no spread.

primary — literature median —

And a route scored against the degree null

Both halves · provenance

Every claim re-verifies offline.

Reference sets are indexed one row per entity and each carries a sha256 pin re-checked on read, so a source that shifts underneath the platform fails loudly instead of quietly changing an answer. lineage_sha256 covers the inputs only, and is tight enough that adding an unconditional key to a payload counts as a breaking change. Licence is an allow-list built before the first ingest — nothing is exportable merely because nobody forbade it — which is why an open export is provably clean. And every result carries verification_cost: what it would take you to stop trusting csb and check it yourself, in items you can point at, with a governance test that fails if anyone turns it into a ratio.

—

can travel under an open licence. Provenance is a column, so the picture that stands is exactly the open track — an export you can ship without arguing about it afterwards.

The pinned tier

The export gate

Open — — Gated — — Share-alike — —

frozen store
—

routes scored — · the split verified across all — couplings

The surface · and what runs on it

One core, two ways to solve it, five benches that consume it.

Counted by walking the tree and reading the store, not by remembering. One ModelIR sits between the external formats and everything downstream, and nothing is allowed to bypass it; from there the same model is solved classically — ODE, SDE, SSA, FBA, PBPK — or learned, as a PINN or a neural ODE. The two are held together by a protocol method: a bridge that implements validate_against_classical cannot ship a drifted trace, because exceeding tolerance raises instead of returning a quiet failure flag. Five benches install csb and consume it as a scoring oracle — RAPL for regulatory work, and the CLDD, CLMD, CLND and CLCD design loops for drugs, devices, nutrition and cosmetics. csb imports none of them. And what crosses that boundary is the marker, not just the number: where a cited absence makes csb compute a zero it cannot stand behind — rofecoxib's heart — the evidence: lower_bound flag survives into RAPL and turns that zero into not_assessed, never a clean bill of health.

Both halves · the size of the gap

And this is what it cannot do yet.

Everything above is what csb computes. This is the scale of what it does not, in the same units — because a page that only lists strengths gives you no way to check the ones it lists. These four are hand-measured on 2026‑08‑03 rather than read from a registry, so each carries the command that re-derives it.

1 of 56capabilities are calibrated against held-out data. Every other magnitude is contrast-only or NOT_CALIBRATED — a ratio you may quote, never an absolute number.
6 of 111curated drugs return an organ row whose magnitude may be claimed — 16 rows out of 80 — and not one of those 16 rests on a binding constant. Every one is an IC50.
12 of 86bridge modules implement validate_against_classical. Where it is implemented the gate is real and raises; it is not yet everywhere.
0sanity checks were chosen by anyone who knows the biology. APOE→Alzheimer and statins→rhabdomyolysis were picked by the people who wrote the code, so no domain review has happened.

re-derive — csb granular calibration --json · csb store audit --json · grep -l "def validate_against_classical" src/csb/bridges/*.py