AI Engineer Code 2025
Proactive Agents
Loading slides…
Read the talk
Proactive Agents: Delegating the Work and the Attention
Jules’s proactivity preview explores how coding agents can discover useful work, explain their proposals, and reduce the supervision that interrupts a developer’s flow.
From a talk by Kath Korevec
Delegating work without delegating attention
When Kath Korevec’s dishwasher broke, her husband volunteered to wash the dishes. Yet each evening she still had to remind him. The physical work had changed hands; remembering, checking, and following up had not. For Korevec, who works on Google Labs’ Ada team and Jules, that household problem captures what remains difficult about asynchronous coding agents.
Delegating execution does not automatically delegate the mental load. A developer still has to notice unfinished work, start an agent, track its progress, and decide when to return. Manually launching Jules can leave someone waiting before they feel able to move on. The agent runs asynchronously, but the person’s attention remains attached to it.
Korevec describes humans as sequential task executors: what feels like multitasking often consists of rapid switches between activities, each requiring some context to be restored. She cites an upper-bound estimate of 40 percent of productive time lost to switching. That is a general task-switching claim, not a measurement of developers using Jules; the talk supplies no experimental conditions for the estimate. The relevant design problem is the repeated interruption and reloading of context.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From managing terminals to trusting collaborators
Running more agents does not necessarily solve that problem. Korevec recalls a social post showing sixteen Claude Code tasks in sixteen terminals across three large monitors. To her, that is an unsettling developer experience: the developer becomes the manager of a wall of work. Useful collaborators must instead understand context, anticipate needs, and know when to intervene. As models improve at completing tasks end to end, clearly understood goals and trust become the conditions for letting work continue while the developer focuses elsewhere.
Most developer tools begin with an explicit request: type into a CLI or IDE, ask for a change, or begin writing code and receive an autocomplete suggestion. This reactive model has a real advantage: it consumes compute when the user invokes it. Korevec’s alternative starts with a hypothetical change in that constraint. If compute stopped being the limiting factor, dozens of small agents could quietly inspect patterns and friction in parallel. Natural events in the developer’s workflow could trigger authentication bug fixes, configuration updates, error flags, or preparation for migrations before someone writes a prompt.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Four requirements for useful intervention
Background activity becomes useful proactivity only when four requirements work together:
- Observation: Continuously understand code changes, recurring patterns, and workflow so that a proposed task fits the project.
- Personalization: Learn what the developer values, tends to ignore, prefers, and explicitly does not want touched.
- Timely action: Intervene late enough to avoid interrupting an unfolding thought, but early enough that the help still matters.
- Seamless integration: Appear in the terminal, repository, or IDE where work already happens, rather than create another application the developer must remember to visit.
Observation identifies possible work; personalization and timing determine whether acting on it would actually help. Integration determines whether receiving that help introduces another context switch.
Combining these requirements is the difficult part. An agent has to understand the workflow, anticipate a need, and intervene at the right moment without breaking the flow it is supposed to support. Simply finding more tasks is insufficient if the resulting suggestions become a new queue to supervise.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Learning when not to ask
Google Nest offers a familiar analogy. After installation and configuration, the thermostat learns routines around leaving home, returning, sleeping, and waking. As those patterns become useful context, climate control requires less conscious management. The benefit is not merely that a temperature change can be automated; it is that the person no longer has to remember each change.
Korevec also points to bodily responses: heart rate rises during exercise, and a protective reaction can begin before someone consciously decides how to catch a fall. These are analogies for assistance without a deliberate command, not claims about Jules sharing their mechanisms. They make the desired experience recognizable: a coding tool that behaves more like an attentive collaborator than a command-line utility waiting for instructions.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From local cleanup to project awareness
The first level of proactivity begins inside an assigned task. Korevec describes Jules at the time of the talk as detecting missing tests, unused dependencies, and unsafe patterns, then fixing them while doing the requested work. Her analogy is an attentive sous-chef: keeping the kitchen clean, the knives sharp, and supplies ready so that the person cooking can concentrate on what comes next. The agent takes initiative within work that already has a purpose.
The second level expands the context to the developer and the whole project. A backend engineer might benefit from React help; a designer might need a database schema. Framework choices and deployment style become part of what the agent learns. The distinction is the scope of anticipation:
| Level | Context used | Initiative |
|---|---|---|
| One: sous-chef | The assigned task and nearby code | Clean up issues encountered during work |
| Two: kitchen manager | Working style and project conventions | Anticipate complementary help and next steps |
The kitchen manager understands the rhythm of the work, not just the task currently on the counter. From there, Korevec introduces a third level that the team was developing toward a planned December preview.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Connecting changes to consequences
The third level asks what a change does to users, performance, and product outcomes. Code context alone cannot answer all of those questions. Korevec describes a proposed collaboration among Jules, the design agent Stitch, and a data agent under development called Insights.
Each contributes a different view of the application:
| Agent | Proposed contribution |
|---|---|
| Jules | Identify what is breaking in the software |
| Stitch | Understand design and user interaction |
| Insights | Connect behavior to analytics, telemetry, and conversion rates |
Together, these perspectives could support proposals that cross conventional boundaries: a performance fix motivated by user experience, or a design change intended to prevent regressions. Live data would help organize the work around consequences rather than isolated code findings. This is the proposed integrated system, not a demonstration that all three agents were already operating together.
Broader context does not remove human direction. The developer still observes the agents, refines their work, intervenes when needed, and redirects mistakes. Korevec frames this level as alignment across the project lifecycle: agents and people sharing enough context to work toward the same outcomes.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Memory, critique, and visible verification
Jules’s starting point is code awareness: understanding the environment, frameworks, and project structure. Several supporting capabilities move it toward broader system awareness. Memory lets Jules write and revise project knowledge that the user can also inspect and edit. An adversarial critic agent challenges its output, checks code quality, and performs a full code review. These address different problems: memory retains context across work, while critique tests whether a proposed change deserves confidence.
Verification adds an inspectable artifact. Korevec describes Jules writing a Playwright script, taking a screenshot, and putting that screenshot back into the task trajectory for the developer to validate. That makes the result visible alongside the work that produced it, rather than leaving the developer with only an assertion that the change is correct. The team was also adding a to-do bot to find work already expressed in repository comments, plus best-practice suggestions as another source of candidate tasks.
Environment setup and context retrieval address two other reasons an agent might need to interrupt. An environment agent used internally for evaluations was being extended to understand and configure users’ environments. Just-in-time context supplies a task-specific cheat sheet when Jules gets stuck, allowing it to consult relevant information before asking the developer. These capabilities reduce the gaps the person otherwise has to fill manually.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From repository scan to reviewable suggestions
The preview follows a concrete workflow, although staging changes prevented the intended live demo. Korevec instead walks through the interface using the adk-python repository. Configuring and enabling proactivity first causes Jules to index the codebase and directory. It then surfaces candidate work, including TODOs and best-practice improvements, without requiring the developer to formulate each task.
A Python TODO illustrates why repository text can supply a useful starting point:
python
def mean_latency_ms(samples: list[float]) -> float:
# TODO: Reject empty samples with a clear ValueError.
return sum(samples) / len(samples)
Here, the comment already specifies an intended change. An agent can propose an empty-input guard and a test for it, rather than ask the developer to restate that intent in a prompt. This teaching example illustrates the TODO mechanism; the walkthrough’s findings come from its indexed repository. Discovering the comment creates a candidate task, not evidence that a fix has run.
The preview gives each suggestion a confidence signal: high in green, medium in purple, and low in yellow. Korevec explains these as Jules’s assessment of what it thinks it can achieve from the code and proposed work. They are qualitative signals, not calibrated success probabilities. The developer can select suggestions and start them manually, avoiding the work of composing a prompt for each one. Automatic starting is described as future work.
The review loop also supports rejection and inspection:
- Delete a suggestion that is unsuitable.
- Drill into a task to inspect the code it proposes to work on.
- Locate that code in the repository.
- Read the rationale for why the work is worth doing.
The rationale and location help the developer judge whether the agent understands the task. That is a concrete basis for trust: a proposal can be examined instead of accepted on the strength of its confidence label alone.
The December availability statement is a forecast made during the talk. The workflow shown here is a preview of repository discovery and human-controlled task starts, not confirmation that every part of the broader proactive-agent vision had shipped.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The Halloween project that still required babysitting
The remaining friction becomes tangible in Korevec’s Halloween project. Her family lives on a slow street in San Francisco, where many people walk past their Victorian house on Halloween. She and her husband built a six-foot animatronic head for the front of the house. He sculpted it from foam, epoxy, and fiberglass; their children called it the bald head. Its inspiration came from Pee-wee’s Big Adventure.
While he worked on the sculpture, Korevec used Jules to update firmware and work on stepper motors, LEDs, and sensors. She wanted to spend her creative energy on LED animations. Instead, bug fixes and library substitutions consumed much of the available time. In this project, she describes repeatedly prompting Jules, waiting ten minutes, and prompting again. That wait is her account of this particular workflow, not a general Jules latency benchmark.
What she wanted to delegate was the research and debugging between creative decisions: investigate the bug, find a fix, and keep the maintenance moving. She wanted eyes that followed people down the street and laser effects for Halloween. Those were ambitions, not demonstrated completed features. She ultimately shipped less than she had intended. The cost of supervision therefore showed up in the product itself: fewer of the creative ideas made it into the head. Closing that distance between tool friction and creative freedom is the purpose of the proactive workflow.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Question the workflow, not just the tool
Today’s AI products need not determine the shape of tomorrow’s software tools. Korevec urges builders to take larger steps rather than assume the current interfaces are permanent. She extends that provocation to Git, IDEs, and even familiar conceptions of code, suggesting that such conventions might change or disappear within six months to a year. This is a speculative challenge to inherited patterns, not a migration timetable.
The opportunity is to decide how software should be made when agents can contribute more than responses to explicit commands. Builders can question which parts of today’s workflow are essential and which merely reflect the limits of earlier tools. That places responsibility with the people designing these systems now: the future developer experience is something they get to build.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Connect a GitHub repository, submit a coding task, and review Jules's proposed plan.
An introduction to Google Labs' tool for generating interface designs and frontend code from prompts and images.
Further reading
Google's explanation of adversarial review within Jules's code-generation process.
APA's overview of task-switching experiments and how task complexity, familiarity, and preparation affect switching time.
Updates since the talk
- Jules's December proactive features releaseDocumentation
The December 2025 launch record for TODO-based Suggested Tasks, including its initial subscription and repository limits.
Instructions for enabling repository scans, inspecting proposed work, starting tasks, and dismissing suggestions.
Full transcript
Loading transcript…