The RIC sets the policy. A ruApp in the radio closes the gap.

The twin is not a black box trained on positions that we would have to invent. The engine is ~1,100 lines of numpy. What ships in this repository is the generic mode: the same engine on a synthetic hex estate with 3GPP-default parameters. The twin stamps each output with its rung, and in the public demo it says so in each response.

# the guardrail call the rApp makes before a SLEEP
POST /v1/evaluate
{ "cell_configs": [{ "cell_id": "g-s1-a-n3", "on_off": false }] }

# reply (generic estate, uncalibrated)
"delta_vs_baseline": { "coverage_rate": -0.003, "outage_rate": 0.016,
                       "rsrp_p5": -1.198, "sinr_p5": -1.393 },
"rung": "simulation, generic 3GPP defaults (uncalibrated)"

The rApp registers in the rApp Catalogue and gets PM through an ICS job (R1). The same code runs on the real O-RAN SC Non-RT RIC and on the in-process stand-in.

Synthetic data ships with the repository (a generic diurnal profile). The same pipeline can run on any 30-minute KPI report CSV in a gitignored directory. Nothing from such a run ships.

This is a supervised classification problem. No one guesses a reward. You can reproduce each decision from data that you can inspect.

1. Label: made from the data itself. For each window t, the label is true if the PRB utilisation of window t+1 falls below the 25th percentile of the training set. The threshold is relative to the data. Thus the model adapts to the load scale of each cell, and no absolute KPI value is hard-coded or published.
2. Features: time and recent load. The features are hour of day as sine/cosine, day of week and a weekend flag. They also include current PRB utilisation DL/UL, throughput and active users. The last ones are one- and two-window lags and a rolling 3-window mean. Training and inference use the same feature function.
3. Model: gradient-boosted trees. scikit-learn HistGradientBoostingClassifier in a pipeline with a median imputer (logistic regression is the fallback). The model returns a calibrated probability, p_low, not a yes/no. Validation is a time-based holdout of the last 20 % of windows. Thus the score shows real forecasting and no leakage from shuffled data.
4. Governor: a deterministic policy on top. The probability goes into a rule-based policy engine. The engine sleeps a cell only when these four conditions are all true:
   • p_low ≥ 0.70
   • the current load is already under the threshold
   • the hold timer allows it
   • the twin guardrail agrees.
   It wakes a cell pre-emptively when the learned hour-of-day profile shows that load comes back. Each rule is readable, and the engine logs each decision with its inputs.

Roadmap. The physics twin is the natural offline environment. When the twin also models load, you can evaluate a policy against it, and later optimise it, without access to the network. That is the honest path to RL: simulate first, then act on the radio only inside an envelope that the governor still enforces.

# what the rApp reports about its own model
GET /health returns "model": {
  "kind": "HistGradientBoostingClassifier",
  "features": ["hour_sin","hour_cos","dow","weekend","prb_dl","prb_ul","thr_dl","users","lag1","lag2","roll3"],
  "label": "next-window prb_util_dl_pct < low_threshold (training 25th percentile)",
  "validation": "time-based holdout, last 20 %",
  "data": "synthetic" | "kpi_report_csv" (local KPI report CSV, gitignored)
}

It is easy to write a policy that sleeps carriers, and it is easy to fool one. Thus the replay uses the real code and not a re-implementation: the real LowLoadModel, the real policy_engine.decide() and the real ruApp wake rule. One command on the shipped synthetic data reproduces each number in this section. The efficiency ratio above is the case for the decision in the radio, as a number and not as an adjective.

What these numbers are not

Roadmap. The roadmap has three steps:

1. Host the same ruApp inside the real Open M-Plane server.
2. Drive it from real OCUDU code.
3. Bring a reference RU under the policy, with the M-Plane to ruApp contract as a community pattern.