Everything found so far.
As it comes in.

Adler’s point is about enterprises with tens of thousands of repositories, far too much code for an agent to fit in context or grep in real time. Sourcegraph’s answer is a code graph and search layer that agents can query across every repo, plus batch changes that roll a fix out to thousands of repos at once. Quoted from YouTube’s auto-generated captions.

For one OpenHands customer, every new vulnerability starts an agent per repository that finds affected code, updates the dependency, fixes breaking API changes and opens a PR. The owning team only has to validate and merge it. Quoted from YouTube’s auto-generated captions.

OpenHands splits large refactors into PR-sized batches that a single agent can finish in one pass. Batches run in parallel in dependency order, and a batch waits until the batches it depends on are verified and merged into a shared integration branch. Quoted from YouTube’s auto-generated captions.

When ten parallel agents all hit the same problem, OpenHands wants the fix shared between them. Brennan compares sharing all context, having a human paste in hints, letting agents edit a shared AGENTS.md with human review, and agent-to-agent messaging, which adds non-determinism. Quoted from YouTube’s auto-generated captions.

In Warp’s Oz cloud agent platform, an outer-loop agent extracts facts from each run into a versioned memory store attached to the agent, and later runs report which memories they used. Humans can review, edit or delete memories, and skill updates land as pull requests a person reviews. Quoted from YouTube’s auto-generated captions.

uReview routes each change to generators by risk and complexity, then rates, filters and deduplicates comments before posting. Uber tracks whether developers act on each comment (the “addressal rate”) and reports costs down 60% against a naive setup. Quoted from YouTube’s auto-generated captions.

Uber has thousands of engineers across hundreds of teams working in six language-specific monorepos. As PR volume and size grew, the time to a first review tripled, which is why Uber built uReview, its in-house multi-agent code reviewer. Quoted from YouTube’s auto-generated captions.

Bhardwaj works on the sandbox infrastructure that runs untrusted code for ChatGPT and Codex web. Plain fork-and-exec lets one tool call starve a shared node. Containers add cgroups for resource limits, but processes in them still share the host kernel with other users’ sandboxes. Quoted from YouTube’s auto-generated captions.

His recommendation for agent sandboxes at fleet scale is hardware-virtualized microVMs (Firecracker, Cloud Hypervisor), with incremental disk snapshots so a sandbox can be restored on another node when hardware fails. He accepts the performance cost over the risk of a breach between tenants. Quoted from YouTube’s auto-generated captions.

Sawhney describes an internal store that records the steps of long coding-agent runs, so engineers can find where an agent started looping or went off course. It sits alongside a UI for drilling into every request made by agents on Google’s shared agent back end. The captions don’t label speakers; the attribution to Sawhney is inferred from the panel’s flow. Quoted from YouTube’s auto-generated captions.

To keep up with reviewing agent-written code at Google’s volume, Sawhney describes a per-language automated review model fine-tuned on the company’s style guides and past examples of good code, with product teams adding their own review prompts. The captions don’t label speakers; the attribution to Sawhney is inferred from the panel’s flow. Quoted from YouTube’s auto-generated captions.

Asked how DeepMind keeps one power user running around a hundred agents from overwhelming a shared system, Sawhney says the current control is a quota cap that stops usage at a threshold. He presents it as a blunt stopgap rather than a finished mechanism. Quoted from YouTube’s auto-generated captions.

Figma found its senior engineers holding unwritten institutional knowledge that agents lack, so they end up catching agent mistakes and adopting AI the slowest. Figma’s response is to put these skeptics in charge of the roadmap for verification and tooling. Quoted from YouTube’s auto-generated captions.

Figma engineers may spend a week on a detailed plan, aligned with other teams, before handing it to agents. Each phase has its own validation gate so later phases don’t build on unchecked assumptions. One plan came back as about 20 PRs of 10 to 100 lines each. Quoted from YouTube’s auto-generated captions.

With about six agents running at once, Lee found himself acting as their scheduler, shared memory and reviewer, and his attention became the limit. He responded by arranging the agents in a hierarchy where each sees only a scoped slice of context, so he reviews only what reaches the top. Quoted from YouTube’s auto-generated captions.

When agents on two machines edited the same context directory, their state quietly diverged. Lee split it into per-machine directories and lets shared context change only through pull requests. Quoted from YouTube’s auto-generated captions.

Dicken separates agents writing application code from agents deploying schema or configuration changes to a production database. A bad database change is hard to undo and can take the whole application down, so it needs its own safety mechanisms. Quoted from YouTube’s auto-generated captions.

Dicken recalls, secondhand, a GitHub post about traffic multiplying over an already high load because of AI agents, as an example of agents overloading shared infrastructure. His mitigation is to tag traffic by source and give each segment a resource budget, so a surge from one source degrades gracefully instead of taking the system down. Quoted from YouTube’s auto-generated captions.

Dicken describes giving agents API and CLI access to database branching, so each agent branch or pull request gets a matching database state instead of every agent sharing one schema. Changes are merged through a deploy request and can be reverted. Quoted from YouTube’s auto-generated captions.

Superconductor moved all agent work off laptops into isolated cloud environments. Each one gets only the credentials it needs and a configurable network allowlist, which also lets non-technical teammates trigger real work safely. Quoted from YouTube’s auto-generated captions.

Superconductor’s small team used about 1.5 billion tokens in a month and benchmarks agent harnesses on its own past PRs to pick a default. Even with nearly all code agent-written, a human still reviews every PR. Quoted from YouTube’s auto-generated captions.

