A pizza-ordering competition in San Francisco offered a compact demonstration of one of the hardest problems in agentic AI: a model can reason about what to do, but completing a real-world task requires current information that was never fixed in its training data. In an official Brave account of the AlphaSignal hackathon, developers were given 90 minutes to build an AI agent from scratch that could get a pizza delivered to 3 Embarcadero Center. The first successful delivery won, and the contest carried $2,500 in total prize money.
Brave says more than 700 engineers and technical leads from companies including Apple, AWS, Google, NVIDIA, Microsoft, OpenAI, Salesforce and Snowflake registered for the event, with more than 100 developers appearing in person on August 6, 2026. The challenge deliberately compressed the agent problem into something mundane: find a restaurant that actually exists nearby, determine what is usable now, choose an option and complete an action before the clock runs out.
Two of the winners, Preston Kwei and Rohan Gandotra, independently used the Brave Search API. Their implementations were different, but both exposed the same architectural requirement. An autonomous agent needs a reliable bridge between model reasoning and the changing outside world.
A pizza order is a deceptively difficult agent benchmark
A language model can know what pizza is, understand delivery and describe how someone might order dinner. None of that guarantees it knows which restaurants near the Embarcadero are currently relevant, whether a business is open, how far away it is or which option can actually deliver to a particular address at that moment.
Those are retrieval problems involving volatile external state. A restaurant can close, move, change its hours or stop accepting orders. A delivery service can alter availability. A model trained months earlier cannot safely infer those conditions from its parameters.
That makes the hackathon a useful stress test for agents. The challenge required the system to move from semantic intent—“get a pizza here”—to fresh discovery, selection and execution. Each stage can fail independently. A perfectly capable ordering agent is useless if it starts with a restaurant that no longer operates or cannot serve the destination.
Preston Kwei used search as a live discovery layer
According to Brave, Preston Kwei used the Brave Search API to identify nearby pizza options in real time, with Brave’s Place Search capabilities helping with local discovery. His agent then moved from retrieval to execution, completing the order through DoorDash in the Brave browser.
The architecture is notable because it separates two capabilities that are often collapsed under the label “AI agent.” Search answers the changing-world question: what options exist right now? Browser interaction answers the action question: what steps must be taken to transact with the selected option?
The model sits between them as the decision layer. It can interpret the task, use retrieved information to select a path and operate the browser, but it does not need to pretend that its internal training data contains current restaurant availability.
Rohan Gandotra turned search results into deterministic input
Rohan Gandotra approached the same challenge differently. Brave says he queried nearby pizza businesses by address through the Search API, programmatically scored the returned candidates according to distance and passed the ranked result back into the agent as structured input.
This design reduces the amount of judgment delegated to the language model. Instead of asking an agent to inspect arbitrary pages and infer which restaurant is nearest, conventional code performs a deterministic ranking step. The model receives a cleaner set of candidates on which to act.
That pattern is important beyond restaurant search. Agent systems do not need an LLM to perform every operation. Search, databases, APIs, filters, ranking functions and ordinary application logic can constrain the environment before the model makes a decision. In many production systems, reliability may improve when deterministic components handle what they can and the model is reserved for tasks that genuinely require flexible reasoning.
Search APIs are becoming infrastructure for agent grounding
The broader lesson from both implementations is that Web search can become an agent primitive rather than merely a user-facing destination. A human traditionally types a query, scans results and decides which page to open. An agent can call a search API, receive structured results, evaluate them and immediately use the information in a subsequent tool call.
That makes retrieval part of the execution pipeline. For a research agent, the next step might be reading documents. For a market-intelligence agent, it might be comparing current company information. For a travel agent, it might be checking businesses or destinations. For the hackathon, it was ordering dinner.
Brave positions its independent Web index as a grounding source for precisely these scenarios. The important architectural principle is broader than any single vendor: when the task depends on current external state, an agent needs a mechanism for acquiring fresh evidence instead of relying exclusively on memorized model knowledge.
Agentic search changes what Web visibility means
This transition has a significant implication for SEO and AI Search. The consumer of search information is increasingly capable of being software rather than a person. A business can therefore become discoverable inside a machine-mediated workflow even when the user never views a conventional search results page.
In the pizza example, the commercially meaningful event is not necessarily a blue-link click. It is whether a restaurant enters the candidate set from which an agent can make a purchase decision. That creates a new visibility layer between indexing and conversion.
NetContentSEO has examined a similar shift in its analysis of local search moving from ranking businesses toward agents taking actions on their behalf. Once an AI system can call, reserve, buy or otherwise transact, discoverability becomes operational rather than purely presentational.
Structured local facts become conversion infrastructure
An agent trying to order pizza needs facts that sound ordinary but become mission-critical in an automated workflow: business identity, address, distance, category, operating status and enough information to reach an ordering mechanism. Missing or contradictory information can prevent the business from surviving the selection process.
This makes entity consistency increasingly important. If a restaurant’s official site, local profiles and other authoritative sources disagree about its location or operating status, a human may resolve the ambiguity manually. An autonomous agent operating under time constraints may simply choose another candidate.
The same principle applies far beyond local restaurants. A product agent needs accurate price, inventory and compatibility data. A travel agent needs current availability and policies. A procurement agent needs specifications and commercial terms. Agentic visibility therefore depends partly on whether the underlying facts are fresh enough and structured clearly enough to support action.
The open Web becomes a live sensor for models
Large language models are powerful partly because they compress enormous amounts of learned information into parameters. But those parameters are not a live database. Search provides a complementary capability: observation of information that changes after training.
The distinction is especially important for tasks with temporal sensitivity. Current events, prices, market conditions, business hours, software releases and local availability can all change faster than a model can be retrained. A search layer allows the agent to query the current Web at execution time.
This is why retrieval is becoming central to agent architecture. The model provides reasoning; the retrieval system provides external evidence; action tools change state in the outside world. The useful agent emerges from the orchestration of all three.
Fresh retrieval also creates a verification problem
Connecting an agent to live search does not automatically make every decision correct. Search results can be incomplete, sources can conflict and websites can contain stale information. A production agent still needs strategies for evaluating source quality, reconciling contradictions and deciding when a piece of evidence is sufficient to justify an action.
The pizza hackathon could optimize for speed because the consequences of a poor choice were small. A legal, financial or enterprise research agent faces a different risk profile. It may need primary-source preferences, timestamps, multiple-source verification, confidence thresholds or explicit human approval before acting.
The underlying architecture nevertheless remains recognizable. Retrieval gives the model evidence it did not possess; validation determines whether that evidence is trustworthy enough; action uses the resulting decision.
SEO may increasingly optimize for machine selection before human persuasion
Traditional commercial SEO assumes that the search result attracts the human, the human visits the page and the page persuades them. Agentic workflows can reorder that sequence. A machine may retrieve and filter businesses first, with the human seeing only the shortlist or final recommendation.
That does not eliminate the need for persuasive websites. Humans can still inspect sources, override recommendations and complete parts of the transaction themselves. It does mean that some commercial competition can occur upstream, inside retrieval and decision logic that the user never directly sees.
For businesses, this raises a practical question: can an automated system accurately understand what the company offers, where it operates, whether the relevant product or service is available and what action should happen next? If the answer is unclear, the business may lose before conventional conversion optimization begins.
Agent-callable Web infrastructure is becoming a separate optimization layer
Search APIs are only one mechanism through which agents can interact with online information. Websites and platforms are also exposing structured actions, tools and machine-readable interfaces that let agents do more than interpret a visual webpage.
NetContentSEO has covered this emerging layer in its analysis of WebMCP and agent-callable websites. The common direction is clear: the Web is evolving from pages designed primarily for humans toward an environment in which software agents can discover information and invoke actions programmatically.
Search APIs occupy the discovery side of that architecture. Browser automation and structured action protocols occupy the execution side. Businesses that become legible to both layers are better positioned for workflows in which an AI system mediates the customer journey.
Brave’s involvement needs an important disclosure
The primary account comes from Brave, and two winning teams used Brave technology, so the source has an obvious commercial interest in highlighting the Search API. Brave itself includes a disclosure: several team members attended the hackathon to observe and answer technical questions, but the company says winners were judged only by how quickly their live-built agents delivered a pizza and that Brave’s attendance had no bearing on the result.
That disclosure matters when interpreting the event. The hackathon demonstrates that Brave Search API was useful to at least two successful implementations under the contest conditions. It does not establish that Brave is universally the best retrieval system for agents or that the same architecture will outperform alternatives in every domain.
The stronger conclusion is vendor-independent: two teams confronted with a live-world agent problem independently introduced current Web search into the loop.
The real benchmark was not pizza—it was grounding plus action
The AlphaSignal challenge compressed an increasingly important software architecture into 90 minutes. The agent needed to understand a goal, obtain information that was not safely available from static model knowledge, reduce the available choices and then interact with a live service to produce a physical result.
Preston Kwei’s implementation emphasized discovery followed by browser action. Rohan Gandotra’s emphasized structured retrieval followed by deterministic ranking. Both demonstrate that capable agents are likely to be compositions of models and external systems rather than isolated language models expected to know everything themselves.
For AI developers, that makes live Web access a grounding layer. For SEO teams and businesses, it changes the meaning of visibility: being retrievable can become the first step in an automated transaction rather than merely the first step toward a human click.
A pizza arriving at 3 Embarcadero Center is a playful result. The architecture behind it is not. As AI agents move from answering questions to performing tasks, the Web increasingly needs to function as both their source of current evidence and the environment in which their decisions become actions.