ML agents that run locally: MLExpert and EpochGo on Ollama, zero API costs

An ML agent is a model that drives the whole data science loop by itself: it cleans the data, tries dozens of models, tunes the hyperparameters and prepares the serving stack. This month, two releases show the two poles of the same story: on one end MLExpert, a frontier 35-billion-parameter model trained to do it autonomously; on the other EpochGo, an open-source platform that runs three coordinated agents on a 16 GB RAM machine, at zero API cost. The first shows what is possible; the second installs today.

MLExpert: the frontier proves ML agents work

MLExpert is an October 2026 paper that trains a 35-billion-parameter Mixture-of-Experts model to run whole machine-learning engineering sessions on its own. It does not assist: it proposes the experiment, runs it, reads the result, adapts the strategy. The training combines two techniques — hierarchical supervision over interaction trajectories, and a reinforcement-learning method called WIRL that assigns one shared reward to the decisions taken between one experiment result and the next.

The number that matters: on MLE-Bench Lite, the average medal rate goes from 37.9% for the base model to 72.7% — a level comparable to much larger frontier models such as Kimi-K3 or GLM-5.3. It is the proof that a 35B model, trained well, can hold a long, expensive decision process without losing the thread. The paper ships no local runtime: it is a research frontier, and it should be read as one — the evidence that the field is mature enough to start bringing it to your own hardware.

EpochGo: the same approach on 16 GB, at zero API cost

EpochGo is the other end of the spectrum: an open-source, local-first AutoML platform that runs on your machine. Under the hood: CrewAI, Ollama, scikit-learn, XGBoost, LightGBM and CatBoost. No API keys, no cloud, everything local.

You drop a CSV into the dashboard and three agents split the work:

• Agent 1 — preprocessing: detects missing values, outliers, encodes categoricals, reduces dimensionality. It produces a standalone script and a before/after report.
• Agent 2 — benchmarking and tuning: compares 7 baseline algorithms (XGBoost, LightGBM, CatBoost, Random Forest, Gradient Boosting, Extra Trees, linear regressions), selects the top 3, optimizes the hyperparameters and picks the champion model, with a reproducible training script.
• Agent 3 — serving: generates a production-ready FastAPI microservice, with a playground in the browser to test predictions and ready-to-paste curl and Python snippets.

Every project saves everything under projects/: scripts, Markdown reports, serialized model. No data, prompt or prediction ever leaves the machine — the detail that matters when the CSV contains real customers.

The costs: API vs local, with the math

Let's do the math on a typical project. The full pipeline — profiling, benchmarking 7 models, tuning, serving code — produces, in total, an order of magnitude of 1 million tokens of agent prompts and output.

Path	Calculation	Cost per project
Paid API	~1M tokens at ~2.50 EUR per M tokens	~2.50 EUR
Local with EpochGo	7B model (~4.7 GB RAM), training on your CPU or GPU	0 EUR in API

These are orders of magnitude: they depend on current prices and on how much tuning you ask for. But the structure is clear — 40 projects a year cost about 100 EUR of API, or zero: the 7B model driving the agents takes ~4.7 GB of RAM, and a 16 GB Mac or an equivalent PC leaves more than 10 GB free for the actual training. At these numbers the cost gap is modest; the real difference is that customer data never leaves the machine.

And the limits?

Let's be clear about what these agents are NOT:

• Tabular data only. The angle is CSV: classification, regression, training and serving. It is not RAG over your documents and not a vision agent: for documents, the path is another one, and it is in the local RAG guide.
• The generated code gets read. The language model writes real Python, which sometimes has bugs. The preprocessing.py, model_building.py and serve.py scripts deserve a review before deployment, like any code that comes from somewhere else.
• The model's quality sets the pipeline's quality. With qwen2.5-coder:7b the level is good for classical data science; with the 1.5B or 3B fallbacks (for 8 GB machines) it drops.

Minimal setup in 10 minutes

Requirement	Value
RAM	16 GB recommended (8 GB with the reduced models)
Driver model	qwen2.5-coder:7b (~4.7 GB RAM)
Stack	Docker Compose + Ollama

1. Install Ollama and pull the driver model:

   ollama pull qwen2.5-coder:7b
   

2. Clone and start EpochGo:

   git clone https://github.com/AryanDinakaran/EpochGo.git
   cd EpochGo
   docker compose up --build
   

   If it does not start, check that ollama serve is running: the compose file connects to Ollama on its own, but only if the server is already listening.
3. Open the dashboard at http://localhost:8000, upload a CSV — two are ready in sample_data/ (customer churn and house prices) — and watch the three agents work, step by step, in the live log.

Sources

• MLExpert: Towards a Generalist Agentic Model for Autonomous Machine Learning Engineering — arXiv, October 15, 2026
• EpochGo — README and specs, MIT license

In summary

Two releases, two poles of the same story. MLExpert proves that a 35B model, trained the right way, does machine-learning engineering at frontier level. EpochGo brings the same approach — three coordinated agents that clean the data, benchmark and prepare serving — to a 16 GB RAM machine, at zero API cost and with data that never leaves the machine. One is the proof that the field is mature; the other is the starting point to try it locally today.

Article generated with AI