Your coding agent's "done" is a claim. Plan the checks between steps

When reviewing a chain of steps created by an AI agent, it is crucial to perform a series of checks between the individual steps. The BOBA-Bench test, conducted by Amazon researchers, reveals that simply allowing an agent to run a sequence of 20 requests without supervision yields only a 51% completion rate. However, when agents are given no room for error and no opportunity to repair their mistakes, the completion rate increases to 59%.

This discrepancy highlights the importance of incorporating thorough checks in the agent's workflow.

The study also found that once an agent's code is checked and deemed correct, it is nearly as reliable as code written by human developers. However, unnoticed failures during the agent's own testing process can significantly impact the overall success of the chain. Approximately 14 to 33% of failing tests are not repaired later.

A key insight from the research is that your gate for checking an agent's work is separate from its own tests. While the agent's tests may pass, they might not catch all errors. For instance, a misinterpretation of a request can lead to tests that validate the wrong scenario. Therefore, it is essential to perform additional checks on the agent's output, ensuring that it aligns with the intended requirements.

Regression runs, which involve re-running earlier steps to verify their correctness, are another crucial aspect of the workflow. By running the checks multiple times, you can catch issues that may have been introduced by the agent's actions. This practice helps maintain a high level of code quality throughout the entire process.

Feedback provided by the agent, such as identifying a failing test, is valuable but not sufficient on its own. Simply labeling a test as "that's wrong" and repeating it a few times is not enough. Instead, providing specific details about the failing test, such as the test name and the observed error, leads to more effective troubleshooting.

When working within a multi-agent setup, it is recommended to share the agent's review results with the sub-agent responsible for that specific task, rather than stopping the process at the orchestrator. This approach ensures that each agent can act on the feedback it has received and improve the overall outcome.

To implement these recommendations, I suggest adding a chain plan to your project's documentation, such as a PR description or a ticket. This plan should outline each step of the process, including the request, the foundation it builds upon, and whether the agent's check has passed. As you progress through the chain, update the "Result fed back" column with the outcomes of the checks and any necessary repairs.

Some additional rules to consider include:

1. A step marked as a foundation should not have a successor until its check column shows "Pass."

2. If the agent's tests pass, it should not be listed in the "Check the agent can't edit" column.

3. If an agent's tests fail, document the exact test name or observed behavior, perform one repair round, and then re-run the check.

4. If no one is available to run a step's check today, the chain should pause at that point.

It is important to note that the BOBA-Bench test was conducted with Python code and without human intervention, so real-world scenarios with human oversight may yield better results. Additionally, the authors themselves acknowledge that their proposed patches are not a comprehensive solution and expect the need for them to diminish as agents become capable of self-certification.

Lastly, based on the findings of both studies, it is advisable to let the agent stack no more than 23 to 43% of requests without running the entire chain yourself. Even with perfect feedback and repair rounds, there is still a risk of unnoticed failures impacting the subsequent steps. By incorporating thorough checks at each stage of the process, you can mitigate the risk of silent misses and ensure a higher-quality output.