My organization recently passed a milestone that says a lot about where enterprise AI is heading. For the first time, more of our AI agent sessions are triggered asynchronously by events, automations, schedules and other agents than by a human sitting in front of them. Inside our own engineering team, 89 percent of the code our engineers commit is committed by Devin, our autonomous software engineer.
Generating code is becoming less scarce. Across Asia, where software demand continues to stretch engineering capacity, that can be useful. It also creates a harder question: when agents produce a growing share of the code, how do teams verify what comes back?
Unverified output becomes unmanageable
There is a compelling moment in agentic development when an agent picks up a customer complaint, diagnoses the issue and puts up a pull request with a fix before an engineer has even seen the bug report. Teams experience this and naturally want to extend the model to more work.
Then the volume arrives. As proactive agents multiply, they can generate a stream of pull requests that all need review. The review queue becomes the new backlog. Human reviewers can become the constraint that code generation used to be, because a change that arrives without evidence that it works transfers effort from writing to checking.
This is particularly relevant in sectors such as banking, insurance, telecommunications and government, where software changes may sit inside tightly controlled production environments. In those settings, AI output needs evidence before it can be trusted in a delivery pipeline.
Verification needs to be part of the agent workflow
One approach is to make agents verify their own work end to end before handing it back. The agent can start the application in a cloud environment, test the affected flow in a real browser and return evidence such as labeled screenshots, recordings and explicit pass or fail assertions.
Getting this to work reliably requires more discipline than simply asking an agent to test what it wrote. Early versions can drift, spend too much time on unrelated parts of the product or make assumptions about application paths that do not exist.
Three practices have helped us. First, the agent writes a test plan grounded in the actual source code before testing begins. Second, it records the expected behavior immediately before each action, which makes it harder to reinterpret an unexpected result as a pass. Third, repeated setup work, such as logging in, is moved into deterministic scripts so the run can focus on the behavior being tested.
These are familiar engineering habits. What changes is that the same discipline is being applied to autonomous agents before their output reaches a human reviewer.
The useful metric is what passes verification
The distinction becomes clearer when looking at deployment results. Cognition has reported that OCBC in Singapore improved first-pass rates for system integration tests from below 50 percent to more than 80 percent after deploying its platform, alongside improvements of up to 30 percent in code and test-case generation. The first-pass rate is the more important number because it says more about whether generated work is ready to move through the delivery process.
The Singapore deployment also sits within Cognition’s broader expansion in Asia. The Singapore Economic Development Board has highlighted Cognition’s regional headquarters and OCBC deployment as part of the company’s growth in the market.
Globally, Cognition has also said that Itaú now fixes 70 percent of its security vulnerabilities automatically. The underlying principle is similar. Automation becomes more useful when a fix returns with evidence that it behaves as intended.
Judge agent output by evidence, not volume
When engineering teams evaluate AI coding agents, the volume of generated code is an incomplete measure. A model can increase output while quietly increasing the amount of review, debugging and rework that engineers must absorb later.
The stronger deployments build verification into the delivery loop. Engineers can then spend more time structuring problems, setting constraints and judging outcomes instead of checking every step manually.
That is also what makes delegation more sustainable. Proactive agents can take on more work, but safe delegation depends on the work returning with proof. As coding agents become more autonomous, verification will increasingly determine whether the additional output becomes shipped software or simply another queue for engineers to manage.
Kevin Lee is Head of Deployed Engineering APJ at Cognition, the company behind the Devin AI software engineer.
Editor’s note: This contributed article has been lightly edited for clarity and TNGlobal house style. The substance of the author’s contribution has been preserved.
Share your perspective: TNGlobal welcomes contributed insights and expert commentary from across Asia’s technology and innovation ecosystem. Submit a contribution for editorial consideration, or explore more conversations in our TNGlobal INSIDER and TNGlobal Q&A and Interviews archive.
Featured image Kevin Ku on Unsplash
The AI citation gap for Southeast Asian SMEs: A seven-check visibility audit