How GM's Agent-First Engineering Tripled Throughput in Autonomous Vehicle Development

The 85 Percent Problem

Software engineers at General Motors' autonomous driving unit spend just fifteen percent of their working hours actually writing code, according to Rashed Haq, the company's VP for autonomous vehicles. The remaining eighty-five percent goes to activities that surround the editor: parsing vehicle telemetry, reproducing edge cases, running validation suites, triaging failures.

That distribution mirrors findings from studies conducted years before large language models entered the enterprise. A Microsoft survey of nearly six thousand developers in 2019 found that on productive days, engineers averaged ninety-six minutes of actual coding in an eight-hour shift. On harder days, that figure dropped to sixty-six minutes. Stripe's 2018 developer survey reported that maintenance tasks - debugging, refactoring, dependency updates - consumed more than seventeen hours per week.

At DailyTechWire, we've tracked productivity tooling across Asia and North America for three years, and the pattern holds: the bottleneck in software delivery is rarely the act of typing characters into an IDE. It's everything before and after.

Workflow Redesign, Not Copilot Deployment

GM's solution wasn't to hand every developer a chat interface that writes functions. Instead, the autonomous vehicle division mapped the full cycle of work in each of its three operational loops: simulation-based development, on-road vehicle testing, and post-deployment fleet monitoring. Engineers identified the longest wait or manual step in each loop, then built agents with the permissions and tool access needed to automate that step.

Haq described the approach during a fireside conversation at VB Transform 2026 in Menlo Park, California. The company deployed agents that can query petabytes of internal telemetry, call the same APIs that power GM's WebViz visualization platform, file structured issue reports, and launch machine-learning experiments in parallel. Critically, those agents operate with the same access permissions as the engineer who invokes them, and humans remain accountable for every output.

The result: roughly three times the volume of merged pull requests across the autonomous vehicle organization, faster feature releases, and a lower rate of defects that escape into later testing stages.

Telemetry, Triage, and the Model Context Protocol

One high-leverage application involves the torrent of data that autonomous test vehicles generate on public roads. Agents now perform initial triage on telemetry streams, surface anomalies, search historical logs for similar patterns, and draft issues that include supporting evidence and the affected subsystem.

GM built custom Model Context Protocol servers to connect agents to internal tools and datasets. MCP is an open standard that lets language models invoke external functions and retrieve structured context; in GM's case, that means agents can call the underlying visualization and query engines directly, rather than scraping a web UI designed for humans.

The company also maintains version-controlled "skills" - instruction documents that define how agents should execute specific tasks. Those skills encode domain knowledge: which logs to check first, how to correlate sensor streams, what thresholds indicate a real problem versus sensor noise.

Haq emphasized that agent output must remain interpretable. An agent might flag a potential localization failure, identify the LiDAR unit involved, pull three prior incidents with similar signatures, and present the evidence in a format an engineer can validate in minutes. The goal is to compress the time from "something looks wrong" to "here's a reproduction case and a hypothesis," not to make autonomous decisions about vehicle safety.

Parallel Experiments and Permission Inheritance

Beyond triage, GM uses background agents to run machine-learning experiments. An engineer specifies a model architecture change, a hyperparameter sweep, or a data augmentation strategy; agents then execute the test matrix, collect metrics, and surface results.

The permission model is straightforward: if an engineer would need access to a dataset, a compute cluster, or a deployment pipeline to complete a task manually, the agent acting on that engineer's behalf receives the same access. Accountability remains with the human. Haq noted that this design avoids both the risk of agents operating outside defined boundaries and the friction of requiring separate approval workflows for every agent action.

Four Engineers, Embedded

GM treated its internal agent platform as a product and assigned four full-time engineers to work alongside development teams. Their role wasn't to build the platform - it was to identify high-value workflows, help teams adapt processes, and propagate patterns that worked.

This embedded model proved essential. Autonomous vehicle engineering spans perception, planning, control systems, simulation infrastructure, and fleet operations. Each domain has different bottlenecks, different data sources, and different quality gates. The embedded team helped translate the abstract capability of agents into concrete improvements in each area.

The Verification Layer

Accelerating a workflow only delivers value if quality controls remain intact. Haq said GM established both structured and unstructured tests, along with performance benchmarks, before widening the aperture on agent-assisted work. Engineers review those measurements at defined checkpoints and confirm that each test still captures its intended failure mode before code advances toward production.

The company also tracks "test escapes" - defects that pass through one stage of validation but surface later. According to Haq, the rate of escapes declined even as the volume of changes increased, a result he attributes to agents catching edge cases during triage and simulation that previously required manual reproduction.

Why It Worked

GM's experience offers a template that other engineering organizations can adapt, though the specific tools and bottlenecks will vary. The core insight is architectural: productivity gains come from redesigning the entire development cycle around agent capabilities, not from adding a code-completion layer to an unchanged process.

The company began with workflow mapping, not vendor selection. It gave agents access to proprietary tools and data through a standard protocol, rather than asking engineers to export context manually. It embedded a small team to drive adoption and surface useful patterns. And it preserved human accountability at every decision gate.

Haq admitted that GM initially projected more modest gains. The surprise, he said, wasn't that agents could help - it was how much of the eighty-five percent could be automated once the right infrastructure and permissions were in place.

For organizations building safety-critical systems - whether autonomous vehicles, medical devices, or financial infrastructure - the GM case suggests that agent-first engineering can increase both velocity and rigor, provided the verification layer scales alongside the automation. The fifteen percent of time spent writing code may not change much. The eighty-five percent around it is now negotiable.