Prompt optimization
Works when behavior is close and needs steering — tone, structure, emphasis.
Fails when the model lacks knowledge or the change must survive adversarial input.
Engine looks for failure patterns that vary with instruction wording.
AI Optimization Intelligence
Stop guessing how to improve your model.
Finetunio turns intent into a ranked optimization plan across prompts, RAG, fine‑tuning, tools, and guardrails — with clear reasoning for what to try first, and when not to fine-tune.
Local-first · deterministic decision engine · files as source of truth
finetunio · strategy
static simulation of real engine rules
Diagnosis
The problem
Fine-tuning is usually the wrong first question.
Model behavior has five levers, but most tooling only sells one. So teams jump to training jobs, guess hyperparameters, spend compute — and get unclear gains.
Without a decision layer
- Pick a base model on vibes
- learning_rate = 2e-4 …probably?
- lora_rank = 16 …someone said 16
- Burn a GPU budget on a run
- Eyeball outputs, shrug, retrain
Expensive guesswork, unclear gains
With Finetunio
- State the behavior you want changed
- Engine diagnoses the problem class
- Five interventions scored & ranked
- Composed plan, with tradeoffs on paper
- Fine-tune only when evidence says so
Cheapest reliable path to behavior change
The category
Training tools execute. Finetunio decides.
Between your business outcome and the execution layer sits a decision nobody's tooling owns: which combination of interventions will actually change model behavior? That layer is AI Optimization Intelligence.
Business outcome
AI Optimization Intelligence
Finetunio
Execution & workflow tools
Training & inference infrastructure
Foundation models
The Optimization Plan
One artifact that justifies itself.
The Decision Engine's output isn't a config file — it's a ranked, composed, justified plan. Swap the goal and watch the reasoning change.
Diagnosis
Demo plans are a static simulation mirroring the real engine's documented rules — matrix scoring, risk penalty, budget hard gate, dataset-size modifier. The shipped engine is deterministic and covered by 122 tests.
The five interventions
Fine-tuning is one lever. Finetunio reasons across all five.
Retrieval / RAG
Works when the model is missing facts it could quote from your corpus.
Fails when the problem is style or procedure, not knowledge.
Engine looks for unsupported claims and answers that go stale with your data.
Fine-tuning
Works when a consistent behavioral change has enough clean examples behind it.
Fails when data is thin, budget is tight, or the change is really missing context.
Engine looks for dataset size, budget floor, and risk tolerance before it will rank this high.
Tool use / MCP skills
Works when the task decomposes into checkable steps or external actions.
Fails when the behavior is judgment inside a single response.
Engine looks for multi-step failures where intermediate state gets lost.
Guardrails / post-processing
Works when violations are detectable — schemas, policies, formats.
Fails when "wrong" can't be checked deterministically.
Engine looks for output-contract failures where validation beats probability.
…and it composes them
Real plans are rarely one lever. The engine returns up to four steps, ordered by fit score — often RAG first, prompt second, fine-tuning as a justified escalation.
Intent-first
You describe behavior. The engine handles the rest.
Hyperparameters are an implementation detail of one intervention. Finetunio asks the questions the person who owns the outcome can actually answer.
- learning_rate
- How strongly should the model adapt?
- lora_rank
- How much consistency vs. flexibility do you need?
- epochs
- How much risk is acceptable?
- eval_metric
- What behavior should improve?
ML-engineer optional, not ML-engineer hostile: every simple answer expands into the full technical detail one layer down.
The product
Seven stages, one spine — and an honest status for each.
Finetunio v0.1 is a working local workbench: you can walk a project from intent to deployment today. Here's exactly what's real, what's simulated, and what's next.
-
Built
Intent
Goals, risk, budget, time — captured as structured intent.
-
Built
Strategy
Decision Engine: diagnosis, ranked plan, whyNotFineTune.
-
Built
Datasets
CRUD, threshold warnings, quality badges.
-
Built · linear
Workflow
Strategy, model & adapter selection. Multi-branch canvas is next.
-
Simulated today
Runs
Run tracking is real; training execution is simulated in v0.1.
-
Coming next
Evaluation
Leaderboard & charts today; evaluation intelligence is Phase 1.
-
Built
Deployment
Deployment records with full status lifecycle; remote targets later.
Architecture
Inspectable. Local-first. Built for trust.
Advice you can't audit is marketing. The decision layer is deterministic, and the whole system is built so you can check its work.
Rules-based engine
Matrix scoring across goal → problem class → intervention. No LLM in the critical decision path.
122 / 122 tests
The Decision Engine is fully covered and deterministic: same intent in, same plan out.
Files as source of truth
Every entity is Markdown + YAML on your disk. Readable, diffable, yours.
SQLite as rebuildable index
Delete the database, restart, get identical state. The index is derived, never authoritative.
Archive, never delete
Atomic temp-then-rename writes; nothing is destroyed, everything has history.
Headless core
Fastify 5 API with a Vue 3 client as one consumer — the core is client-agnostic.
Where this goes · roadmap
The goal isn't one good training run. It's a system that learns.
The next phase closes the loop: evaluation results feed back into diagnosis, the plan revises itself, and every project builds optimization memory.
Plan
Execute
Evaluate
Diagnose
Revise plan
Status: in progress — evaluation intelligence is Phase 1 of the reconciled roadmap.
The thesis is simple: decide first, then spend compute.
Finetunio is early — a v0.1 local workbench with a real decision engine at its core. If you own model quality and are tired of guessing, follow along.
Local alpha is invite-only while the evaluation loop lands.