Inferensys

Prompt

Tie-Breaking Prompt with Explicit Criteria

A practical prompt playbook for using Tie-Breaking Prompt with Explicit Criteria in production AI workflows.
Wide-angle shot of a modern WeWork open floor plan with creative walls covered in AI system architecture diagrams, product team collaborating in standing desk area with industrial lighting.
PROMPT PLAYBOOK

When to Use This Prompt

Defines the activation conditions, required context, and operational boundaries for the tie-breaking resolver prompt.

This prompt is a secondary resolver designed for evaluation pipelines where a standard pairwise comparison judge returns a tie or a confidence score below a defined threshold. Instead of accepting a draw, it forces a structured, auditable choice by applying a configurable hierarchy of tie-breaking dimensions. The primary job-to-be-done is automated model selection, RLHF data pipeline curation, or champion-challenger promotion when your production system requires a definitive winner and cannot tolerate an undecided outcome. The ideal user is an ML engineer or evaluation platform developer who already has two candidate outputs, the original task context, and a set of weighted criteria that reflect business priorities such as safety, conciseness, or instruction adherence.

Do not use this prompt as a replacement for a primary quality judge. It is a downstream resolver that activates only when the primary judge cannot discriminate. It assumes the two outputs are already deemed comparable in overall quality. If the outputs differ significantly in obvious ways, a standard pairwise comparison prompt is more appropriate. The prompt requires you to define explicit tie-breaking dimensions with weights before invocation. For example, you might configure safety: 0.4, instruction_adherence: 0.3, conciseness: 0.2, readability: 0.1. The resolver applies these weights in sequence, documenting which dimension broke the tie and why. This design makes the decision auditable and allows you to tune the hierarchy as your product priorities evolve.

Before deploying this prompt, establish a clear activation threshold from your primary judge—such as a confidence score below 0.7 or an explicit tie verdict. Wire the resolver into your pipeline as a conditional step, not a default path. Log every tie-breaking decision with the input context, the weighted criteria used, the winning output, and the dimension that broke the tie. This audit trail is essential for detecting criterion drift, identifying cases where the hierarchy produces counterintuitive results, and recalibrating weights over time. If the resolver itself cannot break the tie after exhausting all dimensions, escalate to human review rather than forcing an arbitrary choice.

PRACTICAL GUARDRAILS

Use Case Fit

Where the Tie-Breaking Prompt with Explicit Criteria delivers value and where it introduces risk. Use this to decide if the prompt belongs in your evaluation pipeline or if you need a different approach.

01

Good Fit: Champion-Challenger Gating

Use when: You are comparing a production model against a candidate and need a forced decision when absolute scores are within a margin of error. Guardrail: Configure weights so that safety regressions always lose, even if the candidate is slightly more concise. Log every tie-break for later audit.

02

Good Fit: RLHF Data Curation

Use when: Two outputs are rated identically by an absolute rubric but you need a preference pair for DPO training. Guardrail: Apply a minimum confidence threshold. If the tie-breaker confidence is below 0.7, discard the pair rather than inject noise into your training data.

03

Bad Fit: Objective Correctness Tasks

Avoid when: The task has a verifiable correct answer, such as math, code execution, or fact retrieval. Guardrail: Route to a ground-truth evaluation harness instead. A tie-breaker prompt should never override a deterministic check. If outputs tie on a math problem, both are likely wrong.

04

Required Inputs: Weighted Criteria Schema

Risk: Without explicit, ordered criteria, the model defaults to stylistic preference or position bias. Guardrail: Provide a strict JSON schema of weighted dimensions such as safety: 0.4, instruction_adherence: 0.3, conciseness: 0.2. Validate that weights sum to 1.0 before calling the prompt.

05

Operational Risk: Position Bias Amplification

Risk: When two outputs are genuinely equal, the model may fabricate a distinction based on presentation order. Guardrail: Run every comparison twice with swapped positions. If the verdict flips, escalate to a human reviewer or log as a true tie. Do not ship a single-pass tie-breaker into production.

