A Guide to Evaluating LLM Generation, Reasoning, and Retrieval

    This guide provides a practical framework for evaluating large language models beyond superficial demos. It covers defining objective "pass" criteria, verifying visual generation and style compliance, cross-checking reasoning chains against final outputs, testing physical and common-sense rules in agentic environments, and validating multi-turn retrieval fidelity. By using structured acceptance checklists and testable prompts, engineering teams can accurately assess a model's true capabilities.

    Many teams rely on superficial demos before selecting or deploying models, checking only if the output “looks decent”: graphics have lighting, steps are verbose, or the response repeatedly mentions “retrieved.” Such signals easily lead to overestimating the model. For real-world business applications, a more robust approach is to test capabilities separately: whether generation complies with constraints, whether reasoning aligns with the final result, whether interaction follows common sense, whether agent actions align with the environment, and whether retrieval executes the agreed-upon rounds without altering key facts.

    Define “Passing”, Not Impressions

    A single subjective trial cannot distinguish accidental success from stable capability. It is recommended to first write a clear task contract before letting the model answer. The contract should at least include: input conditions, mandatory elements, explicitly forbidden elements, observable success criteria, and allowed retry attempts. Criteria must be verifiable by a program or a checklist, rather than relying on a “feels okay” judgment.

    For the same task, keep at least four types of records: the original prompt, intermediate thinking or tool call traces (if provided by the product), the final visible result, and the diff against the standard answer or rule set. Without traces, you can only evaluate the final result and must not treat the model’s self-reported process as fact. Retries should use fixed prompts; do not secretly alter the task after a failure, otherwise stability cannot be compared.

    Visual Generation: Aesthetics vs. Style and Structure Compliance

    In interactive or graphical tasks, particles, lighting, and gradients are often baseline features and should not serve as standalone bonus points. More informative metrics are structural correctness: object count, relative positions, collision boundaries, hierarchical occlusion, and readability (contrast, whether labels are swallowed by the background).

    Style constraints must be verified separately. If the prompt requires a visible style like ink wash, wood grain, or wireframe, the corresponding visual features must be identifiable in the final output. If the thinking process states “will present a certain style” but the final product completely lacks it, this should be recorded as a planning-execution inconsistency, not dismissed as “style is hard to achieve.” Difficult-to-implement requirements can be replaced with detectable alternative constraints in the prompt, such as specifying a color palette, prohibiting gradients, or mandating contour lines, avoiding unverifiable adjectives as thresholds.

    Interface usability is also a matter of correctness. If a scene’s main information area is too dark, lacks contrast, or blends controls into the background, even if users can barely drag elements, it should be judged as a failure. Darkness is not a style; it is information loss.

    Cross-Check Reasoning Chains and Results

    Long chains of thought enhance the impression of a “diligent process” but also introduce new errors: the model promises an effect, a count, or a configuration in the chain, but does something else in the output, or the chain itself is a hallucination. During evaluation, treat the chain as a hypothesis to be verified, not as evidence.

    A practical approach is to extract testable assertions from the chain and verify them one by one against the output. For example: “will be arranged in an adjacent column,” “will execute four independent retrievals,” or “a certain optional configuration does not exist in the scene.” If an assertion contradicts the output, record it as a consistency failure; if it contradicts external facts, record it as a fact failure. Do not mix these two into a single score, otherwise a model can mask result errors simply by writing more.

    For unachievable goals, the correct behavior is to explicitly state the limitation and provide a fallback solution, rather than pretending in the chain that it has been accomplished. Writing “impossible” as “completed” is more dangerous than admitting failure, because downstream systems will trust that text.

    Physics and Common Sense: Gaps, One-Shot Clears, and Playability

    Small scenes involving rigid bodies or discrete rules are excellent for exposing common-sense gaps. Take a bowling-style setup as an example: the spacing of the pins and their arrangement allowing for a logical strike is a matter of rules, not aesthetics. If the pin spacing is stretched too far, making a common-sense one-shot clear impossible, the task should fail, even if the ball and pins are “drawn correctly.”

    Similarly, sliding puzzle tasks should check whether the final state satisfies adjacency and empty space rules, rather than just checking if the animation is smooth. It is recommended to prepare a set of golden initial states and automatically verifiable end-state predicates: out of bounds, overlap, goal arrangement reached, and whether interaction steps are within the limit. Automated judgment prevents reviewers from being carried away by visual effects.

    Agents and Environments: Alignment Failures Are More Subtle Than Rendering Failures

    In grid worlds, mazes, or layered maps, common failures go beyond visual errors. Anomalous agent size or occupying too large an area renders collision and reward meaningless; missing map layers mean the task cannot even start; being able to render but not interact indicates the render and control loops are disconnected. The most easily missed failure is the misalignment between the action layer and the terrain layer—looking like it moves on the grid, while actual coordinates do not share the same coordinate system as walls, rewards, and terminal cells.

    Evaluation should be scored by layers, rather than a single “is it playable” metric:

    • Geometry layer: Are map boundaries, obstacles, and start/end points generated without contradiction?
    • Coordinate layer: Do the agent’s occupied cells, sensor readings, and terrain indices share the same origin, scaling, and axes?
    • Control layer: Do actions change the state, and are illegal actions rejected?
    • Learning layer: If the task involves tabular reinforcement learning, does the policy or value update during training, and does the converged behavior actually avoid obstacles and reach the goal?

    “Values appear to converge” does not equate to playability. Other implementations might not converge, or might converge to a misaligned policy, which is equally unusable: if rewards are recorded on the wrong cells, a descending loss curve merely means the optimizer is optimizing a skewed environment. During acceptance testing, use a fixed seed to replay several episodes, checking whether trajectories fall on legal cells, whether the agent moves forward through walls, and whether termination aligns with the goal cell.

    When debugging, prioritize printing a triplet at the same moment: the terrain index, the agent cell, and the cell where the value or policy is located. If these three are inconsistent, fix the coordinate convention first before discussing the algorithm. A schematic check can be very short:

    1. assert agent.cell in terrain.walkable
    2. assert value_table.shape == terrain.grid_shape
    3. assert reward_at(agent.cell) == env.reward(agent.cell)

    This is not an interface for any specific framework, but an invariant that must hold true during evaluation.

    Multi-turn Retrieval: Counts, Independence, and Key Facts

    When requiring “exactly a certain number of retrieval rounds,” the passing standard is not how many times “according to search” appears in the text, but whether the corresponding number actually occurred in tool-side or auditable logs, whether queries in each round are not exact repetitions, and whether later rounds leverage gaps found in earlier rounds. Retrieving only once and then reusing the same batch of materials in the text while claiming multiple retrievals should be judged as process fraud. Significantly exceeding the agreed count is also a failure: over-searching introduces irrelevant material and invalidates the capability of “controlling tool budget per instructions.”

    Fact-checking must focus on core configurations, not marginal adjectives. If standard materials explicitly state that a certain model or solution lacks a specific configuration, but the response includes it in the spec sheet, this is a severe error because users will make purchasing or design decisions based on it. The evaluation set should include negative items “easily polluted by marketing rhetoric”: the standard answer is “none,” but the model adds “yes.” When comparing, do not just look at how many selling points were recalled; separately list the accuracy rate of negative facts.

    A stable reference behavior is: if four rounds are agreed upon, execute exactly four, no more, no less; for high-risk negative items, proactively state that “the material does not support or explicitly denies existence,” rather than using common sense to fabricate it. If the product does not expose retrieval logs, rounds cannot be verified, and this item should be marked as unassessable, rather than being scored based on the text’s self-report.

    An Actionable Acceptance Checklist

    It is recommended to use the same set of task cards for each candidate model, recording pass rates rather than anecdotes:

    1. Structure correctness: Object count, positions, and rule end-states are judged by a program.
    2. Style and readability: Agreed-upon visible features exist, and key information contrast is sufficient.
    3. Chain-result consistency: Spot-check assertions; completion in text alone is not allowed.
    4. Common sense constraints: Explicit rules like gaps, one-shot clears, and legal moves.
    5. Layer alignment: Action, terrain, and reward share the same coordinates; replayable.
    6. Learning signal: If training is involved, it converges, and the policy is effective in the aligned environment.
    7. Retrieval fidelity: Actual rounds, query differences, core configs, and negative items are accurate.

    Use a fixed number of retries for the same prompt (e.g., four times), and separately tally “complete failure,” “partially renderable,” “interactive but misaligned,” and “rules passed.” Looking only at the best attempt will severely overestimate the model. If multiple entry points (web and client) behave inconsistently, document them separately; do not use the better-performing end to represent the product.

    How to Write Prompts to Test Capabilities

    In prompts, use less “make it look good” and write more testable constraints: upper limits for pin spacing, rules for mandatory one-shot strikes, maze grid sizes and agent footprint, value annotations must be drawn on corresponding floor tiles, retrieval rounds and required new information types per round, and prohibitions on adding un-retrieved configurations to tables. For styles, provide verifiable alternative descriptions. For unknown configurations, explicitly state “if not retrieved, write unknown; do not infer based on common models.”

    Reviewers should not change criteria after seeing a long chain. Look at automated judgments first, then manual items. Attribute failures as “constraints not met,” avoiding non-actionable conclusions like “domestic models generally do this” instead of pinpointing the defect.

    Conclusion

    Demo-level lighting and fluent writing only indicate that the generator’s lower bound has been raised; they do not prove the task is accomplished. Engineering teams must treat style hallucinations, physical common sense, coordinate alignment, and retrieval fraud as independent thresholds: if any critical item fails, it does not proceed to the pilot phase. Using fixed task cards, executable invariants, and real tool logs is a far better indicator of whether a model has truly advanced beyond “it can draw it” than another round of subjective trials.