AI processes a thousand records: which one does a late result belong to?
Reconcile batch requests, responses and versions; test missing results, retries and interrupted imports before using an answer.
Article language: English

In this article
The first result arrived third. The third record's data had already changed. The fifth result never arrived, yet the batch says “completed”. With a thousand records it is easy to see an impressive processed count and miss the question of which answer belongs to which case. A spreadsheet can retain perfectly ordered rows even when their contents have been swapped.
Batch processing sends many tasks for execution together and retrieves their results later. An audit should check the durable relationship between each input, answer, version and final state. The status of the whole batch does not replace that check.
Start with a deliberately shuffled small test. Five fictional records are enough to check a different return order, a missing answer and an input changed during processing. There is no need to start with a thousand to find an error that could later be repeated efficiently a thousand times.
Five records and one risky shortcut
A fictional company prepares draft descriptions of equipment. Each product has an identifier, a data version and a separate task to generate a draft. The batch has five entries. The simplest but risky way to receive results would be to put the first answer in the first row, the second in the second row and so on. That works only if an ordering assumption holds, and that assumption needs evidence.
OpenAI's Batch API documentation states that output order can differ from input and that custom_id links a response to a request. This is a narrow, concrete receiving rule. For your own process, you still need to establish which object and which version the identifier represents.
Prepare an explicit record of requests: item identifier, source record identifier, input version and task type. These details need not be customer-facing, but they must let an authorised person reconstruct the association. A row number is convenient to read, yet after sorting it may no longer refer to the same thing.
Check input filtering too. If only a particular category was selected from a thousand items, record that scope with the batch. Reconciliation should compare results with the items actually submitted, not the whole catalogue or a later view of it. Otherwise an omission can look like a processing error even though the record never belonged to the task.
Separate the record identifier from the identifier of a particular execution. The same product may be processed again after a data correction. If both answers receive an indistinguishable key, the recipient cannot tell whether a late result concerns the old or the new version. Record the expected relationship before the test rather than explaining it afterwards from the finished description.
Check key uniqueness before sending. Two entries with the same key prevent unambiguous reconciliation even if all answers are otherwise correct. Add such a duplicate in a test and expect a stop or explicit correction under an agreed rule. A warning in a log is not enough if the process nevertheless creates an ambiguous request record.
Do not put the entire case or a person's data into an identifier merely to make a result easy to recognise. A controlled key with access to the proper record in an authorised location is enough for association. A reviewer should be able to reconstruct the relationship without receiving another copy of the source material in every task name.
Deliberately reorder the five answers in a controlled results file. Check that each goes to the right item. Then add an unknown identifier and a duplicate result. The process needs a recognisable path for both cases, without silently placing a foreign answer into the first empty slot.
With agents operating a browser (in Polish), a similar problem can occur when a list has been re-sorted. An asynchronous batch has no visible cursor, but the need to identify the correct object remains. The association should come from a durable record, not the position of an answer on the screen.
A completed batch can contain unfinished work
Anthropic's Message Batches documentation distinguishes individual results such as succeeded, errored, canceled and expired. Reconciliation must therefore account for the status of each request. The end of batch processing does not mean every item produced a usable answer.
In the fictional test one answer is ready, another contains an error, a third was canceled and a fourth returned but awaits a person's decision. A fifth can be technically successful while failing the description criteria. These are two different assessments: execution status and substantive acceptance. Do not combine them in one “ready” column if they lead to different actions.
Prepare an inventory of all input items and give each a reconciliation state. An item without an answer should still be visible. If the summary is built only from the output file, a missing record can disappear from the report instead of receiving a state that requires explanation. The reference point is the request list, not just what returned.
Distinguish a result not received, a rejected result and a task never sent. To an operator these can look alike if all fields are empty, but each needs a different next step. A clear record reduces the risk of rerunning an entire batch because someone cannot identify a few specific gaps.
Use an automation exception queue (in Polish) where a manual decision is needed. Pass on the task identifier, reason and information needed for the decision. A generic “batch incomplete” message makes the person reconstruct the whole run from the beginning.