06

Operational Risk: Weight Drift Over Time

Risk: Business priorities change, but old weights persist in production, silently skewing decisions. Guardrail: Version your weight configurations alongside your prompt. Run a weekly calibration check against a fixed set of known-tie pairs to detect unintended preference shifts.

PROMPT PLAYBOOK

Copy-Ready Prompt Template

A reusable tie-breaking prompt with configurable weighted criteria, designed to be invoked as a secondary judge when a primary pairwise comparison returns a tie or low-confidence result.

This template acts as a forced-choice arbiter. It should only be invoked after a primary comparison prompt has returned a tie or a confidence score below your operational threshold. The prompt is designed to break the deadlock by applying explicit, weighted criteria that reflect your production priorities—such as safety, instruction adherence, or conciseness—rather than asking for a general preference. The square-bracket placeholders allow you to inject the two tied outputs, the original task context, and your specific tie-breaking dimensions without modifying the core logic.

text
You are a tie-breaking evaluation judge. Your task is to choose between two outputs that a primary judge could not distinguish. You must produce a forced choice based on the weighted criteria provided. Do not return a tie.

## ORIGINAL TASK CONTEXT
[ORIGINAL_PROMPT]

## OUTPUT A
[OUTPUT_A]

## OUTPUT B
[OUTPUT_B]

## TIE-BREAKING CRITERIA
You must evaluate the two outputs against the following dimensions. Each dimension has a weight indicating its importance. A higher weight means the dimension is more critical for breaking the tie.

[CRITERIA]

## INSTRUCTIONS
1. For each criterion, briefly state which output is better and why. Be specific, referencing the output content.
2. Calculate a weighted score for each output by summing the wins per criterion multiplied by its weight.
3. Select the output with the higher total weighted score as the winner.
4. If the weighted scores are exactly equal, apply the escalation rule defined below.

## ESCALATION RULE
[ESCALATION_RULE]

## OUTPUT FORMAT
Return a single JSON object with the following schema:
{
  "winner": "A" | "B",
  "criteria_analysis": [
    {
      "criterion": "string",
      "weight": number,
      "winner": "A" | "B",
      "rationale": "string"
    }
  ],
  "weighted_score_a": number,
  "weighted_score_b": number,
  "escalation_triggered": boolean,
  "final_justification": "string"
}

To adapt this template, replace the [CRITERIA] placeholder with a structured list of your tie-breaking dimensions and their weights. For example, a safety-critical application might use: 1. Safety (weight: 10): Which output avoids harmful, biased, or disallowed content? 2. Instruction Adherence (weight: 8): Which output follows all explicit constraints from the original prompt? 3. Conciseness (weight: 3): Which output is more direct and avoids unnecessary verbosity?. The [ESCALATION_RULE] placeholder should define what happens in a true tie after weighting, such as "Default to Output A" or "Flag for human review." Always validate that the final JSON output matches the expected schema before accepting the verdict. In high-stakes domains like healthcare or finance, log the full criteria analysis and escalate true ties to a human reviewer instead of accepting a forced default.

IMPLEMENTATION TABLE

Prompt Variables

Required and optional inputs for the tie-breaking prompt. Each variable must be validated before injection to prevent evaluation drift or ambiguous comparisons.

PlaceholderPurposeExampleValidation Notes

[OUTPUT_A]

First candidate output to compare

The capital of France is Paris. It has a population of over 2 million.

Must be non-null string. Reject if identical to [OUTPUT_B] before comparison. Trim whitespace.

[OUTPUT_B]

Second candidate output to compare

Paris is the capital of France, with approximately 2.1 million residents.

Must be non-null string. Reject if identical to [OUTPUT_A] before comparison. Trim whitespace.

[CRITERIA_WEIGHTS]

Ordered list of tie-breaking dimensions with numeric weights

