Agile Deliberation: Teaching AI Where the Border Really Is

Posted on by
Contents show
Agile Deliberation

Ask a team to build a classifier for healthy food and the meeting stalls at the first question: what counts as healthy? A grain bowl, certainly. A salad with heavy mayo dressing, maybe. A diet soda, probably not. Everyone has an opinion and no two opinions agree, because the concept has no fixed boundary, and that is exactly the problem Agile Deliberation was built to solve. The usual tooling makes this worse by assuming the boundary already exists, handing the team a labeling interface, and quietly encoding whatever inconsistency the first hundred labels happen to contain.

Google Research has released Agile Deliberation, an open-source human-in-the-loop framework that starts from the opposite assumption, treats finding the boundary as the actual product, and ships it with a notebook and an Apache 2.0 license. The gap it targets is the space between what a team says a concept means and what its labels quietly reveal. It treats a subjective concept as something to be discovered rather than defined, and it structures the discovery: breaking the concept into pieces, surfacing borderline images that expose disagreements, and turning the user's reactions into a written definition that is both a human-readable policy and the prompt for a vision classifier.

The evaluation of Agile Deliberation is small but unusual in its honesty, which suits a framework whose claims are about process rather than leaderboard position. Across 18 live sessions, classifiers built with Agile Deliberation scored 10.5 F1 points above zero-shot prompting on average. This article explains how Agile Deliberation works in its two stages, why it abandoned the standard active-learning trick, what its numbers do and do not establish, and who should actually run it.

The problem: definitions that do not exist yet

Objective concepts have ground truth, and the tooling built around them works. Subjective concepts defeat Agile Deliberation's less: they have no ground truth at all, and the same tooling quietly fails.

The distinction is easiest to see in content moderation. Clickbait, a post that is paid to play, healthy food, inspiring artwork: each is a policy judgment that varies by platform, audience and moment. When a team labels examples of such a concept, the labels encode individual intuitions that were never reconciled. A classifier trained on those labels learns the inconsistency perfectly and reproduces it at scale. Agile Deliberation starts from the diagnosis that the failure is not in the model; it is in the fiction that the boundary was known before labeling began.

The design of Agile Deliberation came from interviews with content moderation experts, and their real workflow shaped the whole system. Experts scope a concept first, naming what it includes and excludes, and then refine it on borderline images. The refinement is where the real definition emerges. The slow part, the part everyone avoided, was finding the borderline images in the first place. A haystack of a hundred million images does not volunteer its ambiguous middle.

That reframing, from labeling support to boundary discovery, is what separates Agile Deliberation from the labeling tools around it.

Stage 1: scoping before sorting

The first stage uses prompt chaining with Gemini 2.5 Pro to break a vague concept into at most 3 unit concepts. For healthy food, the decomposition might yield nutrition, processing level and preparation state. Each unit concept then receives candidate positive and negative subconcepts, presented alongside retrieved images: salads and grain bowls as candidate positives, processed food and raw unprepared ingredients as candidate negatives.

The user's role is editorial and cheap. They keep, flip or drop each subconcept, with the retrieved images making the consequences concrete. A subconcept that sounded reasonable in the abstract, clean eating as a positive, can be flipped in seconds once the images show what it would include.

Scoping matters because Agile Deliberation front-loads the disagreements. In a traditional labeling session, the disagreement surfaces one image at a time, buried in a queue, and the annotator resolves it privately with a click. In this stage, the disagreement surfaces as a named candidate concept with example images, and resolving it produces a decision that shapes every later label. The user is no longer annotating a boundary; they are negotiating one, with a system that presents the negotiation in manageable pieces.

Agile Deliberation stage 2: finding images that argue with you

The second stage of Agile Deliberation is the more interesting engineering, because it solves a problem that standard active learning cannot touch.

Classic active learning selects images where the classifier is uncertain. That works when the classifier produces calibrated confidence scores. Agile Deliberation's classifier is a prompted generative model, Gemini 2.5 Flash, and prompted models have no reliable notion of confidence; their uncertainty is rhetoric. Selecting on it would select on noise.

Agile Deliberation substitutes semantic uncertainty for statistical uncertainty. The Agile Deliberation pipeline runs four steps. Gemini 2.5 Flash writes borderline queries, phrases like salads with heavy mayo dressings, and each query retrieves 50 to 100 images from a CLIP-embedded index. Retrieved images are de-duplicated, encoded and grouped into clusters using dictionary learning, so each cluster shares one ambiguity. A UCB multi-armed bandit chooses the next cluster to show, favoring clusters where the user corrected the model or left rich feedback. Finally, a vision model summarizes each image in one sentence, and the user sees at least 5 images that share a single ambiguity.

