Reasoning models spend additional test-time compute to work through harder problems, and developers can trade cost and capability with thinking budgets.
2
Coding agents are moving from autocomplete toward asynchronous work across repositories, but reliable testing, sandboxing, review, and clear success criteria remain necessary.
3
The scarce engineering artifact is shifting toward specifications and context that explain intent, because agents can turn those into code, tests, plans, and operational actions.
Summary
Day 2 combines keynote announcements with a full software engineering agents track. Google describes Gemini 2.5 Pro, dynamic thinking, longer context, multimodal models, and developer features such as embeddings and a deep research API. Other speakers focus on the systems needed to run agents safely: Dagger uses isolated, snapshotting containers; Morph proposes fast branching environments; and Graphite argues that AI-generated code makes review and deployment the new bottleneck. The SWE agents talks trace a progression from autocomplete and small migrations to asynchronous agents that can handle broader tasks. Speakers repeatedly return to tests, human ownership, sandboxing, permissions, and context. The later keynotes add benchmark data on the cost and latency of reasoning models, survey results on how teams use AI, and a case for treating written specifications as executable sources of intent. The session ends with demos from the AI Engineer hackathon.
Gemini is combining faster shipping with a broader developer platform
Logan Kilpatrick presents Gemini 2.5 Pro as a new update with improvements across the benchmarks developers follow, available through ai.dev and the Gemini app. He attributes Gemini's progress to bringing research and product teams together inside Google DeepMind, then shipping models to Google and external developers. He describes the Gemini app as a universal assistant and says proactivity is one of the next important directions. For developers, he points to native audio, video, smaller and larger models, infinite-context research, embeddings, a deep research API, and a shift in AI Studio toward a developer-platform experience with agents built in.
Thinking gives models a dynamic budget for difficult tasks
Jack Rae explains thinking as an additional loop before the final answer. The model can spend more test-time compute on a hard request, then decide how many iterations it needs instead of applying the same fixed computation to every question. Gemini trains this behavior with reinforcement learning, and Rae shows examples of models forming hypotheses, rejecting them, trying alternatives, breaking problems into parts, and using tools. Developers can use thinking budgets as a continuous quality and cost control. Rae also describes Deep Think as a high-budget mode with deeper and parallel chains of thought for difficult multimodal, coding, and mathematics problems.
Evals let teams iterate before production instead of learning only from failures
Manu Goyal argues that evals are more than unit tests for AI. His self-driving-car example shows why a better benchmark score alone does not establish that a system handles pedestrians, traffic, or the law correctly. Evals provide an offline signal before deployment, so teams can run experiments without paying the cost and risk of discovering problems in production. When the same metrics are applied to production data, they also reveal which examples should inform the next iteration. At Braintrust, he connects prompt experiments, logging, observability, and evals into a data flywheel for improving AI products.
Agents need isolated, configurable environments that humans can re-enter
Solomon Hykes frames agent chaos as an environment problem. Running many agents together in one workspace causes them to interfere with one another, while a fully managed background service can limit users' choice of models, compute, and tools. He wants background work, project-specific rails, an efficient way to intervene, and the option to change components. Dagger's Container Use gives agents isolated environments that can be created, snapshotted, branched, and discarded. In his demo, an agent works inside ephemeral containers, persists state through Git objects, exposes a terminal showing what the agent sees, and can run services without polluting the user's workspace.
Coding agents improve in discrete jumps as their task horizon expands
Scott Wu describes a progression from short completions to agents that work for hours. Cognition first saw broad use for repetitive migrations, where playbooks could enforce a known sequence of steps. Agents then handled small bugs and features, followed by broader changes across files that required repository understanding, language-server information, Git history, planning, and testing. The latest stage is giving an agent a backlog and letting it work on many tasks at once. Wu says the right interface and the main bottleneck change every few months because each increase in capability introduces a different collaboration, context, and verification problem.
Asynchronous agents work best when success is easy to verify
Rustin Banks presents Jules as an asynchronous coding agent for background work. He separates parallelism into multitasking, where agents handle independent backlog items, and multiple variations, where agents try different implementations of one task. His demo assigns tests, a calendar link, Gemini summaries, accessibility work, and Lighthouse improvements to separate tasks. Jules gets a cloud VM, clones the repository, proposes a plan, runs tests, and opens GitHub changes. Banks recommends defining success before starting, adding context in documentation, and telling the agent what evidence should make it stop. Clear verification makes it practical to run many agents in parallel.
Agent-generated code moves the bottleneck into review and deployment
Tomas Reimers distinguishes the inner loop of writing code from the outer loop of testing, review, merge, and deployment. As AI increases the volume of code, the outer loop can become the limiting step, especially because generated code can contain mistakes or security vulnerabilities. Graphite's Diamond aims to summarize, prioritize, and review changes, connect to CI and testing systems, and reduce noisy manual review. Reimers argues that the whole toolchain needs to adapt to AI-generated volume, with better pull-request tracking, reviewer assistance, CI pipelines, merge queues, and deployment tools. His broader point is that an AI coding workflow cannot stop at the IDE.
Reliable agent use requires small tasks, ownership, tests, and sandboxing
Robert Brennan says software engineers will spend less time typing while still needing to make architectural and product decisions. He explains an agent as a loop between an LLM and tools such as an editor, terminal, and browser. OpenHands runs these actions in Docker containers and requires careful credential scoping when agents access external services. His advice is to begin with quick tasks that have a clear definition of done, such as merge conflicts, test fixes, infrastructure changes, migrations, and coverage. Humans must review and own the resulting pull request. He also recommends discarding bad work rather than endlessly repairing a fundamentally wrong approach.
Specifications preserve intent that generated code cannot contain by itself
Sean Grove argues that code is only part of engineering value. The rest includes understanding users, setting goals, planning, communicating decisions, and checking whether the result achieved its purpose. Prompts often disappear after generating code, so he compares that workflow to versioning a compiled binary while throwing away its source. He proposes written specifications that align people, state values, define success criteria, and can be tested against model behavior. Using the OpenAI Model Spec as an example, he describes Markdown clauses with IDs and challenging prompts. In this view, specifications can be composed, linted, tested, versioned, and used as training material.
"The secret to working in parallel is a clear definition of success because nobody wants to review PRs all day."2:56:49
Who should watch
You are deciding how to run coding agents across a repository and need practical guidance on environments, permissions, tests, and review.
Your team is generating more code with AI, but pull-request review, CI, merge queues, or deployment are starting to slow delivery.
You are building an agent platform and need ideas for context management, specifications, evals, branching, and asynchronous workflows.
