Search Becomes an Agent Runtime

May’s hot topic was not simply “Google added more AI to Search.”

That story is too small.

The bigger shift is this:

Search is becoming an agent runtime.

For twenty-five years, Search mostly meant:

• parse a query
• retrieve documents
• rank links
• let the user decide what to trust and what to do next

Generative search changed the first half:

• retrieve sources
• synthesize an answer
• cite or summarize evidence

But the May 2026 direction pushes further:

• AI Mode turns search into a conversational, multimodal workspace.
• Search agents turn queries into background monitors and task runners.
• Gemini Spark points toward an always-on personal agent that can operate across a user’s digital life.
• Generated UI turns search results from “links” into task-specific interfaces.

That is a new architecture.

Not “better autocomplete.”

Not “chatbot inside a search page.”

A runtime where retrieval, synthesis, planning, UI generation, and action share the same surface.

Search in one sentence (the old contract)

Classic Search was a ranking system.

It returned documents and made the user responsible for:

• reading
• comparing
• judging credibility
• deciding what to do next

That was imperfect, but it had a clean boundary:

Search helped you find information.
You performed the action.

Agentic Search blurs that boundary.

Now the system may:

• summarize the web
• choose which sources matter
• decide when to ask follow-up questions
• build a custom interface
• run a background monitor
• and trigger tools or transactions

That is why this topic belongs in an architecture blog.

The product surface changed, but the deeper change is the control flow.

What “actionable retrieval” means

Retrieval used to end at “here are relevant documents.”

Actionable retrieval ends at:

“Here is the answer, here is the evidence, here is the proposed action, and here is the control boundary before anything changes.”

That adds three new responsibilities to the search stack.

This is where Search becomes much closer to an agent platform than a web page.

AI Mode: search becomes a workspace

AI Mode changes the shape of search from “query and links” to “conversation plus workspace.”

That matters because long, messy queries become normal:

• “Compare these options”
• “Use this file”
• “Look at these tabs”
• “Plan this task”
• “Keep checking this for me”

The query is no longer a short keyword string. It becomes a task packet.

A task packet can include:

• natural language intent
• files or images
• browsing context
• user preferences
• location or calendar context
• constraints (“cheap”, “near me”, “family-friendly”, “don’t book yet”)

Gemini Spark: the always-on agent pattern

Gemini Spark is interesting because it points to the other side of agentic search:

background continuity.

Search traditionally answered now.

An always-on agent can:

• monitor information over time
• notice changes
• summarize deltas
• remind you when something matters
• prepare actions for approval

This is not “one request.” It is a workflow.

A Spark-like agent needs a durable loop:

1. define the monitoring goal
2. retrieve periodically or subscribe to signals
3. compare against prior state
4. decide whether anything changed
5. notify the user
6. optionally propose action
7. log what happened

That looks less like Search and more like a tiny SRE system for your digital life.

The architecture blueprint: Search as an agent runtime

Here is the mental architecture I’d use for agentic search.

This is the difference between “AI search feature” and “search runtime.”

The hardest problem: evidence fidelity

Generative search has one uncomfortable property:

It collapses many sources into one answer.

That creates convenience, but also removes friction.

Users no longer inspect ten links. They read the synthesis.

So the system inherits editorial responsibility.

A useful internal invariant:

A cited answer should be decomposable into claims, and each high-risk claim should map to supporting evidence.

This is not academic neatness. It is how you debug hallucination in a search product.

Action gates: the line between answer and execution

Agentic Search must distinguish four levels of authority.

Generated UI: useful, but not a permission system

Generated UI is one of the most interesting parts of agentic search.

Instead of returning a static answer, the system can generate:

• comparison tools
• filters
• timelines
• calculators
• travel planners
• shopping flows
• dashboards

That is powerful because the UI can fit the task.

But generated UI also creates a governance problem:

Who decides what this UI is allowed to do?

A generated booking interface must still respect:

• consent
• payment rules
• cancellation policies
• data sharing boundaries
• accessibility
• auditability

Background agents: monitors need budgets and expiration

A search agent that watches the web for you is extremely useful.

It is also easy to forget.

That makes lifecycle management non-negotiable.

Every monitor should have:

• owner
• purpose
• sources / scope
• frequency
• budget
• expiration date
• notification channel
• stop button
• audit history

Without that, you get zombie agents:

• still searching
• still spending
• still notifying
• still holding permissions
• long after the user forgot why they existed

Failure modes I expect in agentic search

This is where the engineering discipline shows up.

What to measure

Agentic Search needs dashboards beyond click-through rate.

A minimal runtime dashboard should include:

If I were designing this system: my minimum viable contract

I would not start with “make Search more intelligent.”

I would start with contracts.

May takeaway

Search used to be an index.

Generative Search made it an answer engine.

Agentic Search turns it into a runtime.

Resources

FAQ