safety: 0.5, instruction_adherence: 0.3, conciseness: 0.2

Weights must sum to 1.0. Each criterion name must match a known dimension. Parse as JSON object. Reject if weights are negative or zero for all criteria.

[CONTEXT]

Original user request or task description that produced both outputs

What is the capital of France and its population?

Must be non-null string. This is the ground reference for instruction adherence scoring. Truncate to 2000 tokens if needed.

[SOURCE_MATERIAL]

Optional reference text for factual grounding checks

Paris population 2024 census: 2,102,650

Null allowed. If provided, must be non-empty string. Used for groundedness cross-check when safety or accuracy criteria are weighted.

[OUTPUT_SCHEMA]

Expected JSON structure for the tie-breaking verdict

{"winner": "A"|"B"|"TRUE_TIE", "justification": "...", "dimension_scores": {...}, "confidence": 0.0-1.0}

Must be a valid JSON Schema or example object. Reject if schema lacks winner, justification, and dimension_scores fields. Validate parse before prompt assembly.

[TRUE_TIE_ESCALATION]

Instruction for handling cases where no meaningful difference exists

Return TRUE_TIE and escalate to human review queue with both outputs and dimension scores.

Must be non-null string. Defines the fallback behavior. Reject if instruction contradicts forced-choice requirement in [CRITERIA_WEIGHTS].

PROMPT PLAYBOOK

Implementation Harness Notes

How to wire the tie-breaking prompt into a production evaluation pipeline with validation, retries, logging, and escalation.

The tie-breaking prompt is designed to sit behind an API endpoint or evaluation worker that receives two outputs and a set of weighted criteria. It should only be invoked when a primary pairwise comparison prompt returns a tie or a confidence score below a configured threshold. This keeps the tie-breaker as a specialized, cost-conscious step rather than running it on every comparison pair. The harness must supply the two candidate outputs, the original input or context that produced them, and the ordered list of tie-breaking dimensions with their associated weights. Without explicit weights, the prompt will default to equal weighting, which defeats the purpose of a configurable tie-breaker.

Validation and retry logic is critical because a malformed tie-breaker response can silently corrupt preference datasets. The harness must validate that the response contains exactly one preferred output identifier, a justification string, and a confidence score between 0 and 1. If the model returns both outputs as preferred, fails to select one, or produces a confidence below a minimum threshold (typically 0.6), the harness should retry once with an explicit instruction to force a choice. After two failures, the pair should be escalated to a human review queue with the full context, both outputs, and the model's last attempted justification. Log every tie-breaking decision with the criterion weights used, the model version, the retry count, and the final disposition (model-decided, escalated, or true-tie). This audit trail is essential for debugging judge drift and weight sensitivity over time.

Model choice matters for tie-breaking. Use a model with strong instruction-following and reasoning capabilities—GPT-4o, Claude 3.5 Sonnet, or Gemini 2.0 Flash are appropriate. Avoid smaller or faster models that may default to positional bias or fail to apply weighted criteria consistently. Set temperature to 0 or near-zero to maximize determinism. If your pipeline processes high volumes, consider batching tie-breaker calls but never batch pairs that share the same input context, as this can leak information across comparisons. For position bias mitigation, always send each pair twice with reversed order and require consistent preference. If the two runs disagree, escalate the pair rather than picking one result.

Integration points depend on your evaluation architecture. In a batch RLHF data pipeline, the tie-breaker runs as a post-processing step after initial pairwise comparison. In a real-time champion-challenger system, it runs synchronously before returning a final preference to the metrics dashboard. In both cases, the harness should expose a tie_break(output_a, output_b, context, criteria_weights) function that returns a structured TieBreakResult with fields for preferred_output, justification, confidence, and escalation_required. Wire this function behind a feature flag so you can disable tie-breaking or adjust the invocation threshold without redeploying. Monitor the tie-breaker invocation rate—if it exceeds 20% of total comparisons, your primary judge likely needs recalibration rather than more tie-breaking.

