The whole MLOps pipeline, driven by a conversation.
There is no command line to learn and no library to install. You describe the model you need, on Tensovy managed infrastructure or your own cloud account, and the agent handles architecture, data, provisioning, smoke testing, training and export while you watch it happen.
Every example the model will learn from, visible before you train.
A dataset is only trustworthy if you can check it. The dataset tab shows each example exactly as the trainer will read it, so you can spot a bad label before it becomes a bad model.
- 0001invoice_4471.png, vendor Northline Freight, 6 line items labelledimage + json
- 0002invoice_4472.png, totals and currency EUR present in the labelimage + json
- 0003invoice_4473.png, low scan quality, one quantity field labelled blankimage + json
- 0004invoice_4474.png, multi page, 14 line items across two tablesimage + json
- 0005invoice_4475.png, handwritten annotation, not part of the labelimage + json
See what you uploaded
Every row in your CSV, JSONL, image folder or zip is listed as the trainer will read it, with the source file it came from.
Profile before you pay
The dataset profile summarises rows, columns and formats before any GPU is provisioned, so a shape problem is caught at zero cost.
Staged for the run
Datasets are staged in Tensovy object storage under your account and pushed to the GPU instance over SSH when the run starts.
Snapshot per run
The exact dataset used is stored with the finished model, so a result is always traceable to the data behind it.
Bring your own, or find one
Upload a labelled JSONL, CSV or image folder, or search Hugging Face and Kaggle from inside the workspace and import a dataset in one step.
Four tabs, and the agent driving all of them.
The agent
Where you describe the task, approve the plan and the cost estimate, and ask for changes mid project. Everything else follows from here.
Training examples
The full set of examples the model will learn from, with source files, row preview and a dataset profile.
Live run view
Loss curves, VRAM headroom, running spend, the live log tail and every fix the agent made during the smoke test.
Artifacts and registry
Every run recorded with its config, dataset and metrics, and download links for weights in standard formats.
Read the config the agent wrote, and change it if you disagree.
Tensovy does not invent a proprietary trainer. It writes a readable training package on libraries the community already maintains, shows it to you before the run starts, and stores it with the finished model.
base_model: unsloth/Qwen2.5-VL-7B-Instruct
adapter: lora
lora_r: 16
lora_alpha: 32
lora_dropout: 0.05
max_seq_length: 2048
per_device_train_batch_size: 2
gradient_accumulation_steps: 8
num_train_epochs: 3
learning_rate: 0.00014
bf16: true
gradient_checkpointing: true
save_steps: 50
dataset:
path: dataset-8fk2.jsonl
format: image_jsonEvery run lands in a registry, and the weights are yours to download.
Finished runs are recorded in your model registry with the config, dataset and metrics that produced them. You do not need a Tensovy library to use the weights. Load the safetensors adapter with the same library that trained it and any existing pipeline works. A serverless endpoint is on the roadmap.
from unsloth import FastVisionModel
model, tokenizer = FastVisionModel.from_pretrained(
"./invoice-extractor", # adapter from the registry
load_in_4bit=False,
)
FastVisionModel.for_inference(model)
inputs = tokenizer(scan, prompt, return_tensors="pt")
out = model.generate(**inputs, max_new_tokens=512)invoice-extractor/
├── train.py # entry point, --dry-run smoke test
├── config.yaml # every hyperparameter, in one place
└── trainer/
├── config.py # typed config loader
├── data.py # dataset loading and formatting
├── model.py # Unsloth model and LoRA setup
├── callbacks.py # loss, VRAM and spend telemetry
└── export.py # safetensors export to the registryYour data, your approvals, your weights.
Managed, or your own key
Run on Tensovy managed infrastructure with no cloud account to set up, or connect your own: the key is stored server side and used only for infrastructure operations, create, launch and terminate, each one approved by you.
Training where you choose
With bring your own key, the GPU instances live in your own cloud account and Tensovy only orchestrates them. On managed infrastructure Tensovy runs the GPU for you. The weights are yours either way.
Weights you can export
Artifacts are downloadable in standard formats at any point, including after you stop using Tensovy.
Spend you approve
Nothing that costs money runs on its own. Hardware plan, instance start, training launch and shutdown each wait for your approval on both routes, and an hourly price cap guards the rest.
Get into the workspace early.
Early access includes help scoping your first run and reviewing your first dataset.