The user labels those borderline images and leaves short notes on disagreements. A language model turns the notes into candidate rewrites of the working definition, and a greedy update keeps whichever candidate scores best on the user's own labels. The definition improves the classifier, the improved classifier surfaces better queries, and the loop tightens around the true boundary.

The substitution deserves emphasis. In Agile Deliberation, asking where is the model unsure and asking where is the concept ambiguous are different questions, and for subjective concepts only the second one has a useful answer. Hunting borderline meaning rather than borderline confidence is the release's central technical idea.

One loop, traced

A concrete pass through the system shows where the value concentrates, so consider a moderation team defining paid to play clickbait, content that pretends to be organic discussion while promoting a sponsor.

Scoping first. In the Agile Deliberation notebook, Gemini 2.5 Pro decomposes the concept into three unit candidates: undisclosed sponsorship, exaggerated claims, and engagement bait through manufactured conflict. The team keeps undisclosed sponsorship, drops manufactured conflict because their policy treats it as a separate violation, and flips exaggerated claims from positive to negative after seeing the example images. Ten minutes of decisions, and the working definition already reflects the team's actual policy rather than a generic reading of the phrase.

The loop then starts hunting. The model writes borderline queries: sponsored reviews that begin with a disclaimer, unboxing videos with a paid partnership buried past the midpoint, gift guides without disclosure labels. Each retrieves candidates from the index, the clusters are ranked by where the user corrected the model before, and the user sees five images sharing one ambiguity: a review that mentions a brand once, with no disclosure anywhere. Is it paid to play?

The user labels the five images and types a note: disclosure in a caption comment does not count if the video itself has none. The language model turns that note into a candidate definition clause, the greedy update tests it against every label so far, and the clause survives. The next round of queries targets exactly the gray zone that clause drew, and the boundary tightens.

Forty-five minutes of that. The output is a classifier and a written definition whose clauses trace back to specific disagreements, which is what makes the definition auditable by someone who was not in the session.

What the evaluation shows, and its ceiling

Subjective concepts defeat static benchmarks, since there is no ground truth to score against, so the team ran 18 live sessions of about 90 minutes each: 9 participants without professional moderation experience, 2 sessions apiece, one with Agile Deliberation and one with manual deliberation. Each participant spent about 45 minutes defining a concept and then labeled 200 held-out test images.

The two concepts were paid to play clickbait and healthy food. On paid to play, F1 rose from 0.48 zero-shot to 0.59, with precision jumping 22 points from 0.35 to 0.57. On healthy food, it rose from 0.48 to 0.58. Ablations showed the pipeline's parts pulling their weight: dropping the borderline-image stage or the definition optimization stage each cost several F1 points, and the full system beat both zero-shot prompting and the team's earlier CVPR 2024 approach, which used roughly 100 labels and chat but no evolving definition.

The precision-recall trade is the Agile Deliberation finding to read carefully. On paid to play, recall fell 17 points, from 0.80 to 0.63, while precision rose 22. On healthy food it fell 15 points. The deliberated classifier catches less of the fuzzy positive space and is far more reliable about what it does catch. For content moderation, where a false positive removes legitimate content and a false negative lets borderline content through, that trade direction is usually the right one, but it is a choice, not a free win, and teams with recall-sensitive use cases should look at the table twice.

The evaluation ceiling is honest about itself: 2 concepts, 9 novices, 200 test images each. The participants were not professional moderators, which tests the tooling for its intended audience but leaves open how experts would fare, and 2 concepts is a sample of the subjective-concept space, not a survey of it. The 10.5-point average gain is a promising result on a small base, and the framework's own benchmark transparency, live sessions instead of a static suite, is the right kind for this problem class even though it caps generalizability.

How it compares with its own lineage

Agile Deliberation is the third entry in a research line, and the differences map the design space.

Agile Modeling, from ICCV 2023, put the user in a real-time labeling loop and showed that under 30 minutes of effort could meaningfully shape a classifier. It treated the concept as fixed and the labels as the input. Modeling Collaborator, from CVPR 2024, brought a language model into the loop: an agent decomposed the concept and auto-labeled data, cutting the label requirement from about 2,000 to about 100. It accelerated labeling but froze the definition once the session ended.

