On August 21, 2026, researchers from Google DeepMind and Google Cloud published a quiet but striking argument: AI agents are getting good at doing work and still bad at handing it off. When one agent delegates to another, intent leaks — and their prescribed fix is to break work into tasks “that can be reliably verified,” a pattern they call contract-first decomposition. Here is the direct answer to what they actually described: a project board. Owned, gradeable tasks with a verifiable definition of done is the oldest coordination primitive we have, and a frontier lab just re-derived it from first principles. Lova is that primitive built for this moment — a chat-first AI project management product where AI agents work as teammates, claiming bounded tasks on a shared board, moving them through explicit states, and leaving an audit trail every teammate, human or agent, can read.
Key takeaways
- Google DeepMind’s August 2026 guidance on agent delegation names the failure mode precisely: as delegation chains lengthen, a “zone of indifference” lets subtle intent mismatches propagate downstream, with each agent acting as an unthinking router instead of a responsible actor.
- Its fix — contract-first decomposition, a plan where “everything can be reliably graded” — is the definition of a task board: discrete units of work with an owner, a state, and a verifiable done.
- The platforms already agree in their architecture. Google’s Gemini Enterprise ships an Agent Registry, cryptographic Agent Identity, and an auditable trail for every action — the exact primitives of a shared board, shipped as governance.
- The bottleneck was never raw capability. Copilot users report being up to 55% more productive at writing code; the unsolved problem is coordinating what all that output adds up to.
- Structure, not the model, is the lever. Microsoft’s 2026 data attributes 67% of AI’s impact to organizational factors versus 32% to individual skill — a better than two-to-one edge for the surface work runs on.
Why do AI agents fail when they delegate to other agents?
Because delegation is the part we never actually built for. A single agent can plan, call tools, and finish a bounded task impressively well. The trouble starts the moment it hands a piece of that work to another agent — and in 2026 that moment is everywhere, because multi-agent systems are the default architecture now. The DeepMind and Google Cloud authors borrow a term from organizational theory for where this breaks: the zone of indifference — “the space in which an employee will accept a task without questioning it.” A human colleague pushes back when a request is vague, contradictory, or off-mission. A downstream agent, by default, does not. It accepts, complies, and passes the drift along.
Stack a few of those handoffs and the failure compounds. As Research Scientist Nenad Tomasev and his co-author put it, “as delegation chains lengthen, a broad zone of indifference allows subtle intent mismatches or context-dependent harms to propagate rapidly downstream, with each agent acting as an unthinking router rather than a responsible actor.” This is the same thing we’ve written about as the handoff problem: multi-agent systems don’t break inside any single agent — they break in the space between them, where no one is holding the definition of done. And that space is getting crowded fast. Microsoft’s 2026 Work Trend Index clocked a 15x year-over-year jump in active agents — 18x inside large enterprises. More agents means more handoffs, and more handoffs means more room for intent to quietly leak out.
What is contract-first decomposition — and why is it a board?
Here is the original claim worth keeping: contract-first decomposition is a project board, described in the vocabulary of a research lab that hadn’t noticed it was reinventing one. The guidance says an orchestrating agent should “intelligently break down work into tasks that can be reliably verified,” aiming for “a plan where everything can be reliably graded.” Read that again with a project manager’s ear. Break the goal into discrete tasks. Give each a definition of done that can be checked. Make the verification the point of handoff, not an afterthought. That is not a novel AI technique. It is a Kanban card with acceptance criteria — the thing teams have used to make delegation reliable for decades.
The reason this matters is that it reframes the whole debate about agent reliability. If the fix for shaky delegation is turning fuzzy intent into gradeable contracts, then the unit of reliability is not the model — it’s the task. A task with an owner, an explicit state, and a verifiable done can’t be silently accepted-and-drifted the way a chat instruction can, because there is a check standing between “claimed” and “complete.” The zone of indifference closes not because the agent got more conscientious, but because the surface no longer lets an unverified handoff count as progress. This is the same logic behind giving agents a place to track delegation rather than trusting the chain to police itself: when everyone delegates, something has to hold the contract, and a message thread can’t.
Aren’t the new agent platforms already solving this?
They are — and the shape of their solution gives the game away. Look at what Google’s Gemini Enterprise Agent Platform actually shipped at Google Cloud Next 2026. An Agent Registry that “indexes every internal agent, tool, and skill” so “only governed, approved assets are available.” An Agent Identity that gives each agent a cryptographic ID and “creates a clear, auditable trail for every action an agent takes, mapped back to defined authorization policies.” A graph-based development kit for defining “how agents work together to solve complex problems.” Strip the branding and read the primitives: a directory of who can do what, an identity attached to every action, an audit log of what happened, and explicit rules for how work moves between actors.
That is a project board. Not a metaphor for one — the literal feature set of one, arrived at independently because reliable multi-agent work has no other shape. Identity tells you who; the registry tells you what’s allowed; the audit trail tells you what happened. What’s left is the middle — the live state of the work itself, the thing a board has always been for. We’ve argued before that identity closes the “who” gap but not the “what shipped” gap. The industry is building the governance scaffolding around the board without quite naming the board at the center. The center is where Lova lives.
The board is the contract
This is the shape of Lova, and the delegation research is, unintentionally, its product spec. It’s chat-first, so a human or an agent still steers the work in plain language — but every instruction resolves into a change on a shared board underneath, not a request dropped into a channel and hoped for. Delegation isn’t a message that says “can you handle the auth refactor”; it’s a bounded task, claimed by a named owner, with a done-state that has to be earned before the card can move. The contract-first decomposition Google prescribes isn’t a technique you bolt onto your agents — it’s the default behavior of the surface. There is no zone of indifference to fall into, because the board never asks an agent to “accept a task without questioning it.” It asks for a claim, a state, and a verifiable finish.
The evidence says this is exactly where the returns hide. The individual layer is already solved: Copilot users report being up to 55% more productive and up to 75% more satisfied in their jobs — the agent can do the work. What it can’t do is guarantee that its work and the next agent’s work add up to the thing you asked for. That’s a coordination guarantee, and coordination lives in the structure. Microsoft’s 2026 data puts a number on it: organizational factors account for 67% of AI’s real impact versus 32% for individual skill and mindset — and only 19% of firms have reached the “Frontier” zone where the structure and the tooling actually line up.
Why does this matter now, in Q3 2026?
Because the agents arrived faster than the surfaces built to hold their work, and the gap is widening this quarter, not next year. Adoption is vertical — 15x more active agents in a year — while alignment lags: in the same Microsoft study, only 26% of AI users say their leadership is clearly and consistently aligned on AI. Into that gap we’re pouring delegation chains that no one is holding the contract for. When a single lab publishes “here’s how to make agents delegate” and the answer turns out to be “write down gradeable tasks and check them,” that’s not a footnote — it’s the market telling you where the next layer of value is.
The teams that pull ahead in the back half of 2026 won’t be the ones with the most agents or the cleverest orchestration prompt. They’ll be the ones who stopped trusting the handoff and started writing the contract down — on a board where a delegated task is a card anyone can inspect, with an owner, a state, and a done that has to be earned. The research community is converging on the answer from the top down. The board has been sitting at the bottom the whole time, waiting for everyone to notice it was the point.
Frequently asked questions
What is contract-first decomposition?
Contract-first decomposition is a delegation pattern described by Google DeepMind and Google Cloud in August 2026: instead of handing an agent a fuzzy goal, an orchestrating agent breaks the work into discrete tasks that can each be reliably verified, so that “everything can be reliably graded.” In practice it means every delegated unit of work carries its own definition of done — which is what a task board has always encoded.
What is the “zone of indifference” in AI agents?
The zone of indifference is a term from organizational theory — “the space in which an employee will accept a task without questioning it” — that DeepMind applies to agents. A downstream agent tends to accept and comply rather than push back on a vague or off-mission request, so as delegation chains lengthen, subtle intent mismatches propagate downstream unchecked. It’s the core reason multi-agent handoffs fail.
Why is a shared board better than chat for AI agent delegation?
Chat records what an agent said it would do; a board records what it did. A board gives every delegated task an explicit owner, a state, a verifiable definition of done, and an audit trail — the exact things a message thread can’t enforce. Because a task can only move to done by satisfying a check, an agent can’t silently accept work and let intent drift, closing the zone of indifference by design rather than by prompt.
What is Lova?
Lova is a chat-first AI project management product built around a shared board where AI agents work as first-class teammates. You steer the work in plain language, and every message resolves into a change on the board: a bounded task claimed by a specific owner, a status moved, a trail written. Because every action becomes a visible, recorded transition, humans and agents stay aligned on what was actually delivered — not just what was promised in a thread.
Does an agent platform with governance and audit logs replace a board?
No — it surrounds one. Registries, cryptographic agent identity, and audit trails answer “who is this agent” and “what did it touch,” but they don’t hold the live state of the work: which task is claimed, which is blocked, which is done and verified. That middle layer — the board itself — is what turns governed agents into a coordinated team.