A spreadsheet agent that stops everything and waits 83 seconds for a human to respond is not an agent at all, it's a script with a phone line. When Google ADK agents pause, resume, and wait hours for a human, the architecture reveals a deeper truth: synchronous handoffs are the enemy of autonomous workflows. The fix, using webhooks and 202 receipts, frees the client while the agent keeps working, and that small change in protocol is what separates a toy from a tool. This is exactly the kind of infrastructure shift that makes other agent patterns possible, like letting a herder agent prioritize questions for you or packaging skills as versioned plugins for smarter governance.
The practical consequence is straightforward: any agent that holds a synchronous connection open for human input is fundamentally limited. An RSS agent that locked its client for 83 seconds is a mild example; wait times of hours or days compound into system failures. Webhooks invert the relationship. The agent posts a 202 receipt, the client moves on, and the agent resumes work when the human responds. This is not an edge case. Every workflow that requires human judgment, approving a data transformation, reviewing a generated chart, confirming a write-back to a source system, benefits from this pattern. The agent does not pause; it defers and continues.
What matters most is what this enables at scale. A synchronous model forces humans to be available on the agent's timeline. An asynchronous model built on webhooks and receipts lets the agent serve as a persistent worker that can wait gracefully. That distinction turns a spreadsheet agent from a novelty into a reliable collaborator. It also aligns with how modern data tools already work. Our piece on package coding agent skills as versioned plugins makes a similar point: structure determines capability. If your agent's communication pattern blocks the client, the agent is not ready for production. If it uses webhooks and receipts, it is ready to handle hours-long human delays without breaking the flow.
The specific detail to watch is the 202 receipt. Most teams implement webhooks for notifications, not for state management. Using the 202 as a lightweight promise that the agent will continue later is a design choice that forces discipline. It means the agent must track its own pending tasks and know when to resume. That is harder to build than a synchronous call, but it is the difference between an agent that feels like a colleague and one that feels like a pop-up prompt. If you are building agents that interact with humans, start with the assumption that the human will be slow. Design for that delay, and your agent will actually deliver on the promise of automation.