Agile Deliberation changes the thing that evolves. Instead of optimizing labels, it optimizes the definition, and the classifier is simply the prompted model reading that definition. That is why it supports definitions that change mid-process, why it needs no distilled artifact, and why its output doubles as policy documentation. On the two evaluation concepts it scored 0.59 and 0.58 F1 against 0.53 and 0.50 for Modeling Collaborator, on comparable human effort.

The comparison also clarifies the trade. Agile Deliberation's classifier is a prompted frontier model at inference time, which costs more per classification than a distilled lightweight model and depends on an API. Teams classifying at very high volume may still prefer the older pattern: use deliberation to write the definition, then distill a cheap model against it. The framework and the distillation path are complements, not competitors, and the released code leaves that combination open.

Where the loop can go wrong

Every human-in-the-loop system inherits its humans, and Agile Deliberation has failure modes that the paper's F1 table does not capture.

The definition can collapse to the loudest annotator. The framework optimizes against one user's labels, so a single session encodes one person's boundary. For a team deploying the result as shared policy, that is a feature only if the right person is in the chair, and organizations should treat participant selection as part of the method rather than an implementation detail.

The written definition can ossify. The whole point is an evolving boundary, but a policy artifact that took 45 minutes to produce acquires authority, and teams will hesitate to reopen it when the concept drifts, which subjective concepts do. The framework supports re-deliberation technically; nothing but discipline forces it.

The borderline hunting depends on retrieval coverage. If the index lacks images from a region of the concept space the team has not thought about, the loop cannot surface disagreements there, and the boundary will be quietly wrong in exactly the places nobody looked. The 13 GB full index mitigates this for the demo distribution, but a specialized domain with sparse web coverage starts from a blinder.

And the classifier inherits prompt sensitivity. A prompted model reading a definition can be sensitive to phrasing in ways a trained model is not, so the same definition reworded may classify differently. Teams should freeze and version definitions the way they version code, because in this framework, the definition is the code.

Running it, and where it fits

The Agile Deliberation code is open under Apache 2.0 with a demo notebook that walks through the healthy food example. Requirements are a Gemini API key, defaults of Gemini 2.5 Pro for scoping and Gemini 2.5 Flash for classification, and a FAISS index built over CLIP embeddings; the demo index starts around 260 MB, with the full 100-shard index around 13 GB. Retrieval runs on CPU or GPU, and nothing is fine-tuned, which keeps iteration cheap: a new concept costs a notebook session, not a training run.

The natural fits for Agile Deliberation are the places where a policy and a classifier need to agree. Content moderation platforms defining what counts as a violation. Brand safety teams deciding what their ads should not appear beside. Research data curation, where a corpus boundary is a judgment call. Internal compliance tooling, where the definition needs to be auditable precisely because it is subjective. In each case the written definition that falls out of the process is as valuable as the classifier, since it becomes the artifact the team debates, updates and re-deploys, and the framework's support for evolving definitions means the debate has a home.

What Agile Deliberation does not replace is large-scale objective labeling, hard science filtering, or any concept with a real ground truth. Those have mature tooling already. This is for the boundary disputes, and it is the first open framework that treats finding the dispute as the actual job.

That framing connects to the broader question this site keeps returning to: as agents take on judgment-shaped work, the bottleneck is not model capability but the specification of what is correct, the same conclusion reached from the deployment side in our piece on agent grounding. The evaluation-honesty theme recurs across recent releases we have covered, from ZHA's modeled-versus-measured split to Droid 1.0's cost-per-passed-task framing, and Agile Deliberation contributes the data-side version: when ground truth does not exist, measure agreement, not accuracy.

Questions teams will ask

Does Agile Deliberation need training or fine-tuning?

No. The classifier is Gemini 2.5 Flash reading a written definition, the scoping runs on Gemini 2.5 Pro, and nothing is fine-tuned. A new concept costs a notebook session and roughly 45 minutes of labeling, not a training run, which is what makes iterating on definitions practical.

What hardware does the retrieval index require?

Retrieval uses CLIP embeddings with a FAISS index and runs on CPU or GPU. The demo index is about 260 MB across 2 shards of the LAION-400M embeddings; the full 100 shards occupy about 13 GB. Teams should plan disk, not accelerators.

Does it work for concepts other than image classification?

The released framework and its evaluation are image-only. The mechanism, borderline surfacing plus definition optimization, is conceptually portable to text and audio, but nothing in the repository supports those modalities yet, and claims beyond images would be speculation.

Sources
Subscription Form