AutoScientist is the first system that automates the full research loop behind model training and alignment. You set the outcome. AutoScientist co-optimizes your data and training recipes, until the model converges on your goal, outperforming human-configured training by up to 35% relative improvement. The loop searches training recipes, optimizes your data, trains, and evaluates, cycling through all four until quality converges on the objective you set.
Until now, all of that lived behind a UI. Today, we're bringing it to code.
The AutoScientist API and SDK gives developers programmatic access to the full research loop. Everything the system does, your code can now trigger, monitor, and build on. Define the outcome in a config, launch the run, and get back a trained model, whether you run it once from a notebook or a hundred times from a pipeline.
How the AutoScientist API Works
Point it at a dataset, give it a target, and get back trained weights. Here's the whole path in code:
from adaption import Adaption
client = Adaption(api_key=ADAPTION_API_KEY)
dataset = client.datasets.upload_file("alpaca.parquet")
adaptive_data_run = client.datasets.run(
dataset.dataset_id,
column_mapping={
"prompt": "instruction",
"completion": "output",
}
)
client.datasets.wait_for_completion(dataset.dataset_id)
run = client.autoscientist.create(
dataset_id=dataset.dataset_id,
)
Simple
Getting from raw data to a custom model takes a few API calls.
Upload your data with upload_file, turn it into a training dataset with datasets.run, then start AutoScientist with autoscientist.create. You give it a target win rate, and AutoScientist searches for the training recipe that gets there. It stops when it hits your target or exhausts the iteration budget.
Before training, the adapt step automatically rewrites and expands your dataset into a richer training set. Every iteration is trained and evaluated in place, so there's no cluster to manage, no checkpoints to shuffle around, and no separate evaluation pipeline to wire together. When the run finishes, the weights are yours to download and deploy anywhere.
Flexible
AutoScientist chooses the model and training recipe by default. If you want more control, pick a model from training_models.list() or tweak one of the hyperparameters. The registry spans sub-billion to frontier-scale models, so you can start small and scale up without changing your workflow.
Composable
Everything is exposed through the API/SDK, so AutoScientist fits naturally into existing systems.
You can retrain automatically when your data changes, kick off a run after detecting a new edge case, or plug training directly into the pipelines you already operate. Instead of retraining every few months, your models can keep improving as your environment changes. Idempotency keys make retries safe, and the async client makes it easy to launch many runs in parallel.
Whether a run starts from code or from the UI, it's the same run. Start training from your application and watch progress live in the AutoScientist dashboard, or launch it from the dashboard and monitor it through the API. Results, evaluations, and iteration history stay in sync automatically because both interfaces are simply different views of the same underlying run.
Get Started
Create an API key, point a run at your data, and judge the result against your own baseline. The docs take you from key to converged model without leaving your editor.
Join the Adaption community on Discord to connect with other builders.
Author
Sudip Roy, Co-founderDate