“We are already an AI — can’t we evolve ourselves every time?” This user-anchored line opened the design of a self-learning system. But what this chapter records is not only how it works, but also an honest boundary — under the current premise that the platform has no safety-assessor signing feature, “learning from signed cases” has no autonomous fuel. Real growth that does not rely on humans comes from three other blocks: the deterministic engine, the resolved-cache, and active re-grounding. Being clear about this matters more than claiming a pretty but idling loop.
agreement_rate → 1.0 — every AI verdict is ultimately consistent with the SA, zero false negatives, zero numbers without provenance.sa_reviews.signed_at is currently all 0 — there is no real signing. So the ground truth for “learning from signing” is all hand-curated (uploaded SA-signed PDFs + official sample PIFs), not something the platform grew itself.The first design decision for the self-driving system was to define the goal clearly. The user anchored “achieve a 100% success rate”, but this phrase has a dangerous misreading — if understood as “100% of formulas pass”, that turns safety assessment into a rubber stamp, entirely violating the fail-safe constitution.
The correct definition is agreement_rate → 1.0:
Every AI safety verdict is consistent with the final human SA decision — zero false negatives, zero numbers without provenance, and the SA feedback loop progressively converges false alarms toward 0.
In other words, success is not “letting more formulas pass” but “the AI’s judgment getting closer and closer to that of a rigorous toxicologist”. This metric has zero tolerance for false negatives (letting a hazard through = immediate failure), while false positives (conservative mis-flags) are counted as over-flags pending calibration.
The core of the learning loop is an asymmetric rule that maps directly to Chapter 14’s fail-safe philosophy:
| Error type | Meaning | Learning action |
|---|---|---|
| false-safe | AI judged safe, SA intercepted (a miss) | Auto-tighten — a safe-direction adjustment may be auto-adopted by the engine |
| over-flag | AI judged review, SA considered it actually safe (false alarm) | Can only produce a calibration proposal, requiring a human toxicologist’s verification before relaxing |
The directionality is clear: tightening may be automatic, relaxing must be human-reviewed. This ensures that even if the self-driving system learns wrong, the wrong direction is “more conservative” rather than “more lenient” — a system that always drifts toward the safe side is far more trustworthy than one that might relax its own thresholds.
The self-driving system designed a “learn from SA signed cases” loop (tox_self_learning.rebuild_learned_anchors learns structural anchors from ground truth with sa_decision='acceptable'). But PROD evidence exposed an assumption:
sa_reviews.signed_at IS NOT NULL→ 0. The platform currently has no truly completed signings.
This means that learning loop has no autonomous fuel. The ground truth it learns from (a dozen or so entries) is all hand-curated: SA-signed PDFs manually uploaded by the user, official sample PIFs, red-team boundary cases. These are fed in by humans, not grown from the platform’s own signings.
This point must be recorded honestly, otherwise it would mislead the reader into thinking the system has a self-reinforcing flywheel. Without a signing feature, the “learn from signing” path moves only when someone manually adds ground truth. Stating this clearly is part of engineering honesty — a pretty but idling loop should not be advertised as autonomous evolution.
So what is real autonomous growth that does not rely on humans? The next three sections.
Chapter 14’s fallback cascade is itself autonomous: curated read-across rules, the RDKit structural-similarity engine, Cramer/TTC — when a new ingredient comes in, the engine gives a verdict directly by structural resolution, with no learning loop needed. This is the most reliable block, because its behavior is fully deterministic, traceable, and independent of how much historical data exists.
rebuild_resolved_anchors_from_history automatically sediments the parsing results with a cited NOAEL from ingredient_tox_cache (the cache of already-analyzed ingredients) into anchors. This requires no signing — as long as an ingredient has once been resolved by an authoritative value, it can serve as an analogue for future read-across. The limitation is a low yield: most cosmetic ingredients are botanical extracts / have no cited NOAEL, and no anchor can be sedimented from them.
This is the correct answer to “autonomous even without signing”. For ingredients with “no NOAEL found”, the system proactively queries an authoritative source (EPA ToxValDB) to fetch more cited NOAELs, expanding from the source rather than passively waiting to be fed by humans.
tox_regrounding.py (the harvester) runs in skip_ai=True mode — EPA ToxValDB is the only non-AI numeric source (OECD/ECHA return only existence; CIR/SCCS go into the AI queue). A daily cron scans data_gap → enqueues → processes → sediments regrounded anchors. PROD evidence (with AI offline) did fetch cited NOAELs: Phenoxyethanol 80, Salicylic Acid 100, ZnO 31.25 — all from EPA ToxValDB, with zero ground-truth contradictions.
One pitfall stepped on three times is worth recording: early re-grounding tried to sediment results into a structural anchor (which needs a SMILES), but the raw return of skip_ai=True does not carry a canonical SMILES → sedimentation failed. The correct answer is not to force a SMILES, but to store the regrounded NOAEL back into the resolver as a cited Tier, keyed by CAS — the next time the same CAS appears, use it directly without going through structure. A data_gap can be retried after a 7-day cooldown (re-fetched whenever the authoritative source updates).
For the self-driving system to be trustworthy, every computation constant it uses must be traceable to authoritative literature, not a magic number an engineer filled in casually. tox_reference.py is an SSOT of computation bases: every basis (TTC, exposure, DAp, SED, MoS, NOAEL assessment factor) is anchored to an authoritative source and records three things — the adopted value, the alternative value, and why the strictest was chosen.
| Basis | Authoritative source | Design principle |
|---|---|---|
| TTC threshold | Munro 1996 / Kroes 2004 / Cramer 1978 | With a structural alert, take the strictest 0.15 µg/day |
| Exposure E | SCCS/1647/22 Table 3A/3B | Use only if the authority lists it; if not, fall to conservative whole-body |
| DAp | SCCS/1647/22 §4-5 + Bos & Meinardi | Fixed oils 5%; essential oils / small molecules not applied |
| MoS threshold | SCCS convention | ≥ 100 (10× interspecies × 10× inter-individual) |
verify_live_constants() self-checks whether the live constants are consistent with the documented literature — if someone changed a constant in the code without updating its literature basis, the self-check catches it. The safety-assessment report’s appendix (§8) outputs this basis together via render_basis_appendix(), letting the SA and the regulator see “where each number comes from”.
Iron rule: a safety threshold must not be naively “aligned to the literature” and relaxed. TTC deliberately takes the strictest — the literature gives a range, and the system takes the conservative end. Before changing any safety constant, one must first read that constant’s literature-basis annotation and understand why this value was chosen in the first place.
Validating the self-driving system cannot only run “normal formulas”; it must proactively attack itself. Every round of deepening runs an adversarial red-team to confirm fail-safe has no breach:
The red-team’s pass criterion is “zero false-safe breach” — if even one hazardous input is released as safe, it is a failure. After multiple red-team rounds, the false-safe dimension was judged truly converged (rather than merely not-yet-caught), at which point it is advisable to stop deep-mining that dimension and turn to other backlog (such as dedicated gates for inhalation dosage forms, or an SED model for hair-dye / perm products).
The core value of self-driving evolution lies not in any single machine-learning technique, but in honest engineering under constraint: use the deterministic engine and active re-grounding to achieve real growth that does not rely on humans, use asymmetric learning to ensure any automatic adjustment drifts to the safe side, and clearly mark which loops currently still lack fuel — letting the system’s degree of autonomy honestly correspond to the data it actually possesses.
| Version | Date | Summary |
|---|---|---|
| v0.3 | 2026-07-06 | First written. Covers the agreement_rate definition, asymmetric learning, the honest boundary of having no signing feature, the three truly-autonomous blocks (deterministic engine / resolved-cache / active re-grounding), the computation-basis documentation SSOT, and adversarial red-teaming. |
© 2026 Baiyuan Tech. Licensed under CC BY-NC 4.0.
Navigation ← Chapter 15: Regulatory Correctness · Appendix A: Glossary →