What is soft verification for agent training and how does it work?

What Soft Verification Actually Means

Soft verification for agent training is a technique for evaluating the outputs of AI coding agents using approximate, probabilistic checks rather than strict binary pass/fail tests. Instead of demanding that an agent's work satisfy every assertion in a formal test suite before it counts as correct, soft verification assigns a graded score or confidence level to an agent's behavior. A patch might earn 0.85 out of 1.0 because it compiles, touches the right files, and passes most tests, even if one edge case fails. This contrasts with hard verification, where anything short of full correctness is treated as failure.

Also worth reading: How does an automated building code verification workflow actually work, and can it replace a manual code review? · How does multi-agent architectural drawing conversion work and why is it superior to single-agent AI for code generation? · What are the best practices for AI takeoff verification in automated architecture drawing conversion?

The approach gained visibility in mid-2025 when AI2 (the Allen Institute for AI) released SERA alongside its Open Coding Agents work, describing agents trained with supervised methods and evaluated through soft-verified signals rather than expensive reinforcement learning from human feedback. The core idea is practical: repository-level tasks are so complex that fully verifying them is often impossible or prohibitively slow, so teams use weighted heuristics — build success, diff similarity to reference solutions, partial test pass rates, static analysis cleanliness — as training and selection signals. For platforms that convert architectural drawings into code, the same logic applies: a generated model of a floor plan can be scored on how many walls, doors, and dimensions it recovered correctly without requiring pixel-perfect reproduction.

Why Hard Verification Breaks Down at Repository Scale

Unit tests work well for small, self-contained functions. They stop working well when an agent must modify a codebase with thousands of files, implicit dependencies, and environment-specific build steps. Research on SWE-bench-style evaluation has repeatedly shown that a large fraction of agent failures are not reasoning failures but verification failures: the test harness itself fails to run, dependencies are missing, or the test environment differs from the one the agent assumed. When your verifier is unreliable, training against it teaches the agent to game the verifier rather than solve the task.

Soft verification addresses this by accepting imperfection in both the agent and the judge. Rather than a single binary signal, it aggregates multiple weaker signals. A typical scoring function might weight compilation success at 30 percent, passing existing regression tests at 40 percent, similarity of the produced diff to human-written reference patches at 20 percent, and adherence to style or lint rules at 10 percent. No single component proves correctness, but together they correlate strongly with it. During supervised fine-tuning, these aggregate scores let you rank candidate outputs and train on the better ones, which is exactly how AI2's SERA-style pipelines operate: supervised training only, no reward hacking against brittle unit-test oracles.

There is a trade-off worth stating plainly. Soft verification cannot guarantee correctness. A score of 0.9 means the output looks right across several dimensions, not that it is right. Teams deploying agents trained this way need downstream safeguards — human review gates, staged rollouts, runtime monitoring — precisely because the training signal was approximate.

How the Training Loop Works in Practice

A soft-verified training pipeline typically runs in five stages. First, you collect or synthesize tasks: real GitHub issues, refactoring requests, or, in the drawing-to-code domain, pairs of architectural drawings and their known correct digital representations. Second, you generate multiple candidate solutions per task, often sampling 4 to 16 completions from the base model at elevated temperature. Third, you score each candidate with the soft verifier — a composite of executable checks, embedding-based similarity, and rule-based validators. Fourth, you select the top-scoring candidates per task and perform supervised fine-tuning on them, sometimes iterating for two to four rounds. Fifth, you evaluate on held-out tasks where you do have ground truth, to confirm the soft scores actually track real quality.

The numbers matter here. Published agentic-coding results suggest that best-of-n selection over roughly 8 samples with a decent verifier recovers a substantial share of what much larger models achieve, at a fraction of the inference cost. Iterating supervised rounds on soft-verified data has been reported to improve repository-level task resolution rates by double-digit percentages relative to single-shot generation, without any reinforcement learning infrastructure. That matters for cost: RLHF-style pipelines require reward models, preference data, and stable RL training runs; supervised-only soft verification needs a scoring script and GPU hours for fine-tuning.

For architectural drawing conversion specifically, the loop looks like this: feed a drawing to the model, generate several candidate structured outputs (wall segments, door placements, room labels), score each against geometric constraints — wall closure, angle plausibility, dimension consistency — plus similarity to verified reference conversions, then fine-tune on the winners. Geometric constraint checking is a natural fit for soft verification because violations are graded: a 2-degree wall misalignment is minor, a 30-degree one is disqualifying.

Comparison: Soft Verification vs. Alternatives

