01/Upload
Documents, a chat-format dataset, or traffic captured from a model already in use.
Language model workbench
Experiment with language models,
end to end.
Fine-tune or distill an open model on your data, prove it beat the base, then serve it or take the weights home.
How it works
From raw data to a model you can run
Six stages. Run one, or the whole path.
02/Parse
Text extracted and chunked. A golden holdout is set aside that nothing ever trains on.
03/Generate
Draft a sample, rate it, refine the guidance, then write the full training set.
04/Train
LoRA or QLoRA on an open model. A quick run, or iterative, aligned, and reasoning runs.
05/Evaluate
Tuned and base scored on the same held-out data. A deploy can wait for the result.
06/Deploy
An OpenAI-compatible endpoint, or adapters and GGUF builds for your own hardware.
Capabilities
The parts you'd otherwise assemble yourself
Training, data review, evaluation, serving, and export in one place, so an experiment doesn't become an infrastructure project.
01/Runs
Managed training runs.
GPU scheduling, checkpoints, retries, and live metrics, so a long run surviving a restart isn't your problem.
02/Data
Data curation in the loop.
Generate examples, then keep, edit, or reject them. Training data stays something you reviewed, not something you hope is fine.
03/Evaluation
Evaluation and comparison.
Held-out splits, judge-based scoring, and side-by-side comparison against the base model before anything ships.
04/Inference
OpenAI-compatible inference.
Point an existing client at a new base URL. Your tuned model answers the same request shape you already send.
05/Export
Export and self-host.
Download adapters or GGUF builds and run them on your own hardware, a laptop, or an edge device. No lock-in.
06/Lineage
Reproducible by default.
Every run keeps its dataset version, configuration, and metrics, so a result you liked can be found and repeated.
Distillation
A small model can inherit behaviour from a large one.
Capture how a larger model handles your task, then train a small open model on that behaviour instead of writing every example by hand.
Teacher and student are then scored on the same held-out tasks, so how much of the quality carried over is a number, not a feeling.
Transfer map
Large modelSmall model
TransferringTraining
See training as it happens.
Runs are scheduled on GPUs, checkpointed as they go, and stream step, loss, learning rate, and throughput while they are still running.
A run that stalls or a loss that stops falling is visible in minutes, not after the bill.
Run monitor
Training lossHeld-out loss
StreamingEvaluation
The comparison that matters is against the model you started with.
Every tuned model is scored on a split held back before training began, side by side with the base model on that same split.
The unflattering result is visible too. A run that changed nothing, or made things worse, looks exactly like what it is.
Held-out scores
Base modelTuned model
ScoringExperiments
Things worth trying
Common starting points rather than a fixed menu. The pipeline is the same whichever direction you take.
Teach a small model one job well
Take an open model in the 1B–8B range and tune it on a single narrow task until it's dependable at that task specifically.
Move behaviour from large to small
Capture how a larger model handles your task, train a smaller one on that behaviour, and measure how much of the quality survived.
Tune on preferences and rewards
Go past supervised tuning with preference and reinforcement methods, for the cases that are hard to write down as plain examples.
Make output shape reliable
Tune for structured output and tool calls, then verify the format holds across a held-out set instead of trusting a few spot checks.
Notes
Notes from the workbench
SFT, DPO, GRPO: what the post-training alphabet means
The three letters behind every fine-tuning product, explained by what each one actually teaches a model: imitation, preference, and trial-and-error.
How to know your fine-tuned model is any good
A falling loss curve proves almost nothing. What real evaluation of a fine-tuned model looks like: held-out data, judges and their biases, and the comparison that actually matters.
Where fine-tuning data actually comes from
Nobody hand-writes ten thousand training examples. How synthetic data generation works, why diversity is the hard part, and where humans still belong in the loop.
FAQ
Frequently asked questions
What is Ekcron?
A workbench for language model experiments. It covers the path from raw data to a tuned model you can call or download: dataset preparation, fine-tuning and distillation, evaluation, and deployment or export.
Do I need machine learning experience?
You need to know your task and your data. The pipeline ships with defaults that produce a reasonable run, and the knobs are there once you want to change them.
Which models can I work with?
Open-weight models, tuned with QLoRA or LoRA by default, with full fine-tuning available when adapters aren't enough. Small and mid-size models are the focus, because they are the ones you can afford to iterate on and realistically self-host.
How do I know a run actually improved something?
A split is held back before training and never trained on. The tuned model and the base model are then scored against it and compared, so a run that didn't help shows up as a run that didn't help.
Can I run the model myself?
Yes. Adapters and GGUF builds can be exported and run on your own infrastructure, a laptop, or an edge device. Serving it here is a convenience, not a requirement.
Start with one small run
Bring a dataset, tune a small open model, and read the scorecard against its base. The fastest way to judge whether this fits your task is to run it once.
