Cognition Grew Merged PRs 40-Fold as Engineering Headcount Rose 2.7-Fold
Cognition’s merged pull requests grew 40.4-fold in a year as its engineering team expanded 2.7-fold, a change Walden Yan attributes to reorganizing development around agents rather than simply adding coding capacity. In his account, small teams own work from customer report through QA, while agents handle implementation and testing in a Slack-driven workflow. Yan argues the next step is to give agents measurable outcomes to pursue over time, not just discrete tasks.

Throughput rose faster than headcount
At Cognition, merged pull requests increased 40.4-fold from November 2025 to October 2026, while engineering headcount grew 2.7-fold. Walden Yan said that meant each engineer was producing more than ten times as many merged PRs as a year earlier. He described their quality as “just as high quality, if not higher quality.”
Yan’s explanation was organizational as much as technical: make software development self-driving by default, then bring in people when judgment is needed. In Cognition’s model, agents handle the path from an initial bug report or feature request through implementation, testing and review, and can continue into deployment monitoring and maintenance. Human involvement is an escalation, not a required stop at every stage.
That changes what engineers are expected to do. Yan said the team told engineers in March that simply taking tickets from a board and handing them to an agent would not be enough: if work can be described and implemented, it can be delegated. Engineers therefore need to own a broader slice of the work, including deciding what should be done.
By default everything should be self-driving.
Small pods own the work from customer report to QA
Cognition broke larger teams into small pods, often with two or three engineers. Instead of organizing people mainly by function, the company groups product, engineering and QA/on-call responsibilities around verticals such as billing, the mobile app or integrations.
Walden Yan said each engineer is responsible not only for implementation but also for listening to customer bug reports, product management and QA. Each maintains a board of work and sends suitable items to agents. The agents provide additional capacity; the pod’s broader ownership is meant to keep decisions close to the product and its users.
One example starts with a customer reporting a small interface bug in Slack. The report is forwarded to an internal channel, an engineer tags Devin with the requested fix, and the agent returns a pull request along with a recording showing the change working. Yan said the team can send that evidence back to the customer without opening an IDE or, in many cases, GitHub.
The aim, he said, is to carry out the development lifecycle from Slack, using recordings and other evidence to review work. That workflow depends on more than giving an agent access to a repository: it requires a codebase it can run and test safely.
Agents need a local, repeatable way to test
Cognition previously tested against cloud deployments, staging databases and live services, with engineers manually clicking through flows. Walden Yan said the company changed its infrastructure so services could run locally using Docker Compose, with mocked versions of third-party services. The environment runs in a virtual machine, so agents can test changes without touching live services.
The company rebuilds those machines every hour from the latest code. If a rebuild fails as the codebase changes, Yan said, Devin is the first responder and repairs the snapshot. An agent launched from Slack therefore starts on a fresh machine with an up-to-date codebase.
Testing instructions also need maintenance. Yan said Devin writes and updates its own testing skills as the codebase changes. The approach can extend beyond single-user flows: while developing Devin’s ability to join Zoom calls, the team had an agent create multiple accounts in one VM, join them to the same call and exchange voice memos to test the feature.
Yan said this setup has let some engineers develop from iPads rather than laptops. He also argued that keeping work in controlled cloud VMs can make development more secure by reducing the exposure of secrets on developer machines.
The factory itself becomes work for agents
When agents and their work are tracked across a codebase, Walden Yan argued, the resulting activity can be analyzed to find inefficiencies. Agents can look for repeated manual steps, slow tests or opportunities to turn procedures into scripts.
He described a channel where Devin posts suggestions for improving the development process—for example, changing the Node setup to save time in CI or changing a lint script to catch more bugs before AI code review. In one analysis shown during the talk, an agent reviewed 1,289 runs and found that computer-use login steps were repeated in 80% of test runs. The slide reported that saving the procedure as a skill reduced test time by 31%.
This is the step beyond using agents to complete individual tickets: use them to improve the system that produces and checks the work.
Give agents an outcome to pursue, not a list of steps
Walden Yan’s next shift is from assigning tasks to assigning jobs. An engineer who wants lower P99 latency, for instance, should be able to state that goal rather than prescribe each implementation step. The agent would establish the current measurement, set up telemetry and alerts, identify and break down the work, and report progress over time. In Yan’s example, it might send updates through Slack and monitor whether latency improves.
The premise is that long-running work becomes more useful when goals are measurable. Yan urged teams to find metrics for outcomes they currently treat as hard to measure—from application performance to layout shifts or onboarding retention—and then let agents work continuously toward improving them.
Cognition used this model to tune inference on NVIDIA’s new Vera Rubin GPUs. Yan said the kernels were not yet built for the hardware when the company received it, so the team gave an agent a throughput goal and dedicated GPUs to experiment on. Over roughly a week, it tested strategies and sent the most promising changes to a human engineer for approval. The presentation chart reported 27,336 output tokens per minute per GPU for GB300 on an FCI.1 agentic workload, using an eight-GPU pair. It displayed best results of 17,165 for GB300 and 8,471 for GB200. The listed changes included batching draft-model guesses, grouping incoming prompts and automating tuning. Yan said the agent was still running and looking for further gains.
An Android app became a 44-day autonomous job
A second example applied the same idea to a product: maintain an Android app in parity with Cognition’s iOS app. Walden Yan said engineer Samyok asked Devin to product-manage the effort, monitor the codebase and Slack feedback, test the app and keep improving it—not simply produce a one-time implementation.
After 44 days, Yan said, the team had a working Android application that it planned to release soon. He said the agent could merge 40 or 50 PRs on many days, while escalating important decisions to a human. The presentation reported the following project metrics: 1,134 merged pull requests, 2,841 screenshot tests, 1,217 tickets closed, and 98.5% of commits written by Devin sessions.
The slides also reported 183 messages from Samyok, totaling 1,961 words, and 22 days without a message from him. Six pull requests were merged for every message he sent. Of the 1,134 PRs, 999 were merged without human approval. Yan characterized the human as barely doing anything in the loop.
| Measure | Result |
|---|---|
| Merged pull requests | 1,134 |
| Screenshot tests | 2,841 |
| Tickets closed | 1,217 |
| Commits written by Devin sessions | 98.5% |
| Messages from Samyok | 183 |
| Days without a message from Samyok | 22 |
| PRs merged without human approval | 999 of 1,134 |


