How I Built a Multi-Agent MLOps Control Center with Google TabFM, Gemma 2B & EU AI Act Cryptographic Attestations

⚠️ This article was written as part of my submission for the Google Cloud #AllThingsAgenticHackathon. Note: The application is currently in its validation phase, running locally on Streamlit and tested end-to-end. It is designed to be fully deployable to Google Cloud Run and BigQuery.

The Problem That Started Everything

Picture this: a telecom company hands you a CSV file with 915 clients. You open it, run a quick analysis, and discover 23.4% of those clients are about to leave next quarter. That's not a statistic - that's €142,500 in preventable annual losses sitting quietly in a spreadsheet, waiting for someone to do something about it.

The real problem isn't the data. It's what happens next:

• A data scientist spends 3 days building a pipeline that only they understand
• The model goes into production without regulatory documentation
• The executive team asks "what does 94% AUC mean in euros?" and nobody can answer
• Months later, an EU AI Act auditor asks for a signed decision log - and it doesn't exist

That's exactly the gap Dataset Automator was built to close.

What is Dataset Automator?

Dataset Automator is a Spatial, Multi-Agent MLOps & Executive Decision Center that transforms any tabular dataset (CSV or Excel) into:

• ✅ A certified, production-ready ML model (Google TabFM)
• ✅ An executive financial ROI report in plain language
• ✅ EU AI Act-compliant cryptographic attestations (RSASSA-PSS-SHA256)
• ✅ A standalone 55-cell Jupyter HTML notebook with all outputs embedded

In under 60 seconds. With full human oversight at every step.

Built with: Streamlit · Google TabFM · Google Gemma 2B · Gemini 3.5 Flash · Neo4j GraphRAG · Google PAIR What-If Tool · Google Model Card Toolkit

🏗️ Architecture Overview

┌─────────────────────────────────────────────────────────────────┐
│DATASET AUTOMATOR v4.1│
│Spatial 7-Node Pipeline Canvas│
└─────────────────────────────────────────────────────────────────┘
[📁 Ingestion]──►[🕸️ Neo4j OKF]──►[🤖 Gemini 3.5]──►[🔬 TabFM] ──►[🌲 XGBoost] ──►[⚖️ Evaluator] ──►[📓 Notebook]

Human Approval Gates:

• ⛩️ Gate A: Domain & OKF Validation
• ⛩️ Gate B: Feature Engineering Plan
• ⛩️ Gate C: Training Strategy Selection
• ⛩️ Gate D: Champion Model Registration

The entire pipeline runs visually on an SVG Spatial Canvas with animated particles moving along Bézier curves - no black boxes, full observability.

🤖 The Two-Model Google AI Strategy: Gemma 2B + Gemini 3.5

The Problem with "Always Use the Biggest Model"

Using Gemini 3.5 Flash for every pipeline operation would cost ~$0.35 per run. At scale, this becomes prohibitive. The solution? Cascade Routing with Google Gemma 2B.

class AdaptiveModelRouter :
    """ Cascade arbitration: route tasks to the most cost-efficient model.
    - Routine telemetry & trace evaluation → Google Gemma 2B (local, 152ms, $0.00)
    - Complex reasoning & deliberation → Gemini 3.5 Flash(API, ~800ms)
    """
    def route ( self , task : dict ) -> str :
        complexity_score = self . _compute_complexity ( task )
        if complexity_score < 0.40 :
            # Simple pattern → Gemma 2B local inference
            return self . gemma_2b . evaluate ( task [ " trace " ])
        elif complexity_score < 0.75 :
            # Intermediate → Gemini Flash (fast)
            return self . gemini_flash . generate ( task [ " prompt " ])
        else :
            # High-stakes reasoning → Gemini Pro
            return self . gemini_pro . generate ( task [ " prompt " ])
    def _compute_complexity ( self , task : dict ) -> float :
        """ Score based on token length, tool calls, and ambiguity