GreenOps Platform: Carbon-Aware Scheduling
Defer When the Grid Is Dirty
73% chance of a clean window within range
vs immediate-dispatch baseline
all pillars · fully auditable to the job level
GreenOps is a cross-cutting governance module in The Autonomous Enterprise Platform — it shifts every flexible workload from every process pillar to low-carbon grid windows without touching a single pillar's domain logic. It is the only AE Platform module with no HITL checkpoint and no human decision path: scheduling decisions are fully autonomous within a ±6 hour deferral window. Hard-deadline jobs are never deferred.
All carbon savings are auditable to the job level and exported as CSRD Scope 3 Category 11 emissions data, shared across the entire platform. Every dispatch writes an actual-vs-baseline record to BigQuery — sourced from metered GKE compute utilisation, not estimates — so a CSRD auditor can verify every savings claim against the source carbon intensity API data and the arithmetic independently.
§1 System Context
GreenOps serves all four process pillars equally — Quote-to-Cash, Procure-to-Pay, Finance Operations, Supply Chain — and every pillar that follows. The CTO and sustainability team are consumers of GreenOps output (the ESG metrics dashboard and Strategy Dashboard feed), not participants in its decisions. Carbon intensity in, optimal dispatch time out — no humans required.
| Job | Pillar / Module | Schedule | Deadline Type | Max Deferral | Eligible? |
|---|---|---|---|---|---|
| Weekly model retraining (RevRec AI) | Quote-to-Cash · M-03 | Sundays 02:00 UTC | Soft — weekly freshness | ±6 hours | ✓ Deferrable |
| Weekly model retraining (Asset IQ RUL) | Quote-to-Cash · M-05 | Sundays 03:00 UTC | Soft — weekly freshness | ±6 hours | ✓ Deferrable |
| Weekly model retraining (ContractGuard) | Quote-to-Cash · M-02 | Sundays 04:00 UTC | Soft — weekly freshness | ±6 hours | ✓ Deferrable |
| Daily feature pipeline backfill | Governance Layer · M-08 | Daily 01:00 UTC | Soft — before daily RUL run | ±3 hours | ✓ Deferrable |
| Daily RUL batch prediction | Quote-to-Cash · M-05 | Daily 02:00 UTC | Hard — FSM queue same day | None | ✗ Never deferred |
| FinRisk anomaly model refresh | Quote-to-Cash · M-04 | Daily 03:00 UTC | Hard — streaming model currency | None | ✗ Never deferred |
| ContractGuard Vector Store reindex | Quote-to-Cash · M-02 | Monthly, 1st | Soft — monthly precedent freshness | ±12 hours | ✓ Deferrable |
§2 Container Diagram — C4 Level 2
The GreenOps Platform boundary contains four distinct deployable containers. Each maps to a GCP-managed service with an explicit IAM surface and VPC-SC perimeter membership. Technology choices are documented in ADR-GO02 through ADR-GO05.
greenops-sa@ roles: run.invoker · datastore.user · bigquery.dataEditor · monitoring.viewer — scoped to the greenops project only| Container | Technology | Role | IAM / Notes |
|---|---|---|---|
| Cloud Scheduler | GCP Managed | HTTP POST trigger · job_id, suite_id, deadline, flexibility_window flag | External trigger source |
| GreenOps Agent | Cloud Run · always-on | Carbon forecaster · decision engine · job dispatcher · circuit breaker | SA: greenops-sa@ · min-instances:1 |
| Firestore | GCP Native, Datastore mode | deferred_jobs collection · TTL on window_expiry | ADR-GO03 |
| BigQuery | GCP Native, Serverless | ae_greenops.job_metrics · CSRD export query | metered_kwh · carbon_saved |
| GKE Autopilot | GCP Managed | All process pillar batch ML jobs | roles/container.developer · greenops-sa@ |
| Carbon Footprint API | GCP, VPC-SC native | Circuit breaker on timeout | No internet egress required |
§3 Architecture — Carbon-Aware Scheduling Pipeline
The GreenOps scheduling pipeline runs every 30 minutes to re-evaluate deferred jobs against the latest carbon intensity forecast. The decision to dispatch is autonomous and immediate — no human is in the path. A circuit breaker wraps every Carbon Footprint API call: on timeout or 5xx, GreenOps enters degraded mode — all queued jobs dispatch immediately with api_fallback:true flagged in the ESG record, and full scheduling resumes on the next successful API response.
| Decision Point | Condition | Outcome |
|---|---|---|
| Hard deadline check | hard_deadline = true | Bypass — dispatch immediately |
| Intensity check | intensity < 80 gCO₂eq/kWh | Dispatch immediately |
| Defer check | intensity ≥ 80 + window open | Add to Firestore deferred queue |
| Expiry check | window expired | Force dispatch + expiry flag |
| Re-evaluation | every 30 minutes | Re-check all deferred jobs against latest forecast |
ae_greenops.job_metrics) feeding the monthly CSRD Scope 3 Category 11 export.§4 State Machine — Job Lifecycle
The GreenOps job state machine has no failure state — every job reaches COMPLETE. Hard deadline jobs bypass the DEFERRED state entirely. Window-expired jobs dispatch at whatever the current intensity is; the ESG record captures the actual emissions accurately (saving_pct = 0% in the worst case — the data is honest, not optimistic).
| State | Trigger | Detail |
|---|---|---|
| SUBMITTED | Cloud Scheduler | Job arrives with job_id, suite_id, deadline, flexibility flag |
| SUBMITTED → EVALUATING | always | Carbon API check |
| EVALUATING → DEFERRED | intensity ≥ 80 | Firestore queue, 30-min re-eval loop |
| EVALUATING → DISPATCHING | intensity < 80 or hard_deadline | GKE Autopilot submit |
| DEFERRED → DISPATCHING | intensity↓ or window expired | Dispatch at improved or current intensity |
| DISPATCHING → COMPLETE | job runs | ESG record written to BigQuery |
§5 Data Flow Sequence
A weekly ContractGuard Vector Store reindex arrives at 02:00 UTC, is deferred because europe-west3 is at 142 gCO₂eq/kWh, re-evaluated five times across the 30-minute loop, dispatched at 06:12 when intensity drops to 71, and completes with a 49% carbon saving logged to BigQuery.
contractguard_vectorstore_reindex · 02:00 UTC · deferred 4h12m · dispatched at 71 gCO₂eq/kWh · 49% saving| Time | Actor | Event |
|---|---|---|
| 02:00 | Cloud Scheduler | contractguard_vectorstore_reindex · flexible |
| 02:01 | Agent → Carbon API | get_forecast(europe-west3, 12h) |
| 02:01 | Carbon API → Agent | current: 142 · min@06:12: 68 gCO₂eq/kWh |
| 02:02 | Agent → Firestore | queue_deferred(job_id, window_expiry=08:00) · intensity 142 ≥ 80 |
| 02:30–04:30 | Re-evaluation cycles | 128 defer · 112 defer · 98 defer · 84 defer · 76 approaching threshold |
| 06:00 | Agent → Carbon API | get_forecast(europe-west3, 12h) |
| 06:00 | Carbon API → Agent | current: 74 · next 30min: 68 → dispatch |
| 06:12 | Agent → GKE | gke.submit_job(contractguard_vectorstore_reindex, carbon_intensity=71, metered_kwh=1.8) |
| 07:14 | Agent → BigQuery | actual 0.128 kgCO₂ · baseline 0.248 kgCO₂ (at 138) · saved 0.120 · saving_pct 49% · csrd_eligible: true |
| 07:14 | State | Complete · deferred_by: 4h12m · carbon_saving: 49% · CSRD eligible: true |
§6 ESG Metrics Dashboard
GreenOps produces auditable carbon savings data — not estimates or projections. Every dispatch writes an actual-vs-baseline record to BigQuery. The CSRD Scope 3 Category 11 export aggregates savings across all process pillars and is generated monthly from these records. The figures below are indicative of a full H3 platform deployment at ClaraVis's workload volume.
SLO breach triggers a Cloud Monitoring alert to the AE Platform on-call. Downstream suites are notified via the platform event bus. The circuit breaker (ADR-GO04) activates automatically — no manual intervention required. Error budget is tracked monthly and reviewed alongside CSRD savings figures.
ae_greenops.job_metrics table exports monthly to a CSRD-aligned CSV with: reporting_period, scope, category, activity_description, activity_units, activity_quantity, emission_factor, total_emissions_kgCO2eq. This export feeds directly into ClaraVis's sustainability reporting tool and satisfies the EU taxonomy technical screening criteria for climate change mitigation.§7 Architecture Decision Records
Five GreenOps decisions, all defensible on their own terms.
The deferral window is the single most important GreenOps design parameter. Too short (±1 hour) and the window is rarely wide enough to capture a meaningful carbon intensity improvement — europe-west3 intensity changes gradually, and a 1-hour window often doesn't span a low-carbon trough. Too long (±24 hours) and flexible jobs start to accumulate in the deferred queue for periods that affect model freshness. ±6 hours was chosen on two empirical observations: (1) analysis of 90 days of europe-west3 Carbon Footprint API data shows a low-carbon window (below 80 gCO₂eq/kWh) occurs within 6 hours of any given time approximately 73% of the time. (2) the ML models across the platform's process pillars were evaluated for freshness sensitivity — all maintain acceptable prediction quality with weekly retraining cycles; a 6-hour delay on a weekly job represents a 0.4% increase in the retraining interval, statistically indistinguishable from expected model performance at the weekly evaluation frequency.
Electricity Maps and WattTime were evaluated — both provide more granular real-time and forecast carbon intensity data than GCP's Carbon Footprint API, including marginal emissions rates. Rejected for three reasons. (1) GCP's Carbon Footprint API is available within the VPC-SC perimeter as a GCP-native service — no outbound internet call required; third-party APIs require outbound HTTPS calls that must be documented in the VPC-SC threat model and approved by the CISO. For a governance-layer module serving all process pillars, adding an external API dependency for a Minimal Risk module is not justified. (2) GCP Carbon Footprint API data is directly aligned with the GCP billing carbon reporting ClaraVis already uses internally — using the same data source for scheduling decisions and CSRD reporting ensures internal consistency. (3) at the forecast granularity required (30-minute intervals, 12-hour horizon), the GCP API is sufficient — the marginal vs average emissions distinction matters more for real-time demand response than for batch job scheduling with a 6-hour window.
Cloud Tasks was the primary candidate — it is the canonical GCP service for delayed/scheduled task execution. Rejected for two reasons. (1) GreenOps does not need guaranteed-once delivery with a fixed delay; the deferred queue requires re-evaluation on every 30-minute loop against the current carbon intensity — the dispatch decision is "dispatch when a condition is met on a schedule," a query pattern, not "dispatch after N minutes." (2) Firestore enables the query GreenOps actually needs: SELECT all jobs WHERE window_expiry > NOW() AND state = DEFERRED — a predicate query over a mutable document store that Cloud Tasks does not expose. The tradeoff — no native dead-letter queue — is mitigated by window-expiry forced dispatch: every job that cannot be deferred successfully is force-dispatched at window_expiry, not lost. Document accumulation is bounded by job volume (≤30 jobs/week at ClaraVis H3 workload), so unbounded growth is not a concern at this scale.
When the GCP Carbon Footprint API is unavailable (timeout, 5xx, or stale data beyond 90 minutes), GreenOps must choose between two degraded modes: (A) block all job dispatch until the API recovers, or (B) dispatch all queued jobs immediately and flag records as api_fallback:true. Option A preserves carbon optimisation intent but violates the "every job dispatched eventually" safety property — a multi-hour API outage would hold all process pillar training jobs in DEFERRED state, potentially cascading into model freshness violations. Option B sacrifices carbon savings for the duration of the outage but maintains the scheduling reliability guarantee GreenOps promises to all process pillars. Degraded-mode dispatches are flagged in BigQuery and excluded from CSRD savings calculations — the audit trail remains accurate. The circuit breaker threshold: 3 consecutive API failures within a 5-minute window triggers degraded mode; recovery requires 2 consecutive successful calls.
Google's carbon-aware computing research (Radovanovic et al., 2021) uses a rolling percentile threshold — typically the 75th percentile of the trailing 30-day distribution — rather than a static absolute value, adapting to seasonal variation in europe-west3's carbon intensity. The adaptive approach is architecturally superior and is the target state for Phase 2. It is deferred for MVP for two reasons. (1) it requires 30 days of historical Carbon Footprint API data before the rolling window is statistically meaningful — deploying in H3 means the threshold logic would run on incomplete data for the first month. (2) a static threshold is easier to audit: CSRD reviewers can verify that every job dispatched below 80 gCO₂eq/kWh meets the threshold without reconstructing the rolling window at each dispatch time. Phase 2 will introduce a threshold_type field (static | rolling_p75) in the ESG record to maintain auditability across the transition.
§8 Stakeholder Rebuttals
Four objections raised during the GreenOps design review. Each rebuttal is grounded in architectural evidence, not opinion.
ae_greenops.job_metrics and verify every savings claim to the job level, which is genuinely harder to produce than a top-down estimate.ae_greenops.job_metrics table is designed for external audit from the start. Every row contains the GCP job ID (traceable to the Cloud Logging execution record), the Carbon Footprint API response at dispatch time, the actual kWh consumed captured in metered_kwh (sourced from GKE resource utilisation via Cloud Monitoring — not estimated), the emission factor applied, and the calculated emissions figure. An auditor can verify each savings claim by checking the source API data, the actual compute utilisation, and the arithmetic independently. The CSRD export format aligns with the EU taxonomy technical screening criteria for Scope 3 Category 11. The remaining assurance gap is the carbon intensity data itself — Google publishes its own methodology statement for the Carbon Footprint API, which ClaraVis would reference in its CSRD disclosure, standard practice for Scope 2 location-based calculations.window_expiry independently — jobs with staggered submission times dispatch sequentially as their individual windows expire, not simultaneously; the weekly retraining jobs for RevRec AI, Asset IQ, and ContractGuard submit at 02:00, 03:00, and 04:00 UTC with maximum expiries at 08:00, 09:00, and 10:00, so even in a worst-case scenario the three forced dispatches are spaced an hour apart. Second, GKE Autopilot's per-pod scheduling absorbs burst workloads gracefully — each job runs on its own node pool, provisioned independently. The window-expiry scenario is a degraded mode, not a failure mode — jobs run at higher carbon intensity than optimal, saving_pct = 0%, and the CSRD export reflects actual emissions accurately.§9 Demo Pathway
Three minutes. One deferred job. One dispatch. One ESG record. The pathway shows the complete GreenOps lifecycle: job submitted, carbon intensity checked, job deferred, intensity drops, job dispatched, ESG record written.
ae_greenops.job_metrics table with recent dispatch records from across all active process pillars.deferred_jobs document for contractguard_vectorstore_reindex shows: job_id, suite_id, submitted_at, window_expiry (submitted_at + 12h), current_intensity: 138, forecast_min_intensity: 72, forecast_dispatch_time: +3.8h.ae_greenops.job_metrics, the new row: actual_intensity 71, metered_kwh 1.8 (source: GKE Cloud Monitoring, not estimated), actual_emissions_kgco2: 0.128, baseline_emissions_kgco2: 0.248 (at 138), carbon_saved_kgco2: 0.120, saving_pct: 48%, csrd_eligible: true, dispatch_delay_h: 3.8.SUM(carbon_saved_kgco2) and SUM(actual_emissions_kgco2) from ae_greenops.job_metrics WHERE csrd_eligible = true, grouped by reporting month. One query covers jobs from every process pillar.§10 ESG Monitoring Dashboard — Live View
This is the GreenOps monitoring view as it appears to the CTO and sustainability team — a read-only consumer of ae_greenops.job_metrics. No decisions are made here. Every figure shown is derived from the same BigQuery table that feeds the CSRD Scope 3 export. The live queue panel reflects the current state of the Firestore deferred_jobs collection.
| Job ID | Pillar | Intensity | metered_kwh | CO₂ Saved | Saving % | CSRD |
|---|---|---|---|---|---|---|
| contractguard_vectorstore_reindex | qtc_pillar | 71 | 1.8 | 0.120 kg | 49% | ✓ |
| revrec_ai_weekly_retrain | qtc_pillar | 68 | 4.2 | 0.318 kg | 52% | ✓ |
| asset_iq_rul_weekly_retrain | qtc_pillar | 74 | 6.1 | 0.391 kg | 43% | ✓ |
| feature_pipeline_backfill | ae_platform | 86 | 0.9 | 0.000 kg | 0% | — |
| daily_rul_batch_prediction | qtc_pillar | 104 | 2.3 | — | Hard | — |
§11 Adjacent Modules
Three platform services — GreenOps is the second. Data Governance (M-08) is the H1 foundation, deployed first, before any process pillar. GreenOps (M-06) activates in H3 once workload volumes justify carbon scheduling. The Strategy Dashboard (M-07) closes the platform layer — reading GreenOps ESG metrics alongside signals from every process pillar and presenting the unified executive view.