When an Autonomous Agent Keeps Reading the Same Asynchronous-Job Result

The observed no-progress loop

The failure is a no-progress loop around an asynchronous job. The agent repeatedly reads a cache-only result while the returned non-terminal value remains unchanged. In the observed loop, consecutive reads of one asynchronous job returned the same non-terminal response, and the dependent action did not begin.

This is the important distinction: the agent is reading successfully, but the read is not advancing the work. The unchanged result becomes the only visible event, while the action that depends on the result remains unstarted.

Failure timeline: repeated reads of a cache-only result

The observed timeline is short:

1. The agent reads the asynchronous-job result.
2. The result is non-terminal and unchanged.
3. The agent reads the same job again.
4. The same non-terminal response is returned.
5. The dependent action still does not begin.

The agent repeatedly read a cache-only asynchronous-job result while the returned non-terminal value remained unchanged. In the observed no-progress loop, the repeated reads did not lead to the dependent action.

Detection signal: two identical consecutive tool outputs

The observed detection signal was two identical consecutive tool outputs. This is deliberately narrow: it does not require a general polling policy or a framework-wide notion of progress. It identifies the immediate pattern in which the next read has reproduced the previous output.

For this failure mode, the repeated value is the signal. Once two consecutive tool outputs are identical, the agent should stop treating another read as the next useful step. The dependent action is still pending, so the loop needs to leave the read operation rather than continue repeating it.

The terminal-result failure

The same pattern can occur after the asynchronous job has already produced the result needed by the next action. In a real autonomous-agent session, the asynchronous LLM job reached state=complete with the full response payload. After that, the agent invoked the same job-read tool more than ten consecutive times. Every invocation returned a byte-identical cached payload, and filing the analysis into the issue tracker never started.

This is a distinct failure from unchanged non-terminal results. Here, the result was already a terminal full-payload result. The problem was not that the agent needed another read to obtain more content; the problem was that it continued reading instead of beginning the dependent action.

Recovery rule: stop reading and continue the dependent action

The applied fix persisted a stop-condition lesson: after a terminal full-payload result, do not poll again; execute the dependent action. Switching immediately to that dependent action worked in the same session.

The recommended policy is therefore bounded and directly testable:

• after two identical consecutive outputs, stop polling;
• when the result is a terminal full-payload result, execute the dependent action;
• if the dependent action cannot be continued, hand the result to an operator rather than repeatedly reading the same job.

The first rule addresses the observed unchanged-output signal. The second addresses the terminal full-payload failure, where the needed result is already present and the next action has not begun.

Regression-test shape

A regression check should preserve the two observed failure shapes as separate cases.

The first case uses consecutive reads that return the same non-terminal response. The expected behavior is that the repeated output is detected after two identical consecutive tool outputs and that the agent does not remain in the read loop while the dependent action is waiting.

The second case supplies a terminal full-payload result. The expected behavior is that the agent does not invoke the same job-read tool again and instead starts the dependent action. The observed session provides the concrete failure boundary: a complete full-payload result was followed by more than ten reads of a byte-identical cached payload while filing the analysis never started.

Keeping these cases separate matters. An unchanged non-terminal response and a terminal full-payload response are different points in the failure timeline, even though both can result in repeated reads and a dependent action that never begins.