# Farka documentation
Farka is a managed fine-tuning control plane for specialized language models.
It validates customer data, calculates an evidence-backed quote, reserves compute
credits, launches an approved provider workflow, compares base and tuned model
quality, reconciles provider usage, and unlocks the selected delivery artifact.
Production access is open. Create a workspace at .
## First run
1. Upload or import a training dataset and an independent evaluation holdout.
2. Select a catalog model.
3. Keep the recommended method and automatic accelerator choice for the first estimate.
4. After signing in, open the quote estimator at
and review the workload-specific total.
Calculating it does not reserve credits or start compute.
5. Reserve credits and start training.
6. Review paired base-versus-tuned evidence.
7. Export the artifact selected in the quote.
## Dataset contract
Farka accepts structured JSONL, JSON, CSV, GZ, text documents, agent traces,
and process specifications. Paid runs require a separately profiled, non-empty
evaluation holdout. Invalid or unsafe rows block the quote.
Prompt-completion JSONL:
```json
{"prompt":"Question or task","completion":"Expected response"}
{"prompt":"Another input","completion":"Another target"}
```
Training and evaluation examples should be disjoint. Farka records row counts,
token estimates, bytes, schema, split evidence, and content checksums.
## Pricing and spend boundary
Farka does not publish one generic price per model because the model name is
only one cost input. Each estimate combines:
- estimated aggregate GPU hours and a pinned compatible accelerator rate;
- profiled dataset and holdout size;
- training objective, method, epochs, and GPU count;
- storage and the selected retention window;
- evaluation, retrieval or reward checks, and platform operating cost;
- the selected weights or deployment-bundle delivery fee; and
- the software margin shown in the quote, which scales with training volume so a
small run is not priced like a large one.
**Your first eligible run is $5.** A supervised LoRA or QLoRA run of up to 1,000
rows, 1,024 tokens per row, one epoch, and a model up to 2B parameters, delivered
as adapter weights on one accelerator with no retention, is priced at a flat five
dollars. The quote also verifies that current serving cost fits the offer. One
started trial per workspace; estimates and unlaunched jobs do not consume it.
**Improving a model costs less than training a new one.** A continuation pays a
reduced delivery fee, because it updates a model whose delivery you already
bought.
The sequence is explicit:
1. **Estimate — no charge.** Validate fit and pin the complete cost breakdown.
2. **Fund — prepaid credits.** Buy only the missing workspace balance through Stripe.
3. **Launch — spend begins.** Reserve the quoted credits and provision compute.
Successful provider usage is reconciled against the reservation. Available
credits cover measured overage before artifacts unlock; an unpaid balance keeps
delivery locked. After workspace access and sign-in, open the estimator at
or review workspace credits at
.
## Run lifecycle
`estimate → awaiting credits → queued → running → evaluating → ready`
A quote pins the model, dataset, accelerator rate evidence, training method, export
target, retention, and cost policy. Launch reserves credits. Failure or
cancellation before successful settlement releases the reservation. When a job
reaches `ready`, Farka emails the verified submitter or workspace owner.
## Quality and delivery
Artifact creation is not promotion. Farka compares the untouched base model and
the tuned model — or, for a continuation, the predecessor model — on the same
unseen holdout. A regressed or malformed run remains visible for review, but
delivery stays locked.
Quotes show target-specific fees for direct weights and deployment bundles.
Bundles include TypeScript/Python clients plus native and OpenAI-compatible
inference routes that run in your environment. Farka-managed hosted endpoints
are not offered in the current launch.
## Improve a model
Open a dataset lineage on the first upload, then add each later version to the
same lineage. The lineage freezes the holdout by row content, so new rows never
move an existing row across the train/holdout boundary and two iterations are
measured on the same terms. Re-uploading content the lineage already holds
returns that version instead of creating a new one.
Train the next iteration from the delivered model rather than the untouched base
weights. The run warm-starts from that adapter, and its reported change is
measured against the predecessor: it answers whether this round helped. The
cumulative change is measured from the first iteration's baseline, which is the
comparison against the base model.
## Developer API
The stable API exposes the managed dataset, quote, job, launch, status,
evidence, usage, and artifact lifecycle. Deployment bundles provide inference
from infrastructure you operate. It is not a low-level optimizer API, an
unrestricted model catalog, or a promise of Farka-managed hosted inference.
See or .
## Public pages
- Models:
- Examples:
- API:
- Security:
- Data control:
- Processors and hosting:
- Changelog: