Is this really ‘fine-tuning’ if I don’t have labeled pairs?

In the modern enterprise GenAI stack, improvement happens at multiple layers: retrieval, prompting, guardrails, and model weights. Databricks’ approach treats “fine-tuning” as part of a broader optimize-and-evaluate loop and methods like TAO can improve models using unlabeled inputs plus automated evaluation signals, without relying on classic supervised labels.

What data do I need if I’m not labeling answers?

You still need representative inputs: real user questions, typical tickets, query patterns, documents, and task instructions plus logs/traces from how users interact with your system. The “training signal” comes from evaluation (synthetic tests, judges), outcome metrics, and targeted SME feedback rather than perfect gold outputs for every example.

Does label-free tuning eliminate RAG?

No. In most enterprise use cases, the best results come from RAG + selective tuning. RAG provides grounding and freshness; label-free optimization (and targeted fine-tuning where it’s justified) improves consistency, formatting, citation behavior, and task reliability especially under ambiguity and edge cases.

How do we measure improvement without human labels?

You measure what matters for production: groundedness/citations, factual consistency vs. source, schema validity (JSON), refusal correctness, latency, and cost. Agent-based build loops typically use automated evaluation suites (including LLM judges) plus a smaller set of SME spot-checks to keep the signal honest.

When do we still need labeled data?

Labeled data is still valuable when: You need strict, auditable correctness on narrow tasks (regulated outputs), The task has a clear “right answer” (e.g., specific extraction fields), Automated judges can’t reliably score the output You are building a specialized model for a repeated high-volume workflow. The key is to label surgically after you’ve instrumented the system and identified the failure modes that actually impact business outcomes.

Label-Free LLM Fine-Tuning with Databricks AI Builder

The enterprise “labelling tax” is why most LLM pilots stall
Most organizations have plenty of data tickets, policies, call transcripts, contracts, SOPs, wikis, CRM notes but very little of what classic fine-tuning expects: clean, task-specific input → ideal output pairs curated at scale.

That gap creates the “labeling tax” that comprises of:

Weeks (or months) of SME time to create ground truth
Constant schema changes as requirements evolve
Slow iteration because evaluation itself is hard
A painful tradeoff between quality and cost in production

Databricks’ answer is a new build-and-improve loop that doesn’t start with hand labels. Instead, it starts with your unlabelled enterprise data + real usage signals, then uses automated evaluation and optimization to tune the system.

If you’re a data/AI leader, platform owner, or engineering team at an enterprise that wants better GenAI performance but doesn’t have time (or budget) to label thousands of examples, this is for you. It’s also relevant if you’ve launched a RAG pilot that “mostly works” yet still fails on edge cases hallucinations, weak citations, inconsistent extraction, or high inference costs and you’re looking for a pragmatic path to systematically improve quality using the data you already have without turning your SMEs into full-time annotators.

What Databricks “AI Builder” actually is: Agent Bricks

Databricks’ AI Builder experience is delivered through Agent Bricks, a declarative, guided way to build production AI agents from natural-language task descriptions and your enterprise data. The core idea: you describe the task, connect data, and Agent Bricks handles evaluation, optimization, and deployment workflows with built-in governance and MLflow-based measurement.

Databricks positions Agent Bricks as a streamlined way for both technical and non-technical teams to operationalize data into production-grade agents, with built-in evaluation (MLflow), governance (Unity Catalog), and model/provider flexibility (AI Gateway).

The key shift: “fine-tuning” now includes label-free optimization methods

When teams say “fine-tuning,” they often mean supervised fine-tuning (SFT) on labeled examples. Databricks expands the toolbox with methods that can improve quality without traditional labeled datasets such as:

1) Test-time Adaptive Optimization (TAO): Tune with inputs only

Databricks introduced TAO, a model tuning method designed to improve an LLM using unlabeled usage data (representative inputs) rather than human-labeled outputs. TAO uses test-time compute + reinforcement learning during the tuning phase, then produces a model that runs at normal inference cost.

Practical implication: if you can collect thousands of real prompts/questions for your task (even without perfect answers), TAO can still move the needle especially on enterprise tasks like document QA and SQL generation.

2) Synthetic evaluation + LLM judges: Create “grading” without humans labeling everything

Agent Bricks automatically generates task-specific evaluation benchmarks, which can include synthetic data and custom LLM judges, then uses those evaluations to guide optimization.

This matters because in many enterprise settings, the bottleneck isn’t training compute it’s deciding what “good” looks like. Automated judges + evaluation suites make iteration feasible.

3) Human feedback as natural language guidance (not row-by-row labeling)

Agent Bricks supports improving agent behavior based on natural language feedback from subject matter experts. This could be, for example, guiding how the system should interpret documents or which sources to prioritize without requiring SMEs to author thousands of perfect target outputs.

4) Turn unlabeled documents into structured data (which becomes training signal)

For extraction-heavy use cases, Agent Bricks can transform unlabeled text documents into a structured table of extracted fields effectively converting messy text into machine-consumable signals you can evaluate and improve.

How the label-free loop works end-to-end on Databricks

Here’s the workflow Databricks is converging on:

Step 1: Start with enterprise content (unlabeled is fine)

You can begin with raw text sources - documents, policies, contracts, notes stored and governed in Unity Catalog.

Agent Bricks includes common templates such as Knowledge Assistant (document Q&A with citations) and Information Extraction (turn documents into structured outputs).

Step 2: Build an agent from a natural-language description

Specify the problem and point to your data
Agent Bricks tries models, optimizes systems, and evaluates them
Refine continuously as it runs more methods and sweeps in the background

This is where “no labeled data” becomes real: you can start from unlabeled datasets and still produce an initial working agent and subsequently improve it iteratively.

Step 3: Instrument and log real usage (this becomes your “training set”)

To improve a system without labels, you need real prompts and production traces. Databricks uses Mosaic AI Gateway as a centralized governance and monitoring layer for model traffic, with logging into Delta tables in Unity Catalog.

Step 4: Automatically evaluate quality and cost

Databricks emphasizes that evaluation is often the hardest part of enterprise GenAI, and Agent Bricks addresses this by automatically generating evaluation datasets/judges and using MLflow-backed evaluation.

Are answers grounded and citing the right sources?
Is extraction output valid JSON and schema-consistent?
Are we improving over time or just changing behavior randomly?
Can we switch to a smaller model to cut cost without losing accuracy?

Step 5: Optimize often without supervised labels

Agent Bricks explicitly calls out that optimization can include a mix of:

Prompt engineering
Model fine-tuning
Reward models
TAO (test-adaptive optimization)

How ACI Infotech helps you operationalize label-free LLM improvement on Databricks

At ACI Infotech, we help enterprises move from GenAI experimentation to production on the Databricks Lakehouse without getting stuck in the labeling trap. Our teams design and implement end-to-end workflows that combine governed data foundations, evaluation-driven iteration, and cost-aware optimization so you can improve LLM performance using the data you already generate.

What we deliver:

Agent + RAG architecture on Databricks
Observability & evaluation
Data governance & security
Optimization playbooks
Production hardening

If you’re running Databricks and want a practical path to higher accuracy, lower cost, and faster iteration without months of manual labelling, ACI can help you stand it up and scale it.

Want to apply this to your Databricks environment?

If you’re trying to move from “demo” to production GenAI on Databricks especially with messy, unlabeled enterprise data, the winning approach is usually the following: