Stop managing AI. The case for proactive agents.
Length: • 5 mins
Annotated by Miguel
What a dishwasher, cognitive science, and a six foot animatronic head taught me about the future of coding agents.
A few months ago, our dishwasher broke. While it was getting repaired, my husband promised to wash the dishes by hand. Every night I still found myself asking whether he had done them. I was not doing the work, yet the mental load was still mine. The reminders, the follow ups, the background monitoring. It all sat in my head.
This is where we are with most AI coding agents today.
Developers finally have tools that can generate code, scaffold projects, write tests, refactor and run tasks without supervision. On paper that sounds like progress. In practice we are still managing them. We are still checking on their work, tracking state, and juggling more than we should. The hidden tax of async tools is that the mental overhead remains with the human.
That gap is what I have been working to close. I started with asynchronous execution. Now I am focused on something more important: true proactivity. I spoke about this at the AI Engineer Code Summit in New York, and I believe it is the next frontier for developer tools.
Here’s why.
Humans work in sequence
There is a basic truth about developers. We are not parallel machines. We juggle several goals, yet we move through them one at a time. Every interruption creates a recovery cost. Research shows that what looks like multitasking is really rapid switching, and switching destroys productivity. You lose time every time you reload a mental stack.
That’s why asynch tools were a meaningful step. You could hand off a long running task to Jules and keep moving. However, what we learned is that removing the waiting is not enough. Developers don’t want to run the task and manage the task. They want to build.
If humans work in sequence, we need tools that can think ahead of us.
Trust is the foundation
Everyone has seen the tweet of a developer with fifteen agent tasks each running in their own terminal window being managed on multiple monitors. It looks impressive. It also looks exhausting. Managing an agent is not the goal. Getting the work done is.
We need collaborators we trust. Tools that understand your goal, the context around it, and the consequences of decisions. Systems that can see what is missing, fill in the gaps, and keep momentum without constant direction.
The future I want is simple. Jules should handle the dishes without being asked every night.
Why reactive tools are not enough
Most AI tools today wait for you. You type a prompt and receive a response. You enter some text and get an autocomplete. That works for small tasks. The limitation becomes clear once the surface area of the work grows. Each new step requires a new instruction. Each instruction requires monitoring.
If compute is no longer the limiting factor, the model changes. Instead of one assistant sitting idle between commands, you could have many small processes watching your workflow. They could notice friction, spot regressions, update configs, prepare migrations, and fix issues before you even think to ask.
True proactivity starts with paying attention.
What a proactive system needs
A proactive system requires four core abilities.
Continuous observation. It must understand what is happening in your project. File changes, frameworks, environment, style, patterns, and intent.
Personalization. It must understand how you prefer to work. Where you are confident. Where you tend to slow down. What you avoid. What you consider complete.
Timely action. The system needs to step in at the right moment. Not too early. Not too late. The timing is part of the intelligence.
Seamless integration. It should live inside your editor, your terminal, and your repo. If you have to remember to use a separate tool, it is no longer proactive.
These are simple to describe and difficult to achieve. When they come together, the experience feels natural.
We already know what proactivity feels like
We experience proactive systems every day.
A Google Nest thermostat adjusts before you notice the temperature shift. A great server refills your water without interrupting your conversation. Your balance corrects before you are aware of falling.
Proactivity does not feel futuristic. It feels human. That is the standard we should aim for in our tools.
Level 1: The attentive sous-chef
This is where Jules, Google’s coding agent, is today. It detects missing tests, unused dependencies, unsafe patterns, regressions, and fixes them while continuing the task you asked for. It keeps the workspace clean and ready so you can stay focused on what you came to build.
Level 2: The kitchen manager
The next level is contextual awareness. Jules and Stitch begin to understand how you work. They learn your patterns and the parts of the codebase that slow you down. A backend engineer gets help with React before asking. A designer gets help with schema changes before getting stuck. The system adapts to your pace.
Level 3: Collaborative intelligence
At the highest level, coding intelligence and product intelligence converge. Jules understands what is happening in code. Stitch understands how users interact with it. And they’re connected with production data measuring real outcomes. Together they can propose improvements that cross traditional boundaries, while the human stays in control of the final decisions.
This is not autonomy. This is alignment.
Where we are with Jules today
Right now Jules has strong code awareness. It understands environments, frameworks, and project structure. It can simulate behavior, run reviews, track regressions, and detect accessibility issues. We are deepening that with:
- A memory system you can edit and control
- A critic agent that helps Jules evaluate its own reasoning
- Playwrite based verification that keeps output aligned with intent
- Coming soon: a proactive code comment based system for identifying tasks
These pieces move Jules closer to acting like a teammate instead of a tool.
A Halloween project that made this clear
This past Halloween, my husband and I built a six foot animatronic head for our front window. He sculpted the structure out of apoxy, styrofoam and fiberglass. I spent two days working with Jules on the firmware for the stepper motors, sensors, and LEDs. I wanted to focus on the creative parts. I ended up spending. most of my time debugging and swapping libraries.
I wanted Jules to handle the tedious bits on its own so I could focus on the ideas and creativity. That gap between ambition and execution is exactly what we’re working to close.
The path forward
Proactive agents are the next shift in developer tools. They reduce mental load, smooth the rough edges of the workflow, and let developers spend more time building the work they care about. This is where I am focused. This is where Jules is going. And this is the future I want to help shape.
The next era of AI coding tools will not be reactive or supervisory. It will be collaborative. It will be proactive.