The table makes the positioning clear. Soft verification sits between cheap-but-brittle automated tests and expensive-but-reliable human judgment. It is not a replacement for either; it is the pragmatic middle layer that lets you scale training data curation beyond what test suites cover while staying far below the cost of human annotation. A reasonable budget comparison: labeling 10,000 agent trajectories with human raters might cost $20,000–$50,000 and take weeks, whereas building a soft verifier costs engineering time up front and then pennies per evaluation.

Common Mistakes and Failure Modes

The first mistake is treating soft scores as ground truth during evaluation reporting. If you claim your agent solves 62 percent of tasks based on soft-verified self-evaluation, and independent hard testing shows 48 percent, you have a 14-point gap that will surface in production. Always validate the verifier itself against a labeled sample — 200 to 500 human-checked examples is usually enough to measure correlation between soft scores and true correctness. If Spearman correlation drops below roughly 0.6, your verifier components are misweighted or measuring noise.

The second mistake is verifier gaming. Agents trained against heuristic scores learn shortcuts: adding comments that resemble reference patches, restructuring diffs cosmetically, or triggering lint passes without functional change. Mitigations include rotating verifier weights between training rounds, holding out some verifier components, and adversarially auditing high-scoring outputs that fail downstream hard tests.

The third mistake is domain mismatch in the similarity component. Embedding-based similarity works poorly for structured outputs like CAD geometries or JSON building schemas, where two outputs can be textually distant yet geometrically equivalent. Use domain-appropriate metrics — IoU on bounding boxes, Chamfer distance on point sets, graph edit distance on topology — rather than generic text embeddings. The fourth mistake is ignoring calibration: report confidence intervals on soft scores, and route low-confidence outputs (say, below 0.7) to human review instead of shipping them automatically.

When to Adopt Soft Verification — and When Not To

Adopt soft verification when three conditions hold. First, your tasks are too complex for complete test coverage — repository-scale changes, drawing interpretation, multi-file refactors. Second, you have access to some reference solutions or verifiable sub-signals, even imperfect ones; soft verification amplifies weak signals, it cannot conjure them from nothing. Third, you are generating multiple candidates per task and need a ranking mechanism, since best-of-n selection is where soft verifiers deliver their clearest wins.

Do not adopt it when cheap hard verification exists. If your domain is API endpoints with clean unit tests, write the tests. Do not adopt it as a substitute for safety review in high-stakes domains — structural engineering calculations derived from drawings, medical code, financial logic all require deterministic validation and human sign-off regardless of how good your soft scores look. And do not adopt it before you have baseline measurements: run your current pipeline, record failure modes manually for a week, and confirm that verification ambiguity is actually your bottleneck rather than model capability or data quality.

Timing-wise, the technique is mature enough in August 2026 to be standard practice among frontier labs and open-source efforts alike — AI2's SERA release demonstrated supervised-only training with soft-verified data reaching competitive repository-level performance — but tooling remains DIY. Expect to write your own scoring scripts; off-the-shelf verifier libraries are still early.

Costs, Tooling, and Practical Budgeting

The direct monetary cost of soft verification is mostly compute and engineering time. Scoring a candidate output with compile checks, test execution, and similarity metrics typically takes seconds to minutes of CPU time — call it $0.001–$0.01 per evaluation on cloud infrastructure. Generating 8 candidates per task across 5,000 tasks means 40,000 generations plus 40,000 scorings; at current API pricing for mid-tier models, expect $500–$3,000 for a full data-generation round, plus fine-tuning costs of roughly $100–$1,000 per round depending on model size. Three to four rounds is a common recipe, putting total project cost in the low five figures — an order of magnitude below comparable RLHF programs.

Engineering time is the hidden cost. Building a reliable composite verifier for a specific domain took early adopters several engineer-weeks each. Budget accordingly: one experienced engineer for four to six weeks to stand up the initial pipeline, then ongoing maintenance as your task distribution drifts. Platforms in adjacent spaces illustrate the pattern — an automated architectural-drawing-to-code service, for instance, would invest in geometric validators and schema checkers once, then reuse them across every customer drawing, which is why the fixed-cost nature of soft verification favors products with high evaluation volume.

Where This Is Heading

Two trends will shape soft verification through 2027. First, verifier models: small language models fine-tuned to predict output quality are replacing hand-weighted heuristic composites, improving correlation with human judgment from the 0.6–0.7 range toward 0.8+. Second, process verification: scoring intermediate reasoning steps and tool calls rather than only final outputs, which reduces gaming and gives finer-grained training signal. Both trends increase the value of owning domain-specific evaluation data — which is why teams sitting on proprietary corpora, such as paired drawings and validated code, are unusually well positioned. The honest caveat stands: soft verification improves training efficiency and candidate selection, but it does not eliminate the need for hard guarantees at deployment. Treat it as a scaling tool for training data quality, not a certification mechanism.