Why AI agents need structured investigation methods and human oversight

Software assistants that draft messages leave users with simple text to inspect. When developers grant programs permission to execute live actions, such as sending communications or modifying stored records, operational complexity grows. The system must interpret the request, select an action, and confirm the actual outcome. Deploying AI agents promises reduced workload. If operators must examine every completed task from scratch, however, that labor has simply moved into supervision. Anyone evaluating automated software faces a practical question: how much work can they delegate without repeating it themselves?

Engineers at an AI company reported this challenge with a coding agent that confused file locations after moving between folders. The agent misidentified targets when its relative directory changed. In internal tests, the team resolved the issue by requiring tools to use each file’s full path. That rule kept operations on the correct target regardless of folder changes.

Separating investigation methods from tools

Similar complications arise when diagnosing software slowdowns. An automated assistant can read code and gather runtime performance measurements. Yet access alone does not provide a method for diagnosing root causes. The agent still needs a defined procedure to select which code adjustments to inspect and what constitutes an acceptable repair. Tommy Tran, a software engineer at Meta, addressed this issue while building an agent platform for infrastructure efficiency. In an interview with LeadDev, Tran stated that he combined discovering software optimizations and investigating performance regressions within the same architecture.

To build practical workflows, Tran collaborated with senior efficiency engineers to record their investigation methods. He captured “the checks they run, the signals they trust, the order they investigate in,” as he told LeadDev. These practices became reusable instructions called skills that guide the agent through distinct problem types. Separating these skills from the tools used to inspect and modify systems allowed specialists to refine investigation methods while keeping tools stable. Their domain knowledge became a guidance layer the agent consults during tasks.

An Engineering at Meta article co-authored by Tran outlines this operational division. Tools perform data collection by retrieving code and configuration history alongside runtime telemetry. Skills direct the investigation strategy. When a slow function converts data formats, for instance, a skill prompts the agent to check recent modifications to the data’s schema. This principle applies well beyond software diagnostics. Providing an assistant access to a spreadsheet does not explain how an organization defines revenue. Similarly, opening a customer database does not reveal what justifies a refund. Autonomous agents need explicit instructions and supporting evidence to make those operational decisions.

Maintaining human approval on proposed repairs

Tran established a strict boundary around the platform’s operational independence. According to his comments to LeadDev, the agent handles the diagnostic investigation and prepares a candidate code fix, but human engineers keep final approval over changes destined for live infrastructure. Meta detailed the preparation that occurs before this handoff takes place. The automated system compiles relevant documentation and earlier fix examples alongside validation criteria for checking the optimization. When an identified software commit triggers a slowdown, the system routes the proposed resolution directly to the author of that commit for review.

Meta reported that automated troubleshooting can compress roughly ten hours of manual investigation down to approximately thirty minutes. This benchmark measures diagnostic time alone, excluding the subsequent stages of evaluating code changes and deploying them to production. The company’s published metric illustrates the design goal of the workflow: developers receive a structured proposal only after the agent finishes its investigative process. Even so, the total time saved across the maintenance lifecycle depends on whether that initial proposal withstands rigorous technical examination.

Human review demands dedicated time and attention. An engineer needs clear context regarding what changed and how it helps before endorsing a fix. If a system generates proposals faster than engineers can evaluate them, the team faces a new review backlog. Handoff clarity matters as much as diagnostic speed. AI engineers note a similar balance for coding agents: automated tests confirm that code functions, while human review evaluates wider architectural requirements. Passing a test and earning human approval answer distinct questions.

Evaluating verification time and operational costs

Everyday tools reflect similar verification hurdles in less technical tasks. An email assistant must display recipients and drafted messages before sending. An agent modifying files should present changes that users can inspect without repeating the entire task. Operating expenses require similar scrutiny. Developers at several AI companies advise starting with the simplest effective approach, noting that agents often trade additional processing time and compute cost for higher task capability. Greater autonomy remains an explicit choice to evaluate for individual workloads.

A comprehensive assessment should track model retries, verification time, manual fixes, and unfinished steps. A rapid first pass delivers little benefit when it leaves an operator facing a long repair job. A program with a narrower scope often proves more useful if it reliably finishes its assigned role. Users evaluating a prospective agent can watch for explicit permissions and visible outputs, alongside an understandable threshold for requesting assistance. The genuine return comes from net time saved once inspection time and manual corrections are fully counted.