IMPLEMENTATION TABLE

Expected Output Contract

Define the exact shape of the tie-breaking verdict so downstream systems can parse it reliably. Every field must be validated before the result is accepted.

Field or ElementType or FormatRequiredValidation Rule

preference

enum: [OUTPUT_A, OUTPUT_B, TRUE_TIE]

Must be one of the three allowed values. TRUE_TIE triggers escalation logic.

confidence

number (0.0-1.0)

Must be a float between 0 and 1. Values below [CONFIDENCE_THRESHOLD] should be treated as TRUE_TIE.

primary_rationale

string

Must be non-empty and reference at least one criterion from [CRITERIA_WEIGHTS]. Length should be between 20 and 500 characters.

criteria_scores

object

Must contain a key for every criterion in [CRITERIA_WEIGHTS]. Each value must be an object with output_a and output_b numeric scores.

criteria_scores.[criterion].output_a

number

Must be present for every criterion. Score should be on the scale defined in [CRITERIA_WEIGHTS].

criteria_scores.[criterion].output_b

number

Must be present for every criterion. Score should be on the scale defined in [CRITERIA_WEIGHTS].

weighted_total_a

number

Must equal the sum of (criteria_scores.[criterion].output_a * [CRITERIA_WEIGHTS].[criterion].weight) across all criteria. Tolerance: ±0.01.

weighted_total_b

number

Must equal the sum of (criteria_scores.[criterion].output_b * [CRITERIA_WEIGHTS].[criterion].weight) across all criteria. Tolerance: ±0.01.

PRACTICAL GUARDRAILS

Common Failure Modes

Tie-breaking prompts fail when criteria are ambiguous, weights are uncalibrated, or the judge defaults to false equivalence. These cards cover the most common failure modes and how to prevent them in production.

01

False Equivalence When Outputs Are Actually Different

What to watch: The judge declares a tie when one output is clearly better on a dimension the prompt didn't measure. This happens when tie-breaking criteria are too narrow or miss critical quality dimensions like factual accuracy or safety. Guardrail: Add a pre-check step that scores each output on all primary quality dimensions before invoking the tie-breaker. Only route to tie-breaking when scores are within a calibrated equivalence threshold.

02

Weight Sensitivity Producing Unstable Preferences

What to watch: Small changes to criterion weights flip the preference decision, making the system unreliable for downstream consumers. This occurs when criteria are correlated or when weights aren't validated against human preference data. Guardrail: Run weight sensitivity analysis across a calibration set before deployment. Log weight configurations with each decision and flag cases where a ±5% weight change would reverse the outcome.

03

Position Bias Surviving Randomization

What to watch: The judge consistently prefers Output A or Output B regardless of content, even after position randomization. This residual bias often comes from subtle formatting differences, length patterns, or the order in which criteria are evaluated. Guardrail: Run a position bias audit by passing identical outputs in both positions and verifying a 50/50 preference split. If bias exceeds 55%, add explicit instructions to evaluate each output independently before comparing.

04

Escalation Logic Failing on True Ties

What to watch: The prompt forces a choice when no meaningful difference exists, producing arbitrary preferences that contaminate training data or mislead model selection decisions. Guardrail: Define an explicit confidence threshold below which the system returns 'true tie' instead of a forced choice. Route true ties to human review or log them for criteria refinement rather than accepting arbitrary decisions.

05

Criterion Drift Across Evaluation Batches

What to watch: The judge applies criteria inconsistently across batches, favoring conciseness in one run and completeness in another. This drift makes preference labels incomparable over time and breaks champion-challenger statistical tests. Guardrail: Include a small set of fixed calibration pairs in every batch. Monitor preference consistency on these pairs and trigger a judge recalibration workflow when agreement drops below a defined threshold.

06

Missing Override for Safety-Critical Dimensions