Korlam’s code review platform Gitar (now part of SonarSource) sees PR volume growing about 25% month over month. His mitigations: make CI fast enough to absorb repair round trips (their incremental CI went from about 10 minutes to under one), and shift expensive checks left. Quoted from YouTube’s auto-generated captions.

To keep human review from becoming the queue, teams on Gitar write plain-English approval policies: low-risk changes are auto-approved and merged, sensitive paths escalate to a person. Each approval and override is recorded on the PR for audit, since CI logs expire. Quoted from YouTube’s auto-generated captions.

At Uber, thousands of daily changes to one monorepo with long builds made one-at-a-time merging impossible, while letting everything merge kept main red. Uber’s SubmitQueue tested likely combinations of pending changes in parallel and kicked out the ones predicted to break trunk. Quoted from YouTube’s auto-generated captions.

Lloyd calls code review the most painful stage of an agent-driven delivery loop. His answer is to have an agent review first, and to treat the question of when humans step in as a risk-management decision that changes over time. Quoted from YouTube’s auto-generated captions.

Lloyd describes the architecture a software factory ends up with: a control plane that decides how incoming work is distributed among agents, and separate cloud sandboxes where the agents do the work. Quoted from YouTube’s auto-generated captions.

Lloyd describes a loop in which observer agents watch how factory agents perform. When engineers correct a review agent’s comments, the observer turns those corrections into improvements for the review agent’s next run. Quoted from YouTube’s auto-generated captions.

When Warp open-sourced its client it received thousands of PRs from hundreds of contributors. Agents triage incoming issues and review every PR first, so the human maintainers only see changes an agent has already approved. Quoted from YouTube’s auto-generated captions.

Palmie argues that writing code was never the limiting step; the delay sits downstream, in pull request review, reproducing bugs and debugging. He frames the software factory as putting agents into those stages rather than only into code generation. Quoted from YouTube’s auto-generated captions.

Palmie recommends starting with one narrow, checkable task, such as incident triage that engineers review. Each stage gets a named owner and monitoring, and stages are chained into a closed loop only once the agent’s output has earned trust. Quoted from YouTube’s auto-generated captions.

Ref argues chat sessions are private and short-lived by design. It suggests keeping state in a shared doc that every agent starts from, so agents stay stateless, the team can review the decisions, and there is a durable decision log. Quoted from YouTube’s auto-generated captions.

Dailey calls the team-level effect of sudden AI speed “velocity sickness”: more PRs than anyone can merge, people moving in different directions, and repeated work. His fix is to align on key decisions in shared docs before agents implement, which moves the review point earlier. Quoted from YouTube’s auto-generated captions.

Postman runs more than 150 microservices with thousands of REST endpoints across hundreds of repos. Instead of per-user agent memory, it built a shared API context graph, grounded in code and production traces, that maps every service, endpoint and consumer for its coding agents. Quoted from YouTube’s auto-generated captions.

An impact-analysis eval failed because new API consumers had appeared since the graph was built. Postman found about 75% of PRs in its top 10 repos touch an API surface, so stale shared context quickly leads to wrong answers and lost developer trust. Quoted from YouTube’s auto-generated captions.

Factory’s “missions” are long-running sessions, some lasting weeks, where an orchestrator agent hands work to worker agents. Workers run one after another rather than as a parallel swarm, and each one can still use parallel sub-agents for small tasks such as research. Quoted from YouTube’s auto-generated captions.

In a Factory mission, separate validator agents check the workers’ output against a contract the orchestrator wrote up front. One validator does linting, types and tests, and another clicks through the running app on a virtual machine. In the customer run she showed, validation took 40% of a 16-hour mission. Quoted from YouTube’s auto-generated captions.

Meticulous, which sells this, records real user flows in non-production environments and replays them against each PR with mocked network calls and a deterministic browser. Isolating each replay this way removes race conditions, so the replays can run in parallel with few flaky results. Quoted from YouTube’s auto-generated captions.

Reported against bd 1.2.2 four months after #3570 closed, and still open in October 2026. The same kind of failure, but nobody has shown it is the same code path.

Two processes wrote 25 rows each; all 50 writes were acknowledged and 25 rows remained. The test forced the sql.js fallback path, so it doesn't apply to every backend. The remaining race moved to #2878, closed in August 2026.

Planning that removes the coordination problem: each test file is its own unit with its own validation gates, so nothing shares state. 75% of target files migrated in four hours, though some long-tail files needed 50 to 100 retries.

An agent’s local context misses what already exists elsewhere in the repository, so duplication compounds.

Copilot code review has done more than 60 million reviews, and over one in five code reviews on GitHub now involve an agent.

Their answer is structural, not a lock: once a file is flagged, new commits are blocked and an outside agent splits it into smaller modules. In the old run the hottest file collected 7,771 conflicts from 1,173 agents; in the new one the most contested file saw 47.

The problem it fixes, in the same section: worker agents "either overwrite the other change or abandon their own."

Same task, comparable models and time budget, different orchestration. The old run also sprawled to 54 crates with three separate SQL packages; the new one settled on nine. More agent activity did not mean more delivery.

A conflict Git never reports: the changes merge cleanly and the design still diverges.

Their engineers averaged 20 PRs a day, and their answer was to drop the second reviewer. Paxos went the other way and keeps two human reviewers on agent PRs.

A shared memory database with about 16,700 entries became unreadable, then broke again about half an hour after a restore. PR #2585 added atomic flushes; cross-process locking was left for later.

Grading PRs by risk keeps human review for the changes that need it. Some teams also agreed to cap PR size after agents made PRs grow.