This is a submission for the MLH x DEV Writing Challenge
OmniML: An AutoML Pipeline That Actually Asks Before It Decides
What I Built
Most AutoML tools operate as complete black boxes. You feed in a dataset, a brute-force search algorithm churns away behind closed doors, and out comes a model with zero explanation, no room for expert intervention, and no consideration for regulatory standards like the EU AI Act or FDA Software-as-a-Medical-Device (SaMD) guidelines. That opacity is exactly what my team set out to fix.
At HackTropica, we built OmniML — an open-source, full-stack, autonomous machine learning system that keeps a human explicitly in the loop at every critical decision point. Orchestrated with LangGraph, powered by Groq's openai/gpt-oss-120b for fast reasoning, and wrapped in an interactive Chainlit UI, OmniML turns a plain-English request into a fully trained, compliance-checked, and deployment-ready ML model, sourcing real datasets from Kaggle along the way.
The pipeline runs through a chain of dedicated stages, and at five separate checkpoints it pauses and hands control back to the user before proceeding. The architect agent first proposes a baseline model graph from the problem statement, which the user can then visually edit through an embedded React Flow canvas before anything is compiled. From there, the system searches, ranks, and downloads a real tabular dataset via the Kaggle API, profiles it for feature distributions and data quality, and surfaces that analysis for review. The user then configures hyperparameters, fairness settings, and compliance mode, and makes an explicit choice between local and cloud compute before training is ever allowed to start. Once training resumes, an engineer and debugger agent pair generates deterministic training code, validates it, and executes it in a sandboxed environment while streaming real-time logs and metrics back to the UI. The final stage produces SHAP and LIME explainability outputs, fairness benchmarks, and a full compliance report formatted against EU AI Act and FDA SaMD guidance, alongside a production-ready deployment bundle.
One design decision I'm particularly proud of is supporting two distinct training paths depending on the problem. Path B, which is the default, uses scikit-learn for fast tabular, text, or image training via grid search over a featurized CSV. Path A compiles the user-approved React Flow graph directly into a custom OmniMLNet PyTorch module and trains it with real epoch-level metrics, which is useful when someone actually wants to reason about network architecture rather than just get a fast baseline. OmniML also grounds its architecture decisions in real research: before training begins, an agent pulls relevant literature and produces a gap-analysis comparing the current dataset, task, and proposed architecture against published methodologies, so the user can see exactly where their setup diverges from established approaches in the field. Every run is also fully reproducible: each execution persists to runs/<run_id>/manifest.json as a complete evidence bundle covering artifacts, plots, logs, and reports, all downloadable and normalized for later benchmarking.
Here's the high-level flow end to end:
User Query
└─► Architecture generation
└─► HITL architecture editor (React Flow)
└─► Dataset sourcing and ranking (Kaggle)
└─► HITL dataset selection
└─► Dataset download + validation
└─► Drift sentry
└─► EDA profiling
└─► HITL training configuration
└─► HITL compute strategy
└─► Hyperparameter tuning + deterministic code generation
└─► Code validation & self-healing
└─► Execution sandbox
└─► XAI / benchmark / fairness / compliance
└─► Deployment dashboard + downloadable reports
What I learned building this had less to do with the ML itself and more to do with orchestration. Getting an LLM-driven agent graph to pause reliably at a UI checkpoint, hold state correctly, and resume exactly where it left off — without losing context or re-triggering earlier stages — turned out to be the hardest engineering problem in the whole project, harder than anything on the modeling side.
Demo
Here's the full walkthrough of OmniML running end to end, including the interactive HITL graph editor, live dataset profiling, and compliance report generation:
🎬 Video Demo
🔗 GitHub Repository: https://github.com/Pritam-mb/hacktropica
Visual Architecture Editor (HITL Checkpoint)
The embedded React Flow visual editor inside Chainlit lets you visually refine a proposed neural network topology before it's compiled into a trainable model:
Pipeline Walkthrough in Screenshots
1. EDA Profiling Dashboard. After a dataset is sourced from Kaggle, OmniML runs it through an automated profiling stage that surfaces missing values, feature distributions with skewness stats, and categorical feature breakdowns — all before the user is asked to approve moving forward:
2. Outlier Detection, Correlation Analysis & AI Data Insights. The same EDA stage flags outliers using IQR fencing, ranks the strongest feature-to-feature correlations, renders a full correlation heatmap, and closes with a natural-language summary generated by Groq — explaining data quality issues and how the dataset maps to its likely source (in this run, correctly identifying it as the Wisconsin Breast Cancer Diagnostic dataset):
3. Training Configuration (HITL Checkpoint). Before any training runs, the user is handed an interactive configuration panel to set epochs, test split, batch size, learning rate, optimizer, and regularization settings — with quick presets for fast debug runs versus deep, balanced, or overfit-test configurations:
4. Live Training Progress. Once training is launched, OmniML streams real epoch metrics back into the chat as live loss and accuracy curves, alongside a running Groq-generated observation of what's happening in the training dynamics — in this case flagging a plateau in validation loss and suggesting the learning rate may be too high for further fine-tuning:
5. Literature Comparison & Gap Analysis. Before the pipeline finalizes an architecture, an agent cross-references the task and dataset against relevant published research, summarizing methodologies from comparable papers and calling out where the current setup diverges from established approaches in the literature:
Try It Yourself
git clone https://github.com/Pritam-mb/hacktropica.git
cd hacktropica
python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
pip install -r requirements.txt
cp .env.example .env # then fill in GROQ_API_KEY, KAGGLE_USERNAME, KAGGLE_KEY, CHAINLIT_AUTH_SECRET
python start.py
Then open http://localhost:8001 and try a prompt like "Diagnose breast cancer from biopsy records" or "Detect credit card fraud from transaction telemetry." Runtime diagnostics — Groq auth status, Kaggle CLI resolution, credential checks — are available at http://localhost:8001/runtime-diagnostics if anything needs debugging.
Partner Technologies
Groq (openai/gpt-oss-120b) is the reasoning engine behind almost every intelligent decision in OmniML: generating the initial model architecture from a natural-language prompt, ranking candidate Kaggle datasets, writing deterministic training code, self-healing that code when validation fails, and generating live natural-language commentary during training (as shown in the screenshots above). What made Groq stand out for this specific project was inference latency. Because OmniML's architecture involves an LLM call at nearly every stage transition in a multi-agent LangGraph state machine, using a slower inference provider would have made the human-in-the-loop experience feel sluggish and would have broken the sense that you're interacting with a live system rather than waiting on a batch job. Groq's speed meant the architect agent could regenerate a model graph, or the debugger agent could rewrite a failing script, fast enough that the checkpoint-and-resume UX in Chainlit felt responsive rather than like a loading screen. Swapping in the openai/gpt-oss-120b model specifically gave us a good balance between reasoning quality for code generation tasks and the raw throughput Groq's hardware provides.
Chainlit is the backbone of the entire user-facing experience. Rather than building a custom frontend from scratch, we used Chainlit's message and element system to embed custom React components — the React Flow architecture editor, the EDA profiling dashboard, the training console, and the deployment dashboard — directly inside a chat interface. The interesting implementation challenge was making Chainlit's async message flow pause execution and wait on user interaction from an embedded custom element, rather than just displaying static content. We used Chainlit's action and custom-element callback system to bridge state from the frontend graph editor back into the LangGraph execution state, so a user's edits to the visual canvas actually mutate the architecture object that gets compiled downstream. Working with Chainlit's extensibility for custom JS/React elements alongside a Python-native backend was one of the more rewarding parts of the stack.
Kaggle API powers structured dataset discovery, evaluation, and automated ingest — letting the agent search, rank, and validate real-world tabular datasets against the user's problem statement without any manual dataset hunting.
PyTorch, Optuna & Scikit-Learn drive graph compilation, hyperparameter search, and model execution across both the sklearn (Path B) and PyTorch (Path A) training routes.
Hackathon Experience
We attended HackTropica on 5th April 2026 at Asansol Engineering College. The energy in the hall was electric from the moment we walked in—hundreds of developers, whiteboards filled with architecture diagrams, and a clear challenge in the air to build something truly transformative.
Building AxisVision OmniML under a tight deadline was both thrilling and intense. A pivotal part of our journey was the guidance we received from Prof. Tridib Chakraborty. His mentorship helped us sharpen our system design, pushing us to ensure our Human-in-the-Loop (HITL) workflow was seamless, robust, and genuinely useful for real-world application.
The most memorable moment was our final pipeline test. We had spent hours resolving a late-stage bug where the LLM-generated graph layout refused to bind cleanly with the Kaggle dataset streaming pipeline. After painstaking step-by-step debugging, we hit "Run"—and watched in real time as the prompt generated a complete 7-layer neural network, downloaded live data, rendered EDA metrics, and executed training end-to-end without breaking.
What I'll remember most about this event is the sheer thrill of turning a complex, multi-module AI system into a working reality in a room full of passionate builders. HackTropica was a powerful reminder of what good teamwork and dedicated mentorship can achieve under pressure.
If you find OmniML valuable, consider giving it a ⭐ on GitHub — and if you build something with it or have feedback, I'd love to hear about it.
Top comments (0)