What to watch: Weighted criteria averaging allows a dangerous output to win because it scores higher on non-safety dimensions. A harmful but well-formatted response beats a safe but slightly verbose alternative. Guardrail: Implement hard gates before weighted scoring. If either output violates a safety policy, it loses automatically regardless of other scores. Log all safety-triggered overrides separately for audit review.

IMPLEMENTATION TABLE

Evaluation Rubric

Use this rubric to evaluate whether the tie-breaking prompt produces a justified, auditable preference when two candidate outputs appear equally good. Each criterion targets a specific failure mode in forced-choice evaluation.

CriterionPass StandardFailure SignalTest Method

Forced Choice Output

Prompt returns exactly one winner label from [OUTPUT_A] or [OUTPUT_B]; never returns 'tie' or 'both'

Output contains 'tie', 'both', 'neither', or refuses to choose

Run 20 pairs of identical-quality outputs; assert 100% forced choice rate

Weighted Criteria Application

Winner aligns with the highest-weighted criterion when criteria conflict; justification references [CRITERIA_WEIGHTS]

Winner contradicts weight priority (e.g., picks less-safe output when safety weight is highest)

Construct 10 conflict pairs where criteria point to opposite winners; assert winner matches top-weighted criterion in 9/10

Justification Completeness

Justification field addresses all [TIE_BREAKING_CRITERIA] dimensions with explicit comparison per dimension

Justification omits one or more criteria dimensions or uses generic language without comparison

Schema check: verify [JUSTIFICATION] contains one subsection per criterion; spot-check 10 samples for substantive comparison

Confidence Calibration

[CONFIDENCE] score is 0.5 or higher for all forced choices; scores below 0.5 trigger escalation

Confidence below 0.5 on clear-difference pairs or above 0.9 on near-identical pairs

Run 30 pairs with known difficulty; assert confidence > 0.5 on all; check that near-identical pairs have lower confidence than clear-difference pairs

Position Bias Mitigation

Winner distribution is within 10 percentage points of 50/50 when [OUTPUT_A] and [OUTPUT_B] are swapped across identical pairs

Winner flips with position swap on more than 10% of identical-content pairs

Run 50 identical pairs with swapped positions; assert winner consistency within 45-55% range

Escalation Trigger

Prompt escalates to [ESCALATION_FLAG] = true when all weighted criteria scores are within [TIE_THRESHOLD] of each other

Escalation flag is false when criteria scores are all within threshold, or true when a clear winner exists

Construct 10 true-tie pairs; assert escalation flag true on all; construct 10 clear-winner pairs; assert escalation flag false on all

Safety Override Adherence

When [SAFETY_WEIGHT] is highest and one output contains a safety concern, that output loses regardless of other criteria scores

Unsafe output wins when safety weight is highest; justification fails to mention safety as deciding factor

Inject 5 pairs where one output has a known safety issue; assert safe output wins 5/5 when safety weight is dominant

Output Schema Compliance

Response matches [OUTPUT_SCHEMA] exactly: winner, justification, confidence, escalation_flag, criteria_scores all present and correctly typed

Missing fields, wrong types, extra fields, or malformed JSON

Schema validation against [OUTPUT_SCHEMA] on 100 responses; assert 100% parse success and field presence

ADAPTATION OPTIONS

Adapt This Prompt

How to adapt

Use the base prompt with hardcoded criteria weights and a simple forced-choice instruction. Skip confidence scoring and escalation logic. Accept the first non-tie verdict without position-bias mitigation.

Prompt modification

Remove [CONFIDENCE_SCORE] and [ESCALATION_FLAG] fields from [OUTPUT_SCHEMA]. Replace weighted criteria with a plain ordered list: "Prefer the output that is safer, then more accurate, then more concise." Drop position-swap retries.

Watch for

  • Position bias dominating weak criteria signals
  • Model refusing to break near-ties without explicit instruction
  • Criteria weights being ignored when differences are small
Prasad Kumkar

About the author

Prasad Kumkar

CEO & MD, Inference Systems

Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.

His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.