# Proactive Agents Kath Korevec, Google Labs | AI Engineer CODE 2025 | 16:51 Source: https://www.youtube.com/watch?v=v3u8xc0zLec Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks. Page: https://aietalks.com/talks/proactive-agents Published: 2025-12-13 Tags: agents, coding-agents, human-in-the-loop, memory ## TL;DR - Asynchronous agents should reduce the monitoring work developers carry instead of adding a new set of tasks to manage. - Proactive systems need to observe work, learn personal preferences, act at the right time, and fit into existing developer tools. - Google Labs is adding memory, critic review, verification, environment setup, and repository-aware task discovery to Jules. ## Summary Kath Korevec argues that asynchronous coding agents still leave developers carrying the mental work of checking progress and deciding what to do next. Humans lose time when they switch between tasks, so agents should behave more like trusted collaborators. Her model of proactive software has four parts: continuous observation, personalization, timely intervention, and integration with the tools developers already use. She describes three levels of proactivity in Jules. The current level detects issues such as missing tests and unused dependencies. Later levels will understand a project, its users, and its outcomes, with Jules, Stitch, and Insights sharing context. The human remains responsible for reviewing, redirecting, and aligning the agents. A demo shows Jules indexing a repository, finding to-dos and best-practice changes, assigning confidence levels, and explaining its suggested work. Korevec connects this to her Halloween hardware project, where agent automation could have left her more time for creative LED and motion work. ## Key ideas ### Async agents should remove monitoring work from developers [00:39](https://www.youtube.com/watch?v=v3u8xc0zLec&t=39s) Korevec uses a broken dishwasher to explain the mental load of asynchronous agents. Her husband agreed to do the dishes, yet she still had to remember the task, check whether it was finished, and follow up. She says developers face the same problem when agents handle pieces of work but require constant supervision. Humans can juggle goals, but they execute tasks in sequence. Switching between them can cost up to 40% of productive time. Developers therefore need collaborators that understand context, anticipate needs, and keep work moving while the developer focuses elsewhere. Korevec describes the goal for Jules simply: it should "do the dishes without being asked." ### Proactive agents act before an explicit request [03:26](https://www.youtube.com/watch?v=v3u8xc0zLec&t=206s) Korevec contrasts proactive systems with the reactive behavior of most AI developer tools. A developer opens a CLI or IDE, gives an instruction, and receives a response. That approach uses compute efficiently because it runs only after an explicit request. If compute stops being the limiting factor, she imagines many small agents working quietly in parallel. They could notice friction, fix authentication bugs, update configurations, flag possible ordering errors, or prepare migrations based on events in the developer's normal workflow. The agent would take on work before the developer asks, while remaining inside the terminal, repository, or IDE rather than sending the developer to another application. ### Proactivity depends on observation, personalization, timing, and workflow fit [04:27](https://www.youtube.com/watch?v=v3u8xc0zLec&t=267s) Korevec gives four conditions for a useful proactive system. It must observe code changes, patterns, and workflow so it understands the project. It must personalize its behavior by learning what the developer cares about, ignores, prefers, or never wants touched. It must act at the right time, since an early intervention interrupts work and a late one misses the moment. It also has to work inside the places where developers already work, including the terminal, repository, and IDE. She compares this behavior with Google Nest learning household routines and with the body reacting to a fall before conscious thought. Proactivity therefore feels familiar rather than futuristic. ### Jules currently detects and fixes surrounding code problems [06:40](https://www.youtube.com/watch?v=v3u8xc0zLec&t=400s) Korevec describes three levels of proactivity in Jules. At the first level, which she says Jules supports today, the agent notices issues while handling another requested task. Examples include missing tests, unused dependencies, and unsafe patterns. It can automatically fix those issues, like an attentive sous chef who keeps the kitchen ready while someone else cooks. This is an early form of collaboration because the agent contributes work that the developer did not explicitly request. It reduces the need to stop and create separate prompts for routine cleanup, while the developer remains focused on the main task. ### Project-aware agents learn how a developer and codebase work [07:19](https://www.youtube.com/watch?v=v3u8xc0zLec&t=439s) At the second level, Jules becomes aware of the whole project and the developer's working patterns. Korevec says it can observe the code being written, the frameworks in use, and the deployment style. It could notice that a back-end engineer needs help with React, or that a designer needs assistance writing a database schema. She compares this agent to a kitchen manager that maintains the rhythm of the work and anticipates what will be needed next. The agent's usefulness depends on knowledge built from the project and the developer's habits, rather than on a series of isolated prompts. ### Multiple agents can connect code, design, and product outcomes [07:55](https://www.youtube.com/watch?v=v3u8xc0zLec&t=475s) The third level adds awareness of consequences. Korevec says Jules, Stitch, and Insights are being brought together so they can share intelligence across an application. Jules can see what is breaking in the software. Stitch is a design agent that understands how users interact with it. Insights is a data agent that connects behavior with analytics, telemetry, and conversion rates. Together, they could propose performance fixes that improve the user experience or design changes that prevent regressions. Korevec says live data organizes this work. Humans still observe the agents, refine their direction, and intervene when they are misdirected. The goal is alignment with the project across its full life cycle. ### Jules is gaining memory, review, verification, and repository awareness [09:30](https://www.youtube.com/watch?v=v3u8xc0zLec&t=570s) Korevec lists several additions moving Jules toward a proactive teammate. Memory lets Jules write, edit, and use knowledge about a project. A critic agent works adversarially with Jules and performs a full code review. Verification has Jules write a Playwright script, take a screenshot, and return that evidence to the trajectory for human validation. A to-do bot searches repositories for future tasks and begins working on them with their surrounding context. Jules can also suggest best practices, set up environments through an environment agent, and consult just-in-time context, described as a cheat sheet for a specific task. These features reduce the need to explain the same project details repeatedly. ### The proactivity view lets developers inspect proposed work before starting it [11:18](https://www.youtube.com/watch?v=v3u8xc0zLec&t=678s) In the described demo, enabling proactivity first causes Jules to index the whole codebase and directory. It then finds repository to-dos and possible best-practice updates. The interface groups suggestions by confidence, with high confidence shown in green, medium confidence in purple, and low confidence in yellow. Developers can manually start selected tasks or delete suggestions that do not fit. Once a task starts, they can inspect the proposed code, find its location, and read Jules's rationale for working there. Korevec says the interface is intended to lower cognitive load and give developers enough context to trust or reject the suggested work. Automatic starting was still being developed. ### Less debugging time could leave more room for creative work [13:19](https://www.youtube.com/watch?v=v3u8xc0zLec&t=799s) Korevec describes building a six-foot animatronic head for Halloween with her husband. She used Jules to update firmware, control stepper motors, and work on LEDs and sensors, but spent much of her time fixing bugs and swapping libraries. Her process was to prompt Jules, wait about ten minutes, and repeat. She wanted the agent to research fixes and handle debugging so she could design creative effects, such as eyes that followed people and lasers coming from the eyes. She did not ship as much as she wanted. For Korevec, proactive agents should close the gap between tool friction and creative freedom. ## Notable quotes - "Humans, we are serial processors, not parallel ones." (01:14) - "I want to be a coder. I want to build." (02:26) - "We want Jewels to do the dishes without being asked." (03:08) - "The human stays firmly in the loop." (08:49) - "I wanted it to handle the ugly parts where it was researching how to fix a bug, doing the debugging itself." (14:37) ## Tools & references mentioned - Google Labs - Ada - Jules - Stitch - Insights - Google Nest - Claude Code - Playwright - ADK Python - Pee-wee Herman ## Who should watch - You are building coding agents and need a model for when they should act without an explicit prompt. - Your team is experimenting with background automation but wants developers to review, redirect, and reject proposed work. - You spend time on repository cleanup, debugging, environment setup, or other maintenance that takes attention away from creative product work. ## Related talks - [Software Development Agents: What Works and What Doesn't](https://aietalks.com/talks/software-development-agents-what-works-and-what-doesnt) (Robert Brennan, OpenHands, 16:46) - [Your Coding Agent Just Got Cloned And Your Brain Isn't Ready](https://aietalks.com/talks/your-coding-agent-just-got-cloned-and-your-brain-isnt-ready) (Rustin Banks, Google Labs, 13:40) - [How Coding Agents Change Software Development Forever](https://aietalks.com/talks/how-coding-agents-change-software-development-forever) (Hailong Zhang, 08:50) - [Agentic Engineering: Working With AI, Not Just Using It](https://aietalks.com/talks/agentic-engineering-working-with-ai-not-just-using-it) (Brendan O'Leary, Kilo Code, 27:03) - [Developer Experience in the Age of AI Coding Agents](https://aietalks.com/talks/developer-experience-in-the-age-of-ai-coding-agents) (Max Kanat-Alexander, Capital One, 18:20)