New Jersey Tech, Business, & Creative Resources
Google’s New Chrome AI Wants to Make Your Website Smarter. What Exactly Is it?
Without sending every interaction to an AI server, Google wants Chrome to make websites smarter. It’s an appealing idea. By interpreting your search, selecting the right filters, and helping you find what you’re looking for, your browser helps you find what you’re looking for. No cloud processing, no unnecessary data sharing, and no expensive AI infrastructure.
There’s one problem.
The AI model currently built into Chrome gets the answer wrong more often than right.
According to research published by French SEO agency Resoneo on October 8, 2026, Chrome’s proposed Decisions API achieved just 37.9% accuracy across 1,365 test decisions using its existing EmbeddingGemma engine.
Other models performed much better. Gemma 4, for instance, achieved an accuracy of 85.2%. Unfortunately, better results come with slower processing and substantially higher hardware requirements.
The good news? As of now, the Decisions API isn’t available for everyday Chrome users. As such, there’s still time for developers to experiment, and for Google to fix its shortcomings.
But these early results raise an important question: Is browser-based AI ready to make decisions on behalf of users?
What Is Chrome’s Decisions API?
Using the Decisions API, Google hopes to bring AI-powered decision-making directly to the browser.
By giving Chrome a set of predefined choices, websites can let its AI select the most appropriate answer rather than asking a large language model to generate text for them.
Imagine visiting a car dealership’s website and typing: “I’m looking for a fuel-efficient SUV with enough room for three kids.”
Rather than selecting fuel economy, seating capacity, and body type manually, Chrome could interpret the request and recommend relevant filters. If someone searches for a pet-friendly mountain cabin with a pool on a hotel booking website, the website could perform something similar.
The important distinction is that the AI chooses from existing options rather than inventing new answers.
Using the website, you can type your search query, ask a question, and see the answers that are available. With Chrome, the request is processed locally and the selections, along with confidence scores, are returned. In theory, this approach offers several advantages:
- Faster interactions without repeated server requests.
- Better privacy because user input stays on the device.
- Lower operating costs for website owners.
- A shared browser-based AI model instead of separate models downloaded by every website.
Google introduced the Decisions API proposal on October 1, 2026.
By October 6, the company had added the experimental API to Chrome’s code and released EmbeddingGemma 2 alongside MediaPipe Decision Maker, a library developers can already experiment with independently.
However, the Chrome implementation remains experimental.
According to the Chrome Status entry, it is currently limited to desktop Canary builds behind an advanced set. But it still returns an “unavailable” response because no decision engine has been connected to the browser.
In other words, don’t expect Chrome to make shopping decisions for you tomorrow.
Why Google Wants AI Making Decisions Inside Chrome
As Google explains, not every AI task requires a huge language model.
When a website needs to find out whether someone wants a sedan, SUV, or pickup truck, a lengthy response is unnecessary. Google argues that using a large generative model for this kind of classification can require 10 to 50 times more computing resources than necessary.
This could be handled more efficiently with a smaller model that simply selects from predefined answers.
This approach is similar to Jev, a specialized decision model released by TypeSafe AI in September 2026. Although Chrome doesn’t use Jev, Google has explored three possible engines:
- EmbeddingGemma: The lightweight model is already available within Chrome.
- Laya: An open-source decision model similar to Jev.
- Gemma 4: A larger, more capable model that delivers stronger results but requires more resources.
Additionally, Resoneo suggests that Google’s broader strategy may be shifting.
With Topics and the Classifier API abandoned, Google appears to be moving towards a system where publishers define their own categories and let browser-based AI interpret user intent. Eventually, that could have implications for search, personalization, and advertising.
However, neither Google’s Decisions API proposal nor its embedding API status page explicitly identifies advertising as a use case. For now, those broader implications remain speculative.
Resoneo Tested Chrome’s AI. The Results Weren’t Pretty.
Using Chrome’s source code, Resoneo recreated three decision engines to see how the proposed API would perform outside of Google’s demonstrations.
Using 11 simulated websites, researchers developed questions covering categories like automobiles, hotels, and home appliances. After that, they examined 414 searches and messages in French and English, resulting in 1,365 individual responses.
In addition to MediaPipe, two other models were tested. Here’s how the engines compare.
| Engine | Correct answers | Time per decision |
| EmbeddingGemma in Chrome | 37.9% | 0.2 seconds |
| EmbeddingGemma in MediaPipe | 53.0% | Not reported |
| Laya | 63.8% | 1.5 seconds |
| GLiNER (MediaPipe only) | 84.7% | 1.2 seconds |
| Gemma 4 | 85.2% | 2.4 seconds |
There is a familiar trade-off between speed and accuracy in AI.
As a result of embeddingGemma, decisions were made in just 0.2 seconds on average. Because of its 37.9% accuracy, it is hard to trust for anything that automatically changes a user’s experience.
Gemma 4 delivered the strongest accuracy at 85.2%, but it averaged 2.4 seconds per decision and required more than 4 GB of memory on the user’s computer.
Its confidence scores were also more meaningful. About 80% of its answers received confidence scores above 0.85, and 91% of those high-confidence answers were correct.
GLiNER came remarkably close at 84.7% accuracy, with a faster average response time of 1.2 seconds. However, it performed less reliably on French queries, where accuracy fell to 81.5%.
It also weighs nearly 1 GB, doesn’t yet load in MediaPipe’s browser implementation, and isn’t part of Google’s planned Chrome engines.
As of October 5, Laya has been in Chrome’s code, but it is not yet capable of being run.
The takeaway? Better models exist, but none offers a simple, production-ready solution for Chrome’s proposed implementation.
Why Does Chrome’s EmbeddingGemma Get So Many Answers Wrong?
According to Resoneo, there are three recurring problems. And they’re more concerning than an occasional incorrect filter.
1. User intent is rarely addressed by Yes/No questions.
Whenever a user’s request changes, a decision model’s answer should be updated. That sounds obvious.
However, Resoneo found that 14 out of 18 yes/no questions produced the same answer no matter what people searched for.
For example, someone looking for a mountain chalet for eight people could find filters for pets, swimming pools, and parking selected automatically, even without requesting those amenities.
That’s not particularly intelligent. Essentially, it’s a guessing system that appears personalized without knowing what the visitor is truly interested in.
2. The model loves choosing “other.”
Another major problem was created by catch-all answers.
When options included vague categories such as “other” or “any,” EmbeddingGemma selected them approximately 70% of the time. Those selections were correct in only 26% of cases.
That’s a serious issue for ecommerce and search interfaces, where broad fallback categories can hide relevant results rather than help users discover them.
3. Its confidence scores are nearly useless,
Google’s examples suggest applying an AI-generated decision only when its confidence score exceeds 0.85. Reasonable enough.
Except Resoneo found that only one of 1,365 decisions exceeded that threshold.
As a result, confidence-based automation is virtually useless in the current implementation. By lowering the threshold, more decisions could be taken, but they wouldn’t necessarily be more accurate. And automatically changing filters based on unreliable predictions is a good way to frustrate visitors.
The Bigger Problem Might Be How Chrome Asks the Question
The most interesting part of Resoneo’s research is here.
In some cases, the poor results are not entirely attributable to the model. Chrome constructs its input by combining the user’s search with the website’s introduction and the decision question into a single sentence. As a result, the actual search accounts for roughly one-fifth of the text the model evaluates.
In other words, different searches look surprisingly similar.
MediaPipe takes a simpler approach by comparing the search text directly. Using the same underlying model file, that change alone increased accuracy from approximately 38% to 53%.
That’s a 15-percentage-point improvement without switching models.
On October 7, a Google reviewer requested that Chrome’s implementation align with MediaPipe.
Independent research also supports the general finding. Natzir Turrado conducted a separate test involving 75 English and Spanish questions. He reported 39% accuracy using Chrome’s combined-sentence approach versus 69% when evaluating the question alone.
The two studies aren’t directly interchangeable, but both suggest that input formatting has a substantial impact on accuracy.
Sometimes, AI doesn’t need a bigger brain. It needs a better question.
EmbeddingGemma 2 Introduces Another Set of Problems
The Decisions API isn’t the only browser-based AI feature affected by these models.
EmbeddingGemma also powers Chrome’s proposed embedding API, which classifies webpages by topic and compare text based on semantic similarity. Resoneo tested the current model against EmbeddingGemma 2 using 151 real webpages from 45 websites across 12 topics.
At first glance, the results looked encouraging. Both versions correctly classified 95.4% of the pages. But accuracy wasn’t the whole story.
Similarity Scores Changed Dramatically
With EmbeddingGemma 2, differences between top classification options were much narrower. About half of the difference between the winning and runner-up topics was closed. Despite being unrelated, even unrelated texts received similarity scores in the range of 0.70.
Consider what that means for a website using fixed thresholds.
According to Resoneo’s test, a similarity threshold of 0.62 that previously didn’t flag any ordinary pages would now flag every ordinary page. The classification accuracy might look unchanged, but the scoring behavior is dramatically different.
Existing Embeddings Won’t Be Compatible
There’s another catch. The two model versions produce incompatible embeddings.
When Resoneo mixed signatures generated by the different versions, classification accuracy collapsed to 13%. In other words, developers cannot just upgrade the model and continue to use their existing embedded models.
They’ll need to regenerate them. And if a website has already processed thousands of pages, that could become a significant migration project.
More Context Didn’t Necessarily Improve Results
Resoneo also discovered several counterintuitive behaviors. EmbeddingGemma 2 was two to five times slower than the previous version. When three examples per topic were added, classification accuracy decreased by 11 percentage points, whereas a single descriptive sentence performed better.
On the Decisions API tests, configuration changes that increased the original model’s accuracy to 58% produced only 45% accuracy with version 2. Even longer input wasn’t always helpful.
When classifying lengthy webpages, analyzing only the first 1,500 words achieved 96.6% accuracy, compared with 91.4% when processing the entire page.
It’s another reminder that feeding an AI more information doesn’t automatically produce better answers.
What Website Owners and Developers Should Do Now
Although the Decisions API isn’t ready for widespread deployment, developers shouldn’t ignore it. Those experimenting with browser-based artificial intelligence can learn several lessons from Resoneo’s findings.
1. Give every answer a clear description.
Don’t assume the model understands a category from its label alone. Instead of simply listing “SUV,” explain what the category represents.
Resoneo found that descriptions improved accuracy by 13 percentage points. With only a few changes, that’s a considerable improvement.
2. Keep unnecessary context out of the request.
In fact, having more context can make the decision harder. Leaving the site’s introductory “context” field empty improved multiple-choice accuracy by 10 percentage points in Resoneo’s tests.
Rather than giving the model a sales pitch, give it the information it needs.
3. Avoid vague choices and yes/no questions.
If possible, use multiple-choice questions with clear descriptions. As much as possible, avoid categories such as “other” or “any,” which are often overselected by the current model.
Likewise, don’t rely on yes/no questions until the underlying behavior improves.
4. Suggest filters instead of automatically applying them.
For website owners, this is probably the most important recommendation. You can suggest a filter for pet-friendly hotels if the AI thinks someone wants that.
Don’t silently activate it. Visitors should remain in control, particularly when the model’s confidence scores aren’t dependable.
5. Prepare for model changes.
Whenever possible, save the original source text and the model version that generated the embedding. This allows you to rebuild your database when Google updates the model. Alternatively, your stored data could become incompatible with new queries after an upgrade.
6. Experiment With MediaPipe Before Chrome’s Release
Developers interested in testing the technology can use Google’s MediaPipe Decision Maker web guide.
Unlike Chrome’s proposed shared-model approach, MediaPipe currently requires each website to download its own model. That means approximately 165 MB for EmbeddingGemma 2 or 678 MB for Laya.
In addition, don’t assume that confidence scores generated by MediaPipe will be directly comparable to those generated by Chrome.
How Much Should We Trust These Results?
Resoneo’s findings are useful, but they aren’t the final word on Chrome’s Decisions API.
For starters, a single researcher created and labeled the test queries. That introduces the possibility of subjective judgments or dataset bias. The experiments also evaluated reconstructed engines rather than a finished, publicly available Chrome feature.
Before releasing the models, input format, or implementation, Google could make changes. Moreover, the difficulty of the task matters greatly.
Consider Google’s dinosaur game demonstration. All five tested models correctly handled its eight possible sentences. If you compare that to more complex, realistic searches, EmbeddingGemma’s accuracy drops to around 53% to 58%.
Recognizing a handful of predictable commands is considerably easier than interpreting messy human language. Resoneo is also an SEO agency conducting its own research, rather than an independent standards organization.
However, Turrado’s separate testing supports its central observation: Chrome’s input construction appears to be degrading performance. Although they shouldn’t be regarded as permanent benchmarks, the results deserve attention.
Chrome’s Decisions API Has Potential. But Accuracy Comes First.
Google’s broader vision makes sense.
Not every website needs a massive generative AI model. Eventually, smaller, locally running models will be able to deal with many everyday interactions. That could make websites faster, cheaper to operate, and more privacy-friendly.
But there’s a difference between demonstrating that browser-based AI can make decisions and proving that those decisions are worth trusting.
At the moment, Chrome’s existing engine struggles with realistic requests, chooses vague fallback options frequently, and produces confidence scores that are of little practical use. While better alternatives perform significantly better, they introduce their own issues related to memory, speed, and browser compatibility.
Developers should experiment, improve choice descriptions, and keep users in control.
Google’s challenge is clear: Make the technology reliable before encouraging websites to automate decisions around it.
Because AI that selects the wrong filters faster isn’t making the web smarter.
It’s just making mistakes more efficiently.