Check the numerical summary. Do ready, rejected and awaiting-explanation items account for the whole input scope? If a use case allows an omission, record its reason as a separate state. A missing row should not masquerade as a deliberate omission merely because the final total looks tidy.
For a review with Aeneia Audit, prepare a small batch, the request record and the way answers are imported. This lets you trace the whole path of a result without starting on a large set of real data.
An answer can be correct for a world that no longer exists
During processing, a product's length or included components changed. An old draft arrives later and matches the earlier input. The model performed its task, but using that result in the current catalogue would be wrong. You need a version check before accepting the answer, not merely a judgement that the text sounds plausible.
In a controlled test change one of the five records after submission. On receipt, expect the difference to be recognised and an agreed action taken: hold the result, send it for review or process it again. Agree the rule before the batch starts and show it to the recipient. It should not arise by accident because the import overwrites a value with whichever result arrived last.
Keep the instruction and configuration version used for the task as well. Two drafts based on the same data may follow different instructions. If the description rules changed during processing, the recipient must know which answer uses the current scope. The response timestamp alone does not describe that difference.
In AI calendar planning (in Polish), a late proposal can refer to a slot someone has already booked. In a catalogue it is the data version that changes; in a calendar, availability. In both cases check the basis for using the result at the moment of decision rather than treating it as permanently current after successful generation.
Also test deletion of a record or its removal from the task after submission. A late response should not automatically recreate an item the team no longer wants to use. Mark that state in a controlled test and determine where the result is held and who may make a different decision. This differs from an ordinary field-value change.
Add a human edit awaiting completion of the batch. Does the import respect the person's work or replace it with the old answer? Set a conflict-resolution method and show it to the operator. A silent substitution is especially hard to explain because each version may look correct in isolation. Examine the collision further in checking a simultaneous record change by AI and a person (in Polish), identifying the current version before writing.
A retry should concern a known item
If two records failed, determine which tasks actually need to be retried. Record the new attempt with a link to the earlier one. Duplicate and retry controls in automation (in Polish) develops the general problem. Here, take particular care not to mistake a valid first-attempt result for the answer to the second attempt.
Do not erase the old state just because a new attempt succeeded. A short history sufficient to explain the decision lets someone establish why a record was processed again and which result was accepted. At the same time, AI logs without excessive data (in Polish) help retain the needed associations without copying all input content into every report.
Test importing the same results file again. Does the process recognise answers already accepted? Can a person see what will be skipped and what will change? Agree the behaviour before daily use: resuming after an interruption often starts with the question of whether the earlier import finished at all.
For a retry, prepare two results returning in reverse order: the newer first, the older afterwards. Check whether the selection rule relies on the correct task version or merely on delivery time. The most recently downloaded file need not contain the newest work. Keep this test: an ordinary successful retry does not expose that collision.
For a manual state correction, require the specific item and a reason. A general “mark batch ready” action can hide unresolved records. If closing with omitted items is allowed, the summary should still list them. The person taking over can then understand what the final status covers.
Separate receiving a file from writing its contents to the target system. Results may download correctly while writing stops after the third item. On resumption, the state of each item must be reconstructed. “File downloaded” does not establish that the entire catalogue contains new drafts.
Interrupt an import deliberately after one item has been written. Then use the intended recovery path and compare its result with an uninterrupted run. No item should be missing and the already written item should not be accepted an extra time. If the outcome remains uncertain, the process needs a way to read state instead of automatically repeating every write.
Finally, ask another person to locate a randomly selected item at three stages: input, received answer and target state. Ask them to explain a rejected item too. If they must infer from the text where a draft came from, the record of associations needs improvement. This short test checks whether the history is usable; merely having logs does not establish that.
Complete acceptance against the target state, comparing it with the request list and accepted answers. For every item it should be clear whether it was written, held or sent for correction. A thousand records then become a larger number of understandable cases, rather than one large “completed” label in which all exceptions can hide.







