self-hosted · autonomous · private

An AI agent that does
ML research for you

Train custom models on your own GPUs, with your own data, and free your company from closed-model dependency.

experiments · 4 running in parallel · day 3/6live

run-a/moe-4b-int8run-b/dense-1brun-c/moe-8b-fp16run-d/dense-3b-int4

fig. 1 · experiments running in parallel; loss curves update in real time

§ 1 · capabilities

Everything an ML team does,
running unattended

From raw data to a deploy-ready model: the agent handles the full research loop and shows its work in graphs, not vibes.

01 / data engine

Cleans, formats & synthesises data

Point it at raw, messy data: dumps, logs, exports, scraped piles. It turns them into a training-ready corpus and tells you exactly what it changed.

Profiles datasets: distributions, class balance, outliers, quality report
Deduplicates (exact & near-duplicate) and scrubs PII automatically
Converts between formats: CSV, Parquet, JSONL, images, audio
Generates synthetic examples where your data is thin, with quality filtering
Builds leakage-checked train / validation / test splits

raw/ 2.4M rows ── dedupe ──▸ 1.9M

├─ reformat ─▸ jsonl ✓

└─ synth ────▸ +340k examples

02 / experiment design

Finds the right architecture for your data

It forms hypotheses, sweeps the design space in parallel, and converges on the smallest model that nails your task within your latency and memory budget.

Searches architectures, model sizes, and quantization levels (int4 / int8 / fp16)
Runs experiments in parallel across your GPUs, with multi-GPU training per run
Multi-day runs babysat end to end: checkpoints, crash recovery, auto-resume
Kills plateaued runs early and reallocates their compute to the leaders
Live loss & eval curves for every run, streamed to the web UI in real time

architecture searchsize sweepint4 / int8 / fp16parallel runslive loss graphs

03 / gpu orchestration

Squeezes your GPUs dry

Give it the GPUs on your own infra: any mix of cards, any topology.

Packs jobs across cards so nothing sits idle
Priority-aware scheduling and preemption
Handles node failures and thermal throttling
Utilisation reports per job and per GPU

32× GPU · 3 jobs scheduled94% utilised

04 / multi-user

One agent, whole team

Everyone can file projects; the agent runs the lab.

Queues and prioritises projects across the team on its own
Negotiates compute between jobs as deadlines shift
Per-project chat threads and progress updates
Pings you when a decision actually needs a human

A fraud-detector-v2 running

S doc-summariser queued

R support-classifier running

05 / sovereignty

Your infra. Your model.

Fully self-hosted, with no closed lab between you and your product.

Runs air-gapped: no external calls, no telemetry
Weights and checkpoints live in your bucket
Full audit log of every action the agent takes
Trained models are 100% yours to ship anywhere

data → never leaves your network

weights → 100% owned by you

api keys → none required

§ 2 · the web ui

You chat. It researches.

This is what working with the agent looks like: describe a job, then watch it profile data, launch runs, kill losers, and report back for days, unattended.

https://mlresearcher.internal.acme.corp

fraud-detector-v2

day 3 of ~6 · 4 runs live

Rishabh09:14

Train a fraud-detection model on last quarter's transactions. Latency budget is 10ms on CPU.

agent09:14

Understood. I profiled s3://data/txns-q2: 41M rows, 0.3% positive class, 14 columns (2 with >8% nulls). Plan: rebalance, synthesise tail-pattern fraud examples, then sweep small dense archs under the 10ms budget.

agent09:31

Data pipeline finished: 38.6M clean rows, +340k synthetic positives (quality-filtered). Launching 4 training runs in parallel on gpu[0–15]. First loss curves in ~20 min.

Rishabh11:02

Can you also try a variant without the merchant-category feature? Compliance might make us drop it.

agent11:02

Queued as run-e. It will reuse the same splits so results stay comparable. Current leader is run-c: AUC 0.981 at 7ms/inference▍

Message the agent…⏎

fig. 2 · the agent's web UI: chat, project queue, and live cluster state

§ 3 · post-training

Don't start from scratch:
post-train open models

Training from zero isn't always the answer. Tell the agent your goal, budget, and infra, and it picks the right open-weight base model, then fine-tunes and post-trains it on your data. Same parallel experiments, same live dashboards, same ownership.

Selects the base model for you, weighing quality, licence, size, and serving cost
Supervised fine-tuning: full-parameter, LoRA, or QLoRA, sized to fit your GPUs
Reinforcement learning: GRPO, DPO, PPO, RLHF / RLAIF with your reward signal
Distils large open models into small ones you can serve cheaply
Quantization-aware finishing (int4 / int8) for your deployment target
Benchmarks the tuned model against the base on your own eval set