Relevance Engineering Archives - iPullRank

Moving from a Google-shaped Web to an Agent-shaped Web: A Refutation of Misinformation about Chunking

Mike King — Thu, 15 Jan 2026 12:00:00 +0000

Back in 2011 when I first started writing SEO blog posts for Moz, despite their popularity I was writing walls of text because that was my nature. Then-CMO Jamie Steven instructed me to read Cyrus Shepard’s 10 Super Easy SEO Copywriting Tips for Improved Link Building for direction on how I should structure what I write for better performance.

In the article, Cyrus comes out swinging showing this visual comparison of a wall of text versus a very well-structured piece of content with lots of formatting and imagery. Using data to drive the point home, he shows how the two posts (by the same great internet marketer) had dramatically different performance, with 62X the external link capture and nearly 4X the time on page.

I was hooked and those insights have stuck with me ever since. In fact, you can trace back elements of anything I’ve written over the last 14 years to the formatting lessons of that classic post. I’d go as far as to say I think more about these principles than I do so-called SEO “best practices.”

Part of why what Cyrus outlined resonated with me so much is that the principles just make sense. Conceptually, it all harkens back to everything we all learned about how humans interact with information when we read “Don’t Make Me Think.” Over time, I’ve seen the specificity and better content UX highlighted yield better performance on any human-driven metric we measure as well as more visibility search engines and large language models.

But…Google Says Don’t Break Your Content Into Bite-Sized Chunks

Recently, on the Search Off the Radar podcast, Danny Sullivan shared his opinion on “chunking” as a tactic to drive visibility in AI Search surfaces (emphasis mine).

“One of the things I keep seeing over and over in some of the advice and guidance and people are trying to figure out what do we do with the LLMs or whatever, is that turn your content into bite-sized chunks, because LLMs like things that are really bite size, right?

So we don't want you to do that. I was talking to some engineers about that. We don't want you to do that. We really don't. We don't want people to have to be crafting anything for Search specifically. That's never been where we've been at and we still continue to be that way. We really don't want you to think you need to be doing that or produce two versions of your content, one for the LLM and one for the net.”

After I laughed to myself in the graveyard of AMP POVs and technical specifications, I turned it back on.

He continued, pre-empting the “but it works, I’m going to do it anyway” argument Danny offers (emphasis still mine):

“Let's assume that, in some edge cases, let's even assume maybe in more than some edge cases, you're finding you're getting some advantage here. Maybe tiny degree measure. No, this is my secret weapon. It's doing it." Great. That's what's happening now. But tomorrow the systems may change.

So you've gone through all this effort. You've made all these things that you did specifically for a ranking system, not for a human being, because you were trying to be more successful in the ranking system, not staying focused on the human being. And then the systems improve, probably the way the systems always try to improve, to reward content written for humans. All that stuff that you did to please this LLM system that may or may not have worked, may not carry through for the long term.

So was that the best use of your time and your energy? Was that the best use of putting turmoil into your marketing department, your content department, and all your other stuff so that you could say, "A-ha, I've got the new thing that you wanted, I've brought it down from the mountain and here it is. Do these sorts of things.”

Before I take this where you know I will, let me first say this.

I deeply respect Danny Sullivan for what he has done for the search marketing community both inside and outside of Google. Full stop.

However, I have two problems with these statements and want to clarify for anyone who is questioning the value of improving content structure (partially) in the service of better visibility:

Chunking and creating content for users are not mutually exclusive.
The statements misalign with how Retrieval Augmented Generation technology functions and with where the future technologies are going.

In the spirit of chunking, let’s add a heading and get to my next series of extractable atomic points.

Chunking and Writing for Users is Not Mutually Exclusive

First, we need to disambiguate “chunking” from how it’s used to describe an operation in Retrieval Augmented Generation (RAG) systems from how it’s being used to describe a content optimization action.

Chunking as it has been co-opted is really structuring content in a way that its passages and statements perform better when retrieved in a RAG pipeline. I know this because I’m one of the first people to drag the term from the AI/IR space into the SEO space.

If we’re being reductive (like most “it’s just SEO” arguments are) we’re effectively talking about content design or UX writing. As with everything in search and content marketing, machines are just a subset of the target personas. So, the idea of preparing the content only for the machine solely is still nonsense.

When we’re talking about chunking in this sense, the act of structuring content overlaps with the content design aspects of Cyrus’s post. However, where it differs is in reasoning of the decisions that you make in the copy that you write.

While the act overlaps with the largely qualitative processes people have historically used in the past, it is not the same. Effective chunking follows all the practices Cyrus discussed, but combines vector analysis to verify improvements. Also, for clarity, chunking is but one of an array of tactics you should apply from the content engineering toolbox. And, what differs it from UX writing or standard copywriting is the aspects of relevance calculation that must be accounted for on a passage level. It’s not just chopping paragraphs into smaller paragraphs and using more headings and hoping for the best.

Consider this, no one can reliably determine that content is generative or not without watermarks. So, Google needing a more reliable signal leverages user interactions to determine whether content should continue to rank. The main attribute that yields better content performance is better structure irrespective of why you do it.

So, What Truly is Chunking?

Chunking is the action that RAG systems take with content when they capture it to prepare it for the retrieval process. Chunking is the act of breaking content into a series of components that can be individually retrieved based on how relevant they are to a prompt or user query.

This is also a function of dense retrieval which Google effectively announced when they revealed their implementation of Passage Indexing. In passage indexing, passages are embedded and stored and the query is too. Approximate Nearest Neighbor (ANN) searches are performed to pull the closest matching passages. This is one of the building blocks of RAG, the primary paradigm behind AI Search.

There are a variety of chunking strategies including, but not limited to semantic, layout-aware, fixed length token-size. Based on Metehan’s research into Google’s public Vertex AI offering, it suggests that theirs may be a combination of fixed length and layout aware with the cascading heading option.

So, we are using the same term to refer to both the action that the system takes to decompose content and the work that we’re doing to restructure the content so it’s easier to extract. I wanted to clarify that for people that look to invalidate meaningful discussion based on syntax and vocabulary.

Why is Chunking Different from Classic Content Optimization for SEO?

In classic SEO, content boundaries were defined largely by intuition and editorial convention. Even when using content optimization tools, the analysis was typically lexical and page-level, evaluating aggregate term usage rather than the relevance of individual passages. As a result, while pages may have been visually or structurally segmented, those segments were not deliberately optimized as independent units of meaning.

Chunking as an optimization tactic changes that. With clearer insight into how modern systems evaluate content at the passage level, we can now treat each chunk as a discrete relevance object. This makes it possible to intentionally shape structure, specificity, and context within each passage to influence how it is measured, compared, and selected. Instead of optimizing pages holistically and hoping relevance emerges, chunking allows us to precisely adjust content at the level where relevance is actually computed.

Insights that Dan Petrovic shared on the length of Google’s grounding chunks and how much of your content gets used after it makes it through filtering give us more clarity on the atomicity. We also know that the natural boundaries of a paragraph we create influences what is considered a chunk in these systems.

Historically, SEO treats the page as a single context window with no real measurable way to tell if your optimizations really did anything except for the rankings themselves. Sure, the various content optimization tools give you a lexical score, but nothing that aligns with the breadth of modern information retrieval. Chunking offers a direct feedback loop for the isolation and improvement of specific blocks of content and how you can influence how they perform in AI surfaces.

The Google-shaped Web

Much has been said about how the web has conformed to what performs best in Google. It’s expected when Google is the biggest referral channel. However, with the advent of generative AI, websites are no longer adapting to a single set of guidelines or incentives. Content is now shaped by multiple platforms and channels, including search engines, AI assistants, recommendation systems, and social feeds, each imposing different structural and semantic pressures on how information is created and how users react to it.

After two decades of being in the space, I can say definitively that statements like this are how Google keeps marketers as their unpaid workforce, nudging the web toward what works best for Google.

Googlers often speak as though they are merely extracting natural patterns from the web, positioning themselves as neutral observers. But they are not the Watchers. They are the Celestials. One watches without interference; the other designs systems that determine what survives. Google’s ranking and retrieval decisions have shaped the web for decades. Entire categories of sites have converged on similar layouts, headings, FAQs, and explanatory formats not because those patterns emerged organically, but because Google’s systems and PR consistently reinforced them.

It’s not that they “don’t want people to have to be crafting anything for search specifically.” It’s that they “don’t want people to have to be crafting things for search that take advantage of Google.”

What changes with generative AI is not that this influence goes away, but that it begins to fragment. Search is no longer only about ranking pages. It is about selecting, extracting, and recombining passages across sources. The incentives now favor content that can be easily segmented, understood in isolation, and reused by machines.

This is still a Google-shaped web. But the shape is starting to loosen, creating the conditions for what comes next.

Google still has search, but the agent-shaped web is emerging outside their control

As generative AI becomes a primary interface for information, the incentives that once forced publishers to conform to Google’s preferences are weakening. Users are getting answers without clicks, referral traffic is less reliable, and the payoff for strict adherence to SEO best practices and Google’s guidelines continues to shrink – even when Google results are a key input for the results. The result is a gradual but meaningful loss of influence over how content is structured and prioritized.

(sidebar: I’ll have you know I wrote that em dash myself in that last paragraph.)

In conversations with F100 clients, this shift shows up clearly. A few are moving towards abandoning search outright, but many are questioning how much effort it still deserves. Investment is spreading to other formats and channels, and teams are becoming more willing to deviate from rigid SEO conventions. Not because best practices are “wrong,” but because repeated testing shows their impact is increasingly marginal.

What’s emerging is an agent-shaped web. Content is no longer written primarily to satisfy a single ranking system, but to be usable by agents that retrieve, reason over, and recombine information across sources. These non-Google systems do not publish guidelines. They do not moralize tactics as “white hat” or “black hat.” They simply use the content that works. In that environment, many behaviors Google historically discouraged are not violations. They are advantages.

This is how Google’s grip loosens. When influence shifts from ranking pages to supplying agents with usable inputs, control fragments. The web stops optimizing for compliance and starts optimizing for utility.

That’s why, when I’ve asked Google engineers what to do beyond “make great content” to improve rankings, the answer has consistently been “nothing.” That response only holds if Google remains the central force shaping outcomes. In an agent-shaped web, it isn’t. And, that’s why you see them creating fast-follow protocols like A2A after MCP and UCP after ACP.

How Chunking Improves Relevance

We know that content structure influences people and they should be the primary audience for any content adjustment. Fundamentally though, Danny’s statements do not align with how the underlying technology functions.

Search engines and Large Language Models are both built on the vector space model. Relevance is a function of distance measures between queries/prompts and documents. Where search engines measure this to rank documents, LLMs use the plotted relationships to predict the next token.

The distance measures are the values that are compared to determine what to feed the LLM. In synthesis pipelines, there is a pairwise determination where passages are compared side by side to determine what gets sent to the language model. A longer piece of text that covers multiple subjects typically has lower relevance than a shorter piece of text that covers a single subject.

Let’s illustrate that idea with an actual example in my tool BubbaChunk (if you know you know).

The paragraph above targets the queries [machine learning] and the [data privacy]. When I generate embeddings for the queries and for that paragraph, using cosine similarity as my distance measure I get a 0.541 for [machine learning] and an 0.620 for [data privacy].

Now, let’s split that paragraph in two and not change anything else. The machine learning paragraph has now improved 19.24% to a 0.645 cosine similarity. The data privacy paragraph improved 1.29% to 0.627.

When compared to passages on both subjects, it now has a better opportunity to perform. Within an environment of a full page, other elements like the heading hierarchy and surrounding passages can be used to influence this. I can further improve the scores with semantic triples, entity salience, and so on, but in isolation, restructuring this content by changing its boundaries improves its retrievability.

Some folks may be invested in Google’s multi-aspect embedding technique MUVERA. BubbaChunk takes a similar approach and MUVERA uses Chamfer Similarity as its distance measure. Those are the Chamfer values you see in the screenshots. You’ll note that there are improvements to all distance measures when I’ve made this adjustment.

If you’re curious, adding the headings does improve the scores significantly. Below you’ll see adding the header to the “Data Privacy” paragraph improved cosine similarity another 17.54%.

No matter how you slice it, embed it or measure it, improving the structure of content yields better scores by machines and how it performs with people.

Structured Content is Better in Any Paradigm

Danny’s comments suggest that Google may eventually evolve its systems to discourage overt structuring techniques. That assumes structure is a temporary optimization tactic andsuggests we’re moving to a world where “high-quality writing” is a monolith that the algorithm will simply “understand.” Google’s own research direction, alongside adjacent work from Meta, Berkeley, and MIT, points in the opposite direction. As systems gain access to more context, memory, and recursion, structure becomes more important, not less. Across multiple papers, Google Research is clearly pursuing near-infinite context through memory rather than brute-force attention, and they are building atop the state of the art from other groups in the space.

Reviewing the state of the art, we find that Berkeley’s Ring Attention demonstrates how extremely long sequences can be processed by breaking them into rotating segments, where each segment attends locally while passing the summarized state forward. In that structure, the model does not need to see everything at once. It needs to preserve meaning across time. Systems like this rely on the continuity of information within a segment. By structuring content into atomic passages, you ensure each “rotating segment” contains a complete, unfragmented unit of meaning.

“Leave No Context Behind: Efficient Infinite Context Transformers with Infini-attention” formalizes this further by introducing compressive memory that allows models to retain and reuse information far beyond a fixed context window. You can’t compress a mess without losing the message. Atomic, legible passages act as high-fidelity signals that survive the compression process, ensuring your information is correctly retrieved later.

Meta’s MemWalker pushes in the same direction by organizing content into memory trees that can be traversed, revisited, and updated. Structure provides the branches. By defining clear boundaries and semantic anchors, you build a “map” that helps the agent navigate and reconstruct the mental model of your information.

These approaches make Google’s intent clear. The goal is not just larger windows. It is durable, near-infinite context.

(sidebar: Those last 4 paragraphs were originally a single paragraph. I split them up while editing to isolate each specific idea and align them with the images from the papers. That’s an example of chunking in action.)

MIT’s work on Recursive Language Models reaches the same destination through a different path. Rather than expanding context directly, RLMs decompose long inputs into smaller units and recursively invoke the model over the most relevant chunks. In effect, the model reasons over content iteratively, revisiting and recombining passages as needed. This reinforces the same reality. Passages are the unit of interaction.

DeepMind’s Mixture of Recursions (MoR) pushes this idea into the architecture itself. Instead of a fixed depth of computation, tokens are routed through different numbers of recursive steps. Some content is processed shallowly. Other content is revisited repeatedly. This is adaptive reasoning at the token level, and it further removes any illusion that content is consumed linearly or holistically. What matters is which pieces survive repeated passes through the system.

A common rebuttal is that we are entering an era of “Infinite Context.” With models like Gemini 3 Pro with a 1 million token context window, why bother chunking when the model can ingest the whole book?

The answer lies in inference cost and reasoning depth. The MoR paper reveals that not every token needs the same amount of “thinking.” In an agent-shaped web, computation is the new scarcity. Well-structured, atomic content allows the model’s ‘router’ to identify meaning quickly and exit the recursive loop early. Brute-forcing an unstructured 2-million-token wall of text is computationally expensive and prone to ‘context rot.’ If you want an agent to pick your content over a competitor’s, you should make it the path of least resistance. You don’t want to be just readable, but computationally efficient to digest.

At the bleeding edge, Google’s Nested Learning moves beyond retrieval entirely. With the HOPE architecture, passages are no longer just fetched as context. They are used as signals for “memory infusion,” updating the model’s inner loop. This is where control erodes most clearly. Once content moves from retrieval into synthesis and memory update, our influence largely ends. Just as we can influence how we rank for synthetic queries but not how answers are composed, we can influence which passages are legible and extractable, but not how they are ultimately weighted, combined, or remembered.

In this environment, atomic legibility is the only survival strategy. If a passage isn’t self-contained (meaning it lacks its own entity, context, and claim) it fails to “infuse” correctly. It becomes noisy data. Just as Infini-attention relies on “compressive memory” to store long-term state, your content must be compressible. You cannot compress a mess without losing the message. Each chunk must stand as a standalone signal so that when the agent tears the binding off so to speak, the individual page survives the transition from retrieval to synthesis.

Furthermore, the shift to an agent-shaped web isn’t limited to text. Agentic systems are increasingly multimodal, needing to reconcile text with images, charts, and tables. Without layout-aware structure, these relationships disintegrate during the retrieval process. By defining clear boundaries and semantic anchors, we aren’t just helping the model read; we are helping it reconstruct the mental model of the information. Structure is the glue that ensures a chart and its context remain unified when an agent retrieves them from a near-infinite context window.

None of this weakens the case for structure. It sharpens it. In every one of these systems, passages remain the atomic unit of meaning. Whether through attention, memory, or recursion, models operate on chunks, not pages.

Google still wants us to produce books: pages that can host ads, preserve attribution, and sustain the economics of the open web. Agentic systems read differently. They tear the binding off the book, ignore the table of contents, and pull out only the pages and paragraphs they need, sometimes revisiting them again and again. In that world, structure is no longer about presentation. It is about making meaning legible at the passage level.

Across every paradigm, from the first Google-shaped web to the looming agent-shaped web, the best we can do remains the same. But the ‘why’ has changed. We are no longer just formatting for ‘skimmability’ or ‘dwell time.’ We are formatting for Programmatic Legibility. We are building the API of meaning. By designing content so each chunk stands on its own with clear signals, we aren’t performing a workaround. We are ensuring our information survives the recursive, synthetic, and agentic loops that are now defining the web.

We’ll Keep Being the Signal through the Noise

There’s a lot of confusion right now as search and generative AI continue to blend. There are also a lot of people who don’t understand the nuances so they keep looking to shoehorn the changes into what they already do and know so they can feel superior or at least relevant.

This also makes it difficult for the community because the only reliable sources of information come from reading patents, white papers, playing with the platform’s public APIs, and then experimenting to see what works. Not everyone is capable of those things, nor do they have the time or wherewithal, so they do what I said above.

It’s unfortunate that Google continues to want to play the FUD game and contradict what we can see with our own eyes in their research, patents, and in how their systems react to changes. That behavior further reinforces that we are not partners in making the world’s information accessible. We are the unpaid extension of their workforce.

For these reasons, iPullRank will continue to do the work and the R&D and share what really works and why. Our AI Search Manual is an example of that. We’ll continue to support everyone striving to build in this new world and this will be one of the threads we continue at SEO Week in April.

So, get your ticket to SEO Week and hear from the sharpest minds on what’s actually working for AI Search.

Want to find out about how Relevance Engineering can help your business?

Learn about iPullRank's Relevance Engineering Services

The post Moving from a Google-shaped Web to an Agent-shaped Web: A Refutation of Misinformation about Chunking appeared first on iPullRank.

Fuzzy Matching and Semantic Search: Improving Visibility in AI Results

Lazarina Stoy — Fri, 31 Oct 2025 11:00:00 +0000

Searchers rarely type (or think) exactly like your brand content has been written. They misspell brand names, swap words for synonyms, and ask open-ended, messy questions. This trend is even further amplified by the introduction of AI chatbots and AI search agents, which take personalization of the user search prompt to the next level. You can see this firsthand in iPullRank’s AI Mode UX study conducted in August.

What does this mean for SEOs?

The uniqueness of your potential customers’ thoughts, used words and phrases, is now up against the sophistication of the search engine’s information retrieval capabilities when it comes to content discovery. To some things more difficult, you’re marketing at the expense of probabilities.

The practical response isn’t to rewrite everything for every phrasing—it’s to teach your retrieval stack to recognize both what a query looks like and what it means. Fuzzy matching catches near-miss strings and variants (typos, transpositions, phonetic lookalikes, and n-gram overlaps). Semantic matching maps language into meaning via embeddings and intent similarity, so paraphrases and long, conversational prompts still land on the right content. When you blend the two, you expand recall without flooding users with noise, and you future-proof visibility as AI agents continue to rewrite, summarize, and personalize queries on the fly.

This article lays out a pragmatic blueprint. We’ll define the main families of fuzzy techniques—exact and distance-based string matching, phonetic and n-gram methods, TF-IDF—and contrast them with semantic (vector) matching. From there, we’ll look at how fuzzy logic powers traditional search in areas like error tolerance, query expansion, voice search, and more. Next, we’ll map those same ideas onto LLM-based search, showing what carries over and what’s new (embedding-driven relevance, reranking, and personalization).

I’ll also share some hands-on quick-start projects that have the potential to improve organic visibility across traditional and AI search engines alike. By the end, you’ll have a clear, testable approach to combine “looks-like” fuzzy signals with “means-like” semantic signals, allowing your content to be discoverable across the messy, personalized, AI-shaped ways people now search.

Fuzzy String Matching - Subtypes, Definitions, Algorithms, and Libraries

Fuzzy matching is a form of string matching: we assess the similarity of two strings against one another. String matching is a machine learning problem dating back to the 1980s. At its core, it measures the “distance” between two strings and converts that distance into a similarity score to classify pairs as equivalent, similar, or distant.

It emerged to solve two big problems: error correction (e.g., spelling mistakes, transpositions, omissions) and information retrieval (finding the best-matching items when inputs are imperfect). In retrieval, we face two risks: returning unwanted items or missing required ones. Fuzzy methods try to balance both.

Now, pause and think about all the SEO/digital marketing situations where human or system errors creep in—and where fuzzy logic helps: redirect mapping, mapping 404s to live URLs, competitor analysis, internal link mapping, and more. Also consider operational data: customer or product databases where manual entry introduces inconsistencies. Fuzzy matching helps deduplicate, consolidate, and correct.

The string similarity problem in fuzzy matching

Similarity is the core problem all fuzzy algorithms tackle. Early work cataloged what actually creates differences between strings that “should” be the same: substitutions (one letter mistaken for another), deletions (omitting a letter), insertions (adding a letter), and transpositions (swapping letters). Algorithms model these errors to compute distance and, from it, similarity.

Crucially, this is why plain string matching is unsuitable for many SEO/marketing tasks that require meaning, not just characters. It’s great for redirect mapping (we assess URLs as strings), but not enough for internal link opportunity identification, where we’re trying to surface pages that benefit users with new information or formats. Classic string matching measures character/word distance; it does not (by itself) capture semantics or context. This lack of semantic or contextual understanding makes them inferior to other approaches (like entity-based mapping) for certain applications, such as internal link opportunity identification.

Fuzzy string matching approaches are classified based on how similarity is calculated. There are five main types:

Type of Matching	Key Difference/Calculation Method	Example Algorithms
Exact Matching	Direct character-by-character comparison to find the exact pattern.	Boyer-Moore algorithm.
Distance-based Matching	Focuses on edit distance—the minimum number of edit operations (insertion, deletion, substitution) needed to convert one string into another.	Levenshtein Distance, Jaro Distance, Hamming Distance.
Phonetic Matching	Captures phonetic similarities, useful where differences exist in pronunciation or spelling but the meaning is the same (e.g., multilingual contexts).	Metaphone, Soundex.
N-gram Matching	Detects occurrences of fixed sets of pattern arrays (sub-arrays like bigrams or trigrams). Focuses on substring patterns.	N-gram based approach, Bigram Matching, Trigram Matching.
TF-IDF String Matching	Uses Cosine Similarity with TF-IDF. Analyzes the corpus of words as a whole and weighs tokens higher if they are less common in the corpus (context-sensitive weighting).	TF-IDF with Cosine Similarity.

Exact Matching

Exact Matching (Direct) as one of the primary methods within the larger context of fuzzy string matching algorithms. It is fundamentally different from other fuzzy methods because its objective is to find perfect identity rather than approximation.

Typical algorithm: This is a well-known pattern recognition algorithm designed for the exact string matching of many strings against a singular keyword (or, in other words – direct character-by-character comparison), and it is very fast in practice.
How it works: Check whether the query’s characters appear in a candidate substring, align lengths, and verify character by character. Partial matches advance the window efficiently until an exact match is found. The algorithm seeks the exact pattern contained within the search string. This involves looping through entries, checking for the presence of the characters within the keyword, and ensuring the length of the keyword input matches the entry. If a mismatch occurs, the algorithm searches for the next substring example.
Strengths: Fast, accurate for exact matches; minimal compute.
Limitations: Only finds exact matches – no tolerance for typos/variants, making it ineffective for fuzzy or approximate matches.

Distance-based Matching

Distance-based methods compute the minimum number of edit operations needed to turn one string s into another t. Operations typically include substitution, insertion, and deletion (sometimes transposition). The Edit Distance is calculated between two strings (e.g., ‘s’ and ‘t’) as the minimum number of edit operations required to convert the string ‘s’ into the string ‘t’. The program calculates the number of character shifts needed to get from the input keyword to the entry found in the search.

Typical algorithms: Levenshtein distance, Jaro (and Jaro–Winkler), Hamming distance (for equal-length strings).
Example: “hard” → “hand” requires one substitution; “hard” → “harder” requires two insertions, so “hard”/“hand” are closer by edit distance than “hard”/“harder.”
Strengths: Very good for detecting approximate matches. Highly flexible for typos and minor differences in spelling of words.
Limitations: No semantic understanding – dependence on simple character distance methodology without incorporating semantic similarity; limited when words sound alike but are spelled differently.

Despite its limitations, this type of fuzzy matching has a ton of implementations in SEO, like 404 URL mapping to live URLs, redirect mapping, identifying branded mention variations in search query data, and more.

Phonetic Matching

Phonetic approaches map words to a code approximating pronunciation so that differently spelled words that sound alike collide.

Typical algorithms: Metaphone (and Double Metaphone). This algorithm excels in performance for handling various errors, including misspellings and letter additions/absences, especially for languages other than English.
Use cases: Multilingual or noisy data where pronunciation varies; handling homophones and cross-language spellings.
Strengths: Catches sound-alikes that distance metrics may miss.

Limitations: The main limitation is that it does not consider semantic meaning. It is limited for words that sound alike but are spelled differently (homophones). Language-specific tuning might also be often needed

N-gram Matching

N-gram methods break text into overlapping sequences (characters or words) and compare overlap. N-gram matching aims to detect the occurrences of a fixed set of pattern arrays embedded as sub-arrays in an input array.

Character n-grams: “elephant” → tri-grams: ele, lep, eph, pha, han, ant.
Word n-grams (great for SEO workflows): When searching a dataset, the input string (e.g., a keyword) is broken down into fixed sets of words or characters called N-grams. For example, if the input keyword is a seven-word phrase like “what is string matching in machine learning,” it could be split into bigrams (sets of two words, e.g., “what is,” “is string matching,” etc.) or trigrams (sets of three words).
How scoring works: Entries in your dataset get higher similarity when they contain more of the query’s n-grams.
Similarity Metric: Jaccard Similarity is an algorithm often used in conjunction with N-gram matching.
How to get started: scikit-learn or APIs designed for N-gram generation (e.g., NLTK).
Strengths: Highly efficient for large datasets. Very efficient for quickly extracting data involving large patterns. Scalable. Useful for detecting partial matches, patterns, or key phrases.
Limitations: Still surface-level; may miss paraphrases with low n-gram overlap. Can be computationally expensive for long strings or high N-gram values.

In SEO n-gram-based matching can be used for keyword clustering, short copy or metadata similarity evaluation, and even detecting plagiarism and finding long-tail SEO phrases.

TF-IDF Matching

TF-IDF String Matching is an approach that introduces complexity and contextual relevance by calculating Cosine Similarity with TF-IDF (Term Frequency–Inverse Document Frequency).

This is a well-established metric for comparing text that has been adapted for flexibility, specifically for matching a query string with values in a singular attribute of a relation.

What it adds: Goes beyond raw string distance by down-weighting common words and up-weighting distinctive ones across your dataset. TF-IDF fundamentally analyzes the corpus of words as a whole. It weighs each token (word) as more important to the string if it is less common in the corpus.
How to get started: scikit-learn or gensim Python libraries are examples of tools that can be used for TF-IDF matching.
Strengths: Well-established, effective for lexically similar but not identical text; simple to implement and tune.
Limitations: It does not capture semantic similarity. It is slower for high-accuracy configurations. It requires preprocessing.

Hybrid Approaches

In practice, combining methods improves results. For example, mix Levenshtein (to handle misspellings) with Metaphone (to catch sound-alikes) so you cover both typographical and phonetic variation. You can also chain stages: generate candidates with n-grams/TF-IDF, then refine with a distance metric, and finally apply business rules (e.g., thresholds) to balance recall and precision. If one methodology underperforms, iterate toward a hybrid architecture that better fits your data and goals.

The practical implementation of these algorithms is extremely beginner-friendly through readily-accessible Python libraries like FuzzyWuzzy and RapidFuzz, which allow users to choose and stack methods.

How fuzzy matching is used in traditional search engines

Error handling

Fuzzy matching is the first line of defense against messy input – typos, transpositions, missing characters, mixed scripts. Large engines correct queries by combining edit-distance style candidates with corpus/context signals (“did you mean…”) so users avoid dead ends. Specific techniques include classic spelling correction, tolerant autocomplete, and resilient entity lookup, which all lean on edit-distance, phonetic, and n-gram methods to recover intent and avoid empty SERPs. In more advanced stacks, error tolerance is fused with semantic understanding (e.g., knowledge-graph reasoning) so the system can still retrieve the right entity even when the query is malformed – an approach sometimes described as fault-tolerant semantic search.

On desktop search, Google implements context-weighted spell-checking for queries, while Microsoft dynamically corrects as you type to handle errors. On mobile systems, it automatically detects keyboard type and uses key-proximity and layout–aware rules to re-rank candidate keys that are physically near on a keyboard, improving the precision of the suggested spelling corrections without adding latency.

Broadening search scope

Beyond fixing errors, engines use fuzzy logic to expand or rewrite queries to improve recall. Google’s augmentation query filings describe issuing extra, related sub-queries and merging or re-ranking their results. Engines expand queries with near-matches (inflections, spelling variants, transliterations), and also with history or session context, by adding related terms or time hints. Recent work on personal history–based retrieval shows that vague, “fuzzy” prompts (e.g., “that chess article I read last week”) can be resolved using similarity thresholds and soft time filters, even in voice mode. This is query expansion in action, guided by context rather than just keywords.

Fuzzy matching is also used to improve search results when users have mistyped part of the query in a different script. Search systems might often generate a parallel transliterated or cross-language query variant as a query expansion to boost recall on multilingual queries, where the user has typed a brand or entity name in the wrong script (e.g., Latin vs. Cyrillic)

User experience

Autosuggest is the most visible fuzzy UI layer in search: partial inputs trigger suggestions that may include spelling variants, synonyms, related entities, and direct-to-result shortcuts. Google and Microsoft patents cover predicting completions and surfacing suggested results alongside queries to help users navigate directly.

Information retrieval

Operationally, fuzzy signals are used at the time when candidate queries are generated to boost recall (character/word n-grams, phonetic hashes, edit-distance lookups), then re-weighted in ranking against lexical (BM25/TF-IDF) and semantic features. This layered retrieval reduces miss-rate on long queries and tail entities while preserving precision.

Google’s query augmentation patent filings describe how these expansions create multiple candidate sets, which are then merged and scored by the ranker. This two-phase architecture (first broaden, then score/merge with thresholds) aims to filter out noise in SERPs before surfacing pages in the rankings. Another technique used to avoid flooding results with similar pages that relies in part on fuzzy matching is near-duplicate detection, which is done via techniques like fingerprinting, shingling, or simhash collapse to identify redundant candidates. This allows for query expansions to improve coverage without cluttering the SERP or wasting computation on duplicates.

User context segmentation

People search in many languages and scripts, and the names of products or entities they mention rarely appear in consistent forms. Engines normalize this across these contexts using culture-sensitive fuzzy pipelines: patents describe culture-aware name regularization, different scripts, romanization/transliteration, and cross-language suggestions to map “different looking” but equivalent strings to the same entity.

Voice search optimization

Voice introduces its own fuzziness—automatic speech recognition (ASR) errors, homophones, and vague temporal references (“last week”). Phonetic matching (e.g., Double Metaphone–style coding) and tolerant time windows help bridge the gap between what was heard and what was meant. History-aware systems even apply fuzzy time ranges (“last week” ≈ last ~2 weeks) to align with human memory, especially in voice assistants.

Google’s patents describe turning ASR n-best hypotheses into weighted Boolean queries so retrieval can still succeed even when the transcript is uncertain. There are also fuzzy-logic-derived pipelines in place for when people code-switch (or otherwise talk or search, mixing words from different languages), using transliteration and cross-language suggestions to reduce ASR brittleness and retrieval misses for bilingual users.

Together, these patterns show how traditional search uses fuzzy matching to repair, expand, and contextualize queries – improving robustness, discoverability, and ultimately the user’s path to the right result.

How fuzzy matching is used in LLM-based search

Similarly to how fuzzy matching is used in traditional search engines, LLMs don’t really do fuzzy matching in the traditional sense (edit distance, n-grams, phonetic coding) inside their core generation model. Instead, fuzzy techniques show up in two places around the LLM – the RAG pipeline and via semantic embedding matching for similar strings.

During Prompt Processing: Error Correction and Query Reformulation (Expansion, Synonyms, Paraphrasing, Text-to-Text Transformations)

When the LLM itself interprets your query:

It tokenizes input. Subword tokenizers (like Byte Pair Encoding) naturally handle misspellings and variants somewhat fuzzily – e.g., “chattbott” is split into known sub-tokens that still relate to “chat” + “bot.”
It handles typos, mistakes, and other language variants. The model’s pretraining also exposes it to tons of noisy, user-generated text (typos, informal language), so it was introduced to fuzzy tolerance during training.

Some systems explicitly add an LLM-based query rewriting step: the LLM takes a noisy input and rewrites it into a cleaner, canonical query before retrieval. This replaces traditional fuzzy edit-distance spell correction with a neural equivalent.

Many RAG systems include a query rewriting or paraphrasing step before retrieval, one example being the advanced technique Rewrite-Retrieve-Read, which, explained simply, generates a rewritten query, then retrieves data, then feeds to the reader. The goal is to turn the user’s possibly awkwardly-typed or under-specified query into one or more reformulated queries that better match the text in the knowledge base. This can insert synonyms, reorder structure, or break a complex request into simpler sub-queries, or expand it to capture follow-up questions (e.g. Query Fan Out).

However, LLM-based query expansion is not perfect. When the LLM lacks knowledge about the domain or the user’s input is ambiguous, expansion may hurt performance by introducing irrelevant or misleading terms.

For Finding Relevant Candidate Documents and Text Processing: Retrieval Augmented Generation (RAG)

When you use an LLM with retrieval (e.g., in RAG pipelines), you first fetch documents or passages from a database before generation.

Even here, fuzzy matching still plays a role:

The system implements lexical fuzzy search: Some hybrid systems continue to incorporate edit-distance, n-grams, or phonetic matching in candidate retrieval to tolerate typos, OCR noise, or format errors.
The system might retrieve documents using a Hybrid approach: A common architecture is:
1. Generate candidates via BM25 and fuzzy string matching (fast, recall-heavy)
2. Generate candidates via vector embeddings (semantic similarity)
3. Merge/rerank them (e.g. via Reciprocal Rank Fusion or weighted fusion)
This layered approach helps the retriever recover answers that would otherwise be missed due to spelling mistakes, synonyms, or paraphrase-level mismatch.

Systems like Perplexity AI explicitly describe combining “hybrid retrieval mechanisms, multi-stage ranking pipelines, distributed indexing, and dynamic parsing” in their architecture, using both lexical and semantic signals. Google’s AI Mode, on the other hand, uses Query fan-out, which benefits from overlapping fuzzy and semantic matching layers for generating the different query variants.

AI Research demonstrates that models combining lexical and distributed (semantic) representations into an architecture (e.g., learned sparse retrieval) outperform either alone.

Inside the Embedding Layer: Embedding-Based Matching (Semantic Fuzzy Matching)

In LLM pipelines, embedding-based matching is the primary fuzzy mechanism of retrieval, enabling content discovery beyond exact keyword overlap.

The core “fuzziness” in modern LLM-based retrieval is based on vector embeddings. Both the query and candidate documents/knowledge chunks are embedded in high-dimensional space; similarity (via cosine distance or other metrics) helps match semantically related content even when literal words differ.

Because embeddings map synonyms, entities with different mention formulations, paraphrases, morphological variants, and contextually similar expressions close together, this acts like a fuzzy matching layer – but at meaning level rather than character-level.

For example, OpenAI’s search patents emphasize that retrieval is shifting from keyword matching to vector-based matching on content chunks.

In Document Selection and Response Generation: Personalization

Personalization is a real axis in LLM pipelines, influencing both retrieval (which passages are surfaced) and generation (how they are used).

Personalization in LLM-based systems often occurs via user embeddings and memory. In AI Mode, the user’s past queries, preferences, and behavior are embedded and influence which retrieved documents are preferred or how results are weighted. For example, systems may be biased toward content that aligns with the user’s embedding. Note that this is not very different from how traditional search engines utilize individual user context as a preference layer based on past content types that the user engaged with. When in chat-mode, AI search can also incorporate memory or prior dialog context (context memory), so the same query by different users might produce different responses despite the core search intent and question asked being identical.

Aspect	Traditional Search (Google/Bing, IR systems)	LLM-based Pipelines (RAG, embeddings, LLM generation)
Core technique	Explicit fuzzy algorithms: edit distance (Levenshtein), phonetic codes (Soundex, Metaphone), n-grams, TF-IDF.	No edit-distance or phonetic codes inside the model; instead relies on vector embeddings for semantic similarity. Fuzzy logic introduced during training.
Error handling	Spell correction, “Did you mean…?”, tolerant autocomplete (typos, transpositions, omissions).	LLMs tokenize noisy inputs into subwords; embeddings smooth over spelling variants. Sometimes add an LLM-based query rewriting step for correction.
Query expansion	Augment with synonyms, spelling variants, query history; broaden recall with n-grams and expansion rules.	Semantic expansion via embeddings (similar meaning queries cluster in vector space). LLMs can also paraphrase queries before retrieval.
Candidate retrieval	BM25 and fuzzy match used to generate candidate sets, then ranked by relevance.	Hybrid retrieval: BM25/fuzzy search and vector embeddings, merged with rank fusion (e.g., Reciprocal Rank Fusion).
Voice & noisy input	Phonetic matching, n-best ASR hypothesis handling.	Embeddings and LLM tolerance for noisy phrasing; LLMs can normalize speech outputs semantically, not just lexically.
Context sensitivity	Some personalization (query history, language normalization, transliteration).	Embeddings naturally capture paraphrases & cross-lingual similarity; LLMs can also normalize names/entities via rewriting prompts.
“Fuzzy” nature	Character- or token-level approximation (distance, phonetics).	Semantic fuzziness: embeddings collapse lexical, morphological, and paraphrastic variants into nearby vector space.
Goal	Ensure users don’t get “zero results” because of spelling errors or lexical mismatch.	Ensure LLM has access to the most semantically relevant passages, even when queries are messy, and then generate a coherent response.

How to get started with fuzzy matching to improve your organic search visibility (SEO and GEO) - Practical Projects and Quick-starts

Some of the most common pitfalls when optimizing content for discoverability:

Over-optimizing for one phrasing may reduce embedding cohesion, while too many variants can dilute embedding signals.
Relying solely on LLM-based paraphrase matching is risky: an LLM-based query expansion showed it can degrade performance for ambiguous or domain-poor inputs.
Personalization may favor content “close” to a user’s past behavior – new or niche content may need stronger signals to break through.

Strategies

Here are strategies to make your content more discoverable in pipelines combining fuzzy methods and LLMs:

Goal / Problem	Tactic	Why It Helps in Fuzzy and Semantic Pipelines
Surface in query-rewrite pipelines	Use multiple phrasings / paraphrases / synonymous expressions within your content (e.g. in FAQs, subheadings)	If the rewriting step paraphrases user input, having variant phrase forms ensures your content is reachable under those alternate rewrites.
Embed well as retrieval target	Write clear, self-contained passages (≈ 100–300 words) that can be chunked and embedded independently	Dense retrieval favors semantically coherent chunks; if your passage is too diffuse, embeddings may mismatch.
Anchor entity / keyword variants	Use canonical names and aliases, multi-script forms, transliterations, synonym lists (in structured data or in-body)	Embedding and fuzzy rewrites will map variant forms to your content; this improves recall for users using alternate names or scripts.
Signal context / intent explicitly	Include context terms, qualifiers, and related keywords in the same passage (“for small businesses,” “in 2025,” etc.)	Retrieval and rewriting benefit from overlap in secondary keywords to anchor intent, reducing ambiguity.
Personalization alignment	Create personalized paths (e.g. by persona or vertical) so that your content can match user embeddings better	If your content matches one persona’s profile closely, it may be favored under retrieval weighting in personalized systems.
Guard against hallucination mismatch	Ensure that key facts (dates, names, figures) are explicit and unambiguous in content	The LLM uses retrieved passages to ground its response; if your content is vague, the LLM may hallucinate or misalign.
Measure selection, not just ranking	Track inclusion in RAG pipelines (was your content retrieved or not), not just SERP rank	In LLM pipelines, being “retrieved” is step zero — if you are never picked as a candidate, you have no chance to be used.

Practical Projects

I’ve organized nine practical projects for you to get started with optimizing your content and technical site workflows, for traditional and AI search systems alike.

Here are the top three that you should prioritize, and why:

Question-to-Section Mapping – AI systems cite passages that are short, self-contained, and unambiguous. Mapping clustered, fuzzy variants of questions to answer-first H2/H3s and tight FAQs makes your content better prepared to be cited. It also aligns perfectly with hybrid retrieval architectures discussed earlier.
SEO Entity Footprint Unification – For local/topical entities, AI systems need a single, confident referent. Fuzzy-reconciling NAP variants (name/address/phone) and emitting machine-readable signals (JSON-LD LocalBusiness with stable @id, sameAs, hours/geo) makes it easy to ground and safe to cite.
Schema Graph Consolidator – AI pipelines benefit from clear, machine-navigable entity graphs. A single, deduped JSON-LD graph reduces ambiguity across Organization/LocalBusiness/Person/Product and strengthens cross-page signals that retrieval can trust.

These three projects directly improve the two signals AI systems rely on to cite you:

Extractable, high-confidence answers: tightly scoped, answer-first sections that an LLM can lift into its output without risk.
Unambiguous entity grounding: consistent identifiers and machine-readable signals that reduce ambiguity about who you are, where you are, and what you do.

Everything else is also useful, but more of a subset or multiplier once you have a solid base.

See all the suggested projects in this sheet

Project Ideas for Fuzzy Matching and Semantic Search Optimization for SEO and AI Search

How can you use Fuzzy Matching?

Fuzzy matching is for candidate generation, not the final decision. Use edit distance, n-grams, or phonetics to repair and expand messy inputs, then let semantic rankers select what matters.

Hybrid retrieval is the default. Engines expand queries both lexically and semantically. Content that aligns with entity attributes, comparisons, and clear facts is more likely to be retrieved and cited.

Build answer-first hubs. Create one authoritative hub per entity. Link supporting pages back with the canonical label and merge duplicates quickly so signals converge.

Expect citation differences. Personalization approaches will continue evolving.

Overall, fuzzy matching is not only a foundational approach but also useful and integrated widely, not only in traditional search but also in AI search retrieval systems. Utilize it as part of your toolkit to better research, plan, and structure content at scale and organize your technical infrastructure to be better understood by LLMs.

Explore the strategies, tactics, and frameworks that define AI Search.

The AI Search Manual: The Official Documentation for Relevance Engineering in AI Search

The post Fuzzy Matching and Semantic Search: Improving Visibility in AI Results appeared first on iPullRank.

Mike King Named 2025 Search Marketer of the Year by Search Engine Land

Garrett Sussman — Mon, 27 Oct 2025 20:01:47 +0000

NEW YORK, NY — October 27, 2025 — Michael King, Founder and CEO of iPullRank, has been named AI Search Marketer of the Year by Search Engine Land for 2025. This marks his second win and cements his position as one of the leading innovators in modern SEO and AI-driven search strategy.

Michael King continues to set a new benchmark for leadership in SEO. In April, he launched the inaugural SEO Week in New York City, a highly technical, forward-looking conference that brought together more than 40 of the industry’s top thinkers, creators, and engineers. The event went beyond entry-level presentations and featured practitioners shaping the next phase of search, including machine learning engineers, search product leads, in-house enterprise SEOs, and creative strategists. SEO Week introduced frameworks, challenged norms, and delivered experiments, live-coded demos, and data-backed insights on the future of search.

A central idea introduced during SEO Week was Relevance Engineering, a framework that merges content strategy, information retrieval, UX, digital PR, and AI. It reflects how modern search engines interpret meaning semantically and contextually. Relevance Engineering positions SEO as a technical marketing discipline built on language modeling, query understanding, and information gain. It is supported by measurable systems that include vector embeddings, cosine similarity, topic segmentation, and semantic scoring at scale.

King’s AI Mode article following Google I/O became the definitive breakdown of Google’s new AI Search experience. He unpacked patents, analyzed the mechanics of query fan-out, and explained how Google’s systems use personal context and multiple intent satisfaction to generate results.

In that article, he also introduced Qforia, a Gemini-powered tool he built to generate query fan-outs for AI Mode and AI Overviews, which inform the type of multi-model content SEOs need to create to earn more visibility in AI Search, helping marketers test and understand AI Search.

Building on that foundation, King and the iPullRank team launched The AI Search Manual. This comprehensive, multi-chapter publication documents the principles and methods driving visibility in conversational and AI Search. The Manual covers topics such as query fan-out, content resonance, measurement frameworks, and brand performance in AI Search environments. It has become a go-to resource for enterprise marketers and SEOs navigating the shift toward AI Search retrieval systems.

King’s philosophy has remained constant: take complex systems, decode them, and build tools that make them actionable. Through keynotes, prototypes, and research, he continues to push the field toward a more technical, evidence-based future.

"First off: thank you. To the judges, to the community, to my team at iPullRank—the most brilliant, relentless crew in the game.

Winning this once was a statement. Winning it twice? That feels like legacy in motion.

I didn’t get here by playing safe. I got here by breaking things open. By questioning every assumption this industry ever handed me. SEO was never meant to be static. It was never about chasing 10 blue links. It was always about decoding how meaning moves through machines.

While everyone else was arguing over subdomains versus subdirectories and what to call AI Search, we were out here defining Relevance Engineering and building the bridge between AI and human intention. We weren't getting lucky, we were keeping our heads down and getting to work.

This moment isn’t just about me, it’s about what comes next. Because the future doesn’t wait. It doesn’t care who’s comfortable and cautious. It rewards the curious, the creative, the ones crazy enough to believe that search can be rewritten like code and poetry at the same time.

So to everyone watching: stop playing defense. Don’t wait for the next AI innovation or algorithm update to tell you who you are. Be the signal, not the noise.

The machines are learning from us. Let’s give them something worth learning.

Thank you and congratulations to all my fellow nominees and everyone in this space pushing the boundaries. The future’s already watching."

~ Michael King, Founder and CEO

Under King’s leadership, iPullRank has developed the AI Search Strategy Program, designed for enterprise brands preparing for the next phase of search. The program includes:

The Keyword Portfolio
Omni-Media Content Audit
Omni-Media Content Plan
AI Search Measurement Plan

Enterprise marketers are encouraged to join the program before the end of the year to align with 2026 budgets and strategic initiatives.

Interested in developing your own AI Search strategy for your brand?

Schedule your own AI Search Strategy Program Consultation

About iPullRank

iPullRank is a New York-based digital marketing agency that integrates Relevance Engineering, technical SEO, content strategy, and AI innovation to help enterprise brands achieve measurable visibility in both human and machine-driven search. The agency partners with Fortune 500 and high-growth companies across finance, eCommerce, and technology sectors to engineer relevance at scale.

The post Mike King Named 2025 Search Marketer of the Year by Search Engine Land appeared first on iPullRank.

Strategic Ways to Use Your End-of-Year Marketing Budget

Heather Ferris — Thu, 23 Oct 2025 11:00:00 +0000

In 2026, AI Search will continue to reshape how organizations plan, allocate, and evaluate their budgets. The integration of generative systems into everyday business tools means decisions are being made with more data, more context, and a lot of guesswork.

As AI Search platforms become the new normal, it changes how companies interpret market signals, measure ROI, and prioritize spend. CMOs are under pressure to connect every investment directly to performance. And not just in outputs, but in the insights that drive them.

That shift influences how leaders approach compensation, hiring, and growth. Many organizations ahold their budgets steady as they assess the productivity and efficiency gains AI brings to the table. The goal is stability in a landscape that’s become more predictive and automated by the month.

How you spend the rest of your 2025 marketing budget could directly shape your company’s position in this market.

According to the Willis Towers Watson 2025 Salary Budget Planning Report:

38.9% of survey respondents anticipate recession or weaker financial results
34.4% have concerns related to cost management (e.g., rising cost of supplies)
In the US, organizations plan to increase salaries by 3.5% in 2026 – nearly identical to 2025 budgets. Canada, France, Germany and the UK are showing similar trends, with these markets forecasting increases between 3.2% and 3.6%
Most countries are forecasting salary increases that are relatively flat compared to last year

Gartner has some things to say about how AI will change some trends in the industry, and these are important to consider:

A prediction that 40% of Generative AI solutions will be multi-modal by 2027 (up from 1% in 2023 – a huge jump)
Early adoption could potentially lead to a competitive advantage and time-to-market benefits
Both open-source large language models (LLMs) and multi-modal AI technologies have high impact potential within the next five years

This means your remaining 2025 marketing budget should make room for experimentation with multi-modal AI tools and open-source LLMs, because early adoption could be the difference between leading the pack and scrambling to catch up.

How enterprise budgets will be affected by the growth of AI in 2026

A World Economic Forum survey found that 41% of companies worldwide will “reduce their workforces over the next five years because of the rise of artificial intelligence.” They’ll close locations, lay off employees, and slash budgets.

Bain found that “businesses are facing a growing shortage of skilled professionals as they race to implement AI”:

44% of executives say a lack of in-house expertise is slowing AI adoption
Demand for AI skills has grown 21% annually since 2019 amid an AI talent shortage likely to persist through 2027
Compensation for AI skills continues to increase, growing 11% annually since 2019

It feels bleak out there. Headlines that highlight a significant impact on reduced headcount. Marketing is frequently the first to go. But we think that’s a mistake. If anything, we believe it’s more important than ever to upskill your existing SEO team with Relevance Engineering skills.

There’s no getting around it – companies must consider digital platforms and AI as the primary direction of marketing budget.

In 2025, 27% of companies significantly increased their investment in AI. By the end of 2026, 37% expect to replace roles with AI, and many will restructure teams to prioritize automation.

McKinsey released a study earlier this year on how businesses are “rewiring to capture value.”

Their survey shows that AI-related hiring remains steady compared to 2024. Fewer organizations added data-visualization and design specialists but more introduced new risk-focused roles like AI compliance (13%) and AI ethics specialists (6%). Larger companies hired more broadly across AI roles, especially data scientists, machine learning engineers, and data engineers, while smaller firms lag behind.

Although filling these positions is still tough, fewer respondents than in previous years call it “very difficult,” except for AI data scientists, who remain in high demand – half of AI-using organizations say they’ll need more than they currently have.

Marketing departments are already outdated, and the companies that treat AI search as a passing fad are about to pull a Blockbuster. As search shifts toward generative systems like Google’s AI Overviews and ChatGPT, visibility is no longer about rankings or keywords but about engineering relevance across AI ecosystems.

The solution: evolve your SEO team into a GEO (Generative Engine Optimization) team, staffed with hybrid roles like Relevance Engineers, Retrieval Analysts, and AI Strategists. These specialists design, structure, and measure content the way AI systems understand it – through semantics, embeddings, and information architecture.

While the fundamentals of SEO still matter, the next phase of organic growth is about building systems that make your brand the default answer inside AI-driven search experiences.

Continue with the tired marketing playbook of the past and you’ll struggle.

Funnel your end-of-year marketing budget into the same old digital ads, and you may have very little to show for it. The same goes for outdated SEO approaches. We’ve already seen what happens when brands treat search like a side project: when disruption hits, they fall behind.

That’s why the smarter play today is to future-proof your content for AI-driven, and we’re already seeing some great results on our end.

Recently we helped a major client in the mortgage industry achieve a 27.4% Quarter-over-Quarter 7-figure revenue increase, powered by a 78% increase in leads.

And for a client in the FinTech space, our content engineering optimizations delivered significant bottom-line growth. Over an 8-month period, we more than doubled their organic traffic (a 101% increase!) and drove a 154% increase in sign-ups, proving the impact of our content optimizations.

When AI engines rewrite the rules, CMOs can’t just obsess over keyword rankings. The real goal is to make content extractable, citation-worthy, and relevant in AI outputs, whether that’s an AI Overview, a ChatGPT response, or a Perplexity answer.

That requires Generative Engine Optimization (GEO) and Relevance Engineering (r19g): structure content so machines can actually use it, embedding authority signals, and diversifying formats across text, video, audio, and UGC.

Keep your foot on the gas as competitors try to figure out the new playbook, and when the next market shift comes you’ll be the brand AI engines can’t ignore.

Why It’s Still Worth Investing in GEO and SEO (Even with Smaller Teams):

AI adoption = new markets: As AI search expands, brands with GEO capabilities will control visibility across dozens of new discovery channels, not just Google.
Competitive moat: With 97% of SEOs unprepared for this shift, early movers gain an enormous advantage in shaping AI’s understanding of their brand.
Revenue efficiency: GEO reduces dependency on paid channels by making content discoverable across AI assistants, search modes, and recommendation systems.
Scalable expertise: Relevance Engineering uses automation, NLP, and data science to do more with smaller, smarter teams—critical in leaner workforce environments.
Future-proof hiring: Demand for AI-literate marketers and engineers is exploding (up to 2,000% growth in key roles). Training or hiring for GEO now avoids costly catch-up later.
Financially sustainable: Companies that integrate GEO into existing SEO frameworks maximize current investments while positioning for long-term relevance in AI search ecosystems.

How enterprises handle end-of-year marketing budgets

It’s common for enterprises to take an up-or-out approach to their business. It’s no surprise that many enterprises take a use-it-or-lose-it approach to budgeting as well.

Let’s be honest.

Departments and business units are in constant competition with each other. There’s an internal struggle for resources that drives department spending.

Retain the current budget. If your end-of-year budget is unused, you’ll lose it. It’s also likely that next year’s budget will be lower; it becomes difficult to justify an increase when your department failed to use last year’s budget productively.
Increase the current budget. A budget increase means your team has to deliver more value. Departments that are hungry for growth need to (a.) justify their current budget and deliver more value, and (b.) produce a strong justification (via forecasts, projections, surveys, etc.) and outline why your budget needs to be increased.
Defend against internal competitors. The internal conflict between departments (e.g., sales and marketing) is a common issue. The sales department thinks marketing isn’t producing enough leads; they feel they can do a better job, so they ask for a bigger budget. These internal conflicts are often the results of operational silos and turf wars, but this kind of competition produces rivalries and turf wars all on their own.

CMOs are always under an enormous amount of pressure.

Thanks to our economic climate, and the uncertainty in the coming year as AI explodes, that pressure has only grown.

How do CMOs distribute their end-of-year excess marketing budget?

Gartner’s 2025 report, Marketing Budgets: Benchmarks for CMOs in the Era of Less, shows some surprising insights on CMOs’ approach to budgeting.

“Successful CMOs will lean in to disruption, in how they approach marketing strategy development, how they lead their function and collaborate cross-functionally, and how they drive marketing innovation. As operational interdependency has become the new norm, CMOs need to focus efforts where collaboration drives strategic impact and consider where emerging technologies (like AI) add to the strengths of their marketing team to deliver growth and cement marketing value.”

So what does that mean for CMOs with dwindling budgets?

“Breaking it down to the fundamentals, you need to define what the right ‘less’ looks like, accounting for the consequences of your trade-offs. More with less is about leaning in to your investments, ensuring they deliver the highest possible yield.”

So how will CMOs adjust their budget planning?

You know the answer.

They’ll work to accelerate growth.

If these CMOs are bullish on their ability to generate results in a moving target market, theymove forward. They’ll invest their marketing dollars aggressively. Smart CMOsplace their dollars in channels that produce strong short- and long-term returns.

What about end-of-year budget distribution?

Smart CMOsspend their end-of-year budget on initiatives likely to produce long-term value, giving them a jump in the upcoming year. They focus their attention on the channels thathelp them to produce more with less.

Should you throw your excess budget toward advertising?

It’s easy, low-hanging fruit.

A shot of general advertising would immediately drive traffic to your offerings and produce quick, short-term gains. That’s part of the problem, though. Everyonesees this effort for what it is, an attempt to exhaust your budget before it expires.

So, what’s the problem with that?

If you’d like to persuade the C-suite to increase your budget, advertising comes with a list of problems.

Well, why not?

Customers don’t like advertising
Customers don’t want to see advertising
Customers don’t trust advertising
Customers don’t need advertising

We use paid media because it’s effective in the right hands and an indispensable part of a balanced marketing plan, but a haphazard approach is throwing money away.

We know paid media works – it’s alluring due to the near-immediate response and reliability. That’s also the problem; it’s necessary, but there’s no compounding. When you turn it off, everything stops.

And we know Google willtest out AI ads in AI Mode in Q4 – they sent out a one sheet for testing in Q4 – but we don’t know how effective AI-driven advertising will be. (See more on this from Garrett here.)

Optmyzr did a PMax study – Evaluating Popular Strategies For ROI – and the results show that traditional digital advertising is going to change pretty radically with the changes related to AI.

PMax underperforms when mixed with other campaign types; siloed campaigns get auction priority.
Best performance: multiple campaigns with a single asset group (ROAS leader)
Feeds, exclusions, audience signals, and search themes often hurt or flatten results
Success requires at least 60 conversions/month – low-volume campaigns struggle
Text-only assets look “best” on paper, but video is the real creative workhorse
Heavy PMax spend (50%+ of budget) boosts ROAS but can weaken CPA/conversion rates
Human bias (exclusions, over-targeting, cluttered assets) usually reduces performance

What’s a better option?

Follow this three-step framework to maximize the value you receive from your end-of-year budget.

Assess your goals, current projects, and portfolio in relation to the growing changes with AI, Generative Engine Optimization (GEO), and new content strategy
Ensure your investments are linked to the company/marketing strategy
Optimize your projects and campaigns to maximize returns

What opportunities can be maximized?

The opportunities from end-of-year Content and SEO/GEO

We talked about paid media; now let’s talk about owned media.

Content and organic search are wonderful because the rewards compound. The value we receive today continues indefinitely into the future, frequently with minimal maintenance requirements.

Here’s an example.

Let’s say you create one 10x post.
This single post generates $750 of value each month.
Your team capitalizes on this and produces a series of ten posts, each earning $100 per month.
At this point, your monthly total is $1,750 per mo.
You reinvest, generating 50 posts that earn $100 per month. ($6,750 per month)
You repeat the process, producing 500 posts that earn $100 per month + 20 10x posts earning $750 per month
At this point, your monthly total is $65,000 per month or $780,000 annually.
These small numbers demonstrate the point.

Here’s the thing.

This doesn’t include the value you receive from organic search, including growing AI Search using LLMs.

The old ROI formula breaks down in the age of AI Search. The way content is retrieved, parsed, and synthesized has changed, and so has the value equation.

Because what we know about ranking for keywords has basically been thrown to the wolves. We operate in an environment where the ten blue links are no longer the Holy Grail.

We need to create for agentic AI – a variety of LLMs act as search engine user agents. They pull data from across the web to return a ChatGPT response, a Claude or Perplexity answer, a “conversation” between your potential client and an AI service.

This completely changes the game.

The old keyword-first mentality is basically obsolete. CMOs can’t just ask their teams to “rank for X keyword” and call it a day because the LLM doesn’t care about that anymore. Instead, AI engines are retrieve content based on whether it can be extracted, summarized, and trusted in response to a conversational query.

The shift to Generative Engine Optimization means CMOs need to think like machine trainers, not just marketers. AI engines reward clarity, structure, and corroboration.

That’s why brands need an omnimedia strategy – meaning an approach that considers every place you might show up online. Not just your website, but your content across all formats and platforms, including owned, earned, and shared media. It’s about publishing in a way that ensures your ideas exist in every format the system can see and reuse. That includes video, audio, data, and text. Sometimes that means refreshing old posts with richer media. Other times, it means creating new content designed to travel across multiple channels and modalities from day one.

An omnimedia content audit helps identify those gaps, and it’s one of the smartest ways to use end-of-year budget if you want your content to stay visible in AI-driven search results.

Content has to anticipate synthetic queries (the dozens of rewrites and follow-ups that AIs spin off from a single prompt) and be formatted so the model can easily map it to the right context.

CMOs should invest in frameworks like semantic markup, entity-rich copy, omni-format publishing (text, video, audio, UGC), and Relevance Engineering (r19g). These are the new prerequisites for discoverability.

Stop thinking in keywords and start thinking in citations.

Build content ecosystems that can survive AI’s slicing and dicing. Measure presence in AI Overviews, ChatGPT citations, and LLM outputs just as carefully as you used to measure organic rankings.

And budget for multidisciplinary content teams that combine SEO, data, PR, and UX, because optimizing for AI search is less about “ranking higher” and more about being the source AI engines can’t ignore.

Let’s look at an example: Imagine you’re in the market for an Aventon Ebike. Like this:

Results

The old way was to slice keywords into neat little clusters – “Aventon bike,” “Aventon financing,” “Aventon vs. competitor.” That kind of portfolio thinking made sense when Google was matching strings to strings.

But AI Search platforms are looking for more than just your exact keyword. They’re not looking for exact matches; they’re looking for clean, extractable answers they can drop into a summary.

This is why instead of just building keyword lists, you want to include a query fan out, which indicates the various related searches that Gemini probabilistically determines what would be related to the original search.

Build keyword portfolio with a keyword matrix
Think in terms of the questions an AI agent might spin up around your brand:
- Comparisons
- Dimensions
- Financing
- Pros/cons
- Competitor mentions
Package your content so each of those questions has a short, structured, and authoritative passage ready to be cited

The “customer intent” is still there, but now it’s parsed through synthetic related queries and model-driven reasoning, not keyword counts.

This means your analysis framework shifts. Persona insights still matter, but they inform what kinds of passages you need to create, not what keyword variations to stuff.

Content-centric audits should look at whether your copy is chunked, schema-tagged, and semantically rich enough to be retrievable.

Analytics need to track citations, prominence, and assisted conversions, not just volume.

Competitive analysis should assess whose content is actually being cited in AI outputs, not who’s “ranking.”

Directional mapping is now about aligning extractable passages with potential AI questions, not keyword gaps.

The endgame is the same: drive revenue, build authority, and anchor your brand in the conversation.

But the mechanics have changed.

You’re no longer optimizing for the spider. You’re optimizing for the summary.

Based on these new search parameters, you probably need to examine your current content closely. You should be able to prioritize the opportunities available to your business via search.

If you’re going to evaluate your keyword portfolio, you’ll want to do it across these five dimensions:

Persona-Based: Look closely at your current and prospective customers to uncover the kinds of questions they’re actually asking. Comparisons, pros and cons, financing details, competitor alternatives, how-to’s, etc. These intents should guide what passages you create for AI engines to cite.
Content-Centric: Audit your existing content not just for topics, but for how well it’s packaged. Are answers short, structured, and scannable? Do you have schema markup, clear headings, and entity-rich copy that makes your content easy for LLMs to extract?
Analytics-Based: Stop obsessing over keyword volume and CPC. Instead, measure where your content is being cited in AI outputs, how often you appear in AI Overviews or ChatGPT responses, and what those assisted visits or conversions look like.
Competitive: Don’t just check who’s ranking. Look at whose content is surfacing in AI summaries and citations. Which competitors are already shaping the narrative in AI Mode or Perplexity answers, and what kinds of passages or formats got them there?
Directional: Map extractable passages, not keywords, to target queries. Each core question or theme should have a page, section, or snippet designed for easy AI consumption. Then track whether those passages are being picked up, cited, and driving results.

Update your keyword portfolio (with help) + do a complete omnimedia audit

iPullRank can help you build a content engineering strategy powered by a keyword portfolio that:

Fuels revenue by making your content the go-to source for AI engines and LLMs
Establishes authority with clear, extractable answers across your core themes
Anchors your integrated marketing with passages designed for omni-format visibility

Instead of chasing keywords, you’ll get a keyword portfolio that shows where your biggest opportunities are, segmented by customer intent, use case, and value, so your content shows up when AI engines go looking.

A more complete solution includes multiple prongs that address keywords as well as overall content, and not just on your website.

The Keyword Portfolio

This is essentially your roadmap to how people actually search for your business. It’s a living document that shows what your audience wants, how they ask for it, and where your brand can show up. We pull together the data that really matters:

How and where people search for your products or services
Which types of content (articles, videos, AI results) appear for each topic
What’s performing well and what’s not
How your keywords connect to different goals, audiences, and use cases
Your Relevance Score – which shows how well your current content matches real search demand, plus shows performance data like clicks, rankings and engagement.

The Keyword Matrix

The keyword matrix takes things a step further.

Predicts how AI search systems like ChatGPT or Google’s AI Overviews might expand a single query into related questions and topics
This helps your brand show up not just for one search, but across all the connected ideas AI uses to build an answer to inform any optimization needs

The Omnimedia Content Audit

Once we know how people are searching for you and how AI interprets it, we use that data to review all your content.

This includes content not just across your site, but also all social channels, video, and more
We identify where you’re visible and where you’re not
We look at what formats perform best for your audience and for AI systems

The Omnimedia Content Plan

This is your actionable roadmap for creating and refreshing content that performs everywhere your audience (and AI) is looking.

Fortifies Content Resonance
Strengthens coverage across all discovery surfaces with content models and governance frameworks
Includes an AI Strength Measurement Plan that tracks input metrics, channel metrics, and performance metrics across AI Search surfaces

Together, these deliverables give you a unified, data-driven strategy that connects how people search, how algorithms interpret, and how your content performs, all grounded in the realities of AI-powered discovery.

CMOs are under a lot of pressure to perform. Marketing teams need to demonstrate they’re producing value with the budgets they already have. The compounding value of content and organic search gives you a clear way to demonstrate your value.

Properly structured GEO and Relevance Engineering campaigns can deliver value in the short and long term.

iPullRank has a comprehensive AI Search Strategy Plan that incorporates all of the above where we design and execute a strategy for your brand. Our experience has shown that these strategies earn measurable visibility across AI Search platforms, including Google (AI Overviews and AI Mode), ChatGPT, Perplexity, and others.

This bespoke program is only available for a select number of clients in 2026 – if you’re an enterprise brand leader looking for the insights, plans, audits, and metrics to win in the next era of search, schedule a call today.

Using your end-of-year marketing budget productively

What can you do to maximize the value you receive from your end-of-year budget? Is there a simple way to determine where you should focus your attention first?

As a matter of fact, there is.

Here are five options to maximize the gains you receive from your end-of-year budget.

Improve Page Performance via Relevance Engineering

Let’s be honest – traditional content audits are a grind. Pull the data, check rankings, eyeball traffic, and make a judgment call that may or may not align with your actual business strategy. That approach used to work when SEO was about keywords and clicks. But in the AI Search era, performance is about what aligns, not what ranks.

Content performance now depends on semantic precision. The question isn’t “Does this piece get traffic?” but “Is this piece contextually aligned with what our brand should be known for, and is it structured for machines to understand it?” That’s where Relevance Engineering comes in.

Instead of relying on gut instinct or traffic metrics, Relevance Engineering blends semantic embeddings (AI-generated representations of meaning) with SEO and content metadata to evaluate and rebalance your content library objectively. It’s a smarter, scalable way to identify what deserves to stay, what to update, and what to retire, with no guesswork required.

How Relevance Engineering Improves Page Performance

By using this framework, you can quantify alignment between your existing content and your business’s strategic focus – across thousands of URLs. The process identifies which assets reinforce your topical authority and which dilute it. The result is a tighter, more relevant content ecosystem that signals expertise to both users and AI-driven search systems.

The framework typically includes:

Content Relevance Scoring: Use AI embeddings to measure how semantically close each page is to your organization’s core topics and business priorities.
Performance Layering: Combine those scores with real-world SEO data (clicks, impressions, conversions) and content metadata (publish/update dates) for context.
Decision Modeling: Apply an evidence-based “Keep / Review / Prune” model to categorize each page and prioritize updates or consolidations.
Optimization Execution: Refresh or merge high-relevance but underperforming assets, redirect content with no strategic fit, and republish top performers with improved structure and metadata.

Why It Works

Relevance Engineering eliminates the subjective, time-consuming slog of manual pruning. It replaces opinion with evidence, merging semantic analysis and SEO insight into one defensible framework. This approach allows teams to:

Cut large content libraries efficiently without losing valuable pages.
Focus on content that reinforces brand authority and search intent.
Improve sitewide semantic relevance and focus — often by measurable percentages.
Strengthen AI Search visibility by ensuring content aligns both topically and structurally.

In practice, this isn’t just about cleanup. It’s about creating a leaner, sharper content portfolio that communicates expertise at scale — to audiences, search engines, and large language models alike.

Improve AI Visibility

If you’re part of an enterprise, your website probably has more content than anyone wants to admit. In the old world, we worried about crawl budget. In the new world, the issue is less about how many pages Googlebot can crawl and more about whether AI engines and LLMs can extract, trust, and reuse your content at all.

Think of it this way: AI systems don’t waste time “crawling.” They pull from massive indices, trusted ecosystems, and structured passages. If your content is bloated, repetitive, or buried in messy layouts, it simply won’t get cited.

Visibility depends on whether your pages are structured for retrieval, not just ranking.

Why your AI visibility matters:

Generative engines reward precision. Pages with clean structure, clear entities, and scannable passages are the ones that show up in AI Overviews, ChatGPT citations, and other LLM outputs. Pages with duplicate fluff or vague content are largely ignored.

The shift is from “optimizing for bots that crawl” to “optimizing for models that extract and synthesize.”

There’s a limit to AI’s patience, too. If your site is slow, unstructured, or throws errors, the models move on. If your passages are buried or irrelevant, they’ll pull from Reddit or Wikipedia instead.

Addressing AI visibility issues is a straightforward way to future-proof organic performance.

What you need:

Relevance audit, part 1: A qualitative + quantitative review of all your content to spot overlap, thin passages, or near-duplicates that confuse AI engines. The goal isn’t just to reduce clutter but to consolidate authority into passages that are extractable and citation-worthy.
Relevance audit, part 2: Instead of a crawl log, you need to know how and where your content surfaces in AI engines. Are you being cited in AI Overviews, Perplexity, or ChatGPT? Which passages get pulled, and which pages are invisible? This audit identifies the extractability gaps.
Semantic/AI-focused site audit: A deep review of your technical, content, and entity signals to pinpoint why models skip you. This goes beyond page speed or title tags and looks at schema, structure, embeddings, and whether your content is aligned with real-world queries and synthetic variations. A key part of this is mapping content into semantic triples (subject → predicate → object), so that AIs can interpret relationships and reuse your passages with confidence.
Relevance Engineering (r19g) recommendations: A prioritized roadmap to maximize AI visibility, including restructuring content into extractable chunks, layering semantic markup, fixing broken signals, and ensuring your brand shows up in omni-format ecosystems (site, video, UGC, PR).

Eliminate Redundant Signals for AI

When your content competes with itself in AI engines, you’re erasing your own visibility. Generative search cares about which passages are clear, unique, and trustworthy enough to cite.

Redundant or near-duplicate content means your brand’s authority gets diluted, and the AI grabs whatever looks simplest, often from your competitors.

Redundancy problems include overlapping pages that say the same thing, messy variations written for keyword padding, boilerplate-heavy CMS templates, and scraped content that outperforms your original.

When your content isn’t distinct, your visibility, credibility, and conversions all drop. The revenue leak is real: AIs won’t pick you if your signals are fuzzy, and users won’t convert if they don’t see you in the answer box.

What you need:

Entity & signal audit: Instead of a backlinks check, focus on whether your content distinctly represents the right entities, relationships, and context. This ensures AIs map your pages to unique concepts rather than lumping them together or skipping them entirely.
AI visibility testing: Run your content through AI Overviews, ChatGPT, Perplexity, and other LLMs. Which page gets cited? Which gets ignored? Use those results to restructure, redirect, or merge redundant content into authoritative, scannable assets.

Optimize for AI Readability & Relevance

Page speed and UX still matter, but in an AI-first search world, what really counts is how easily your content can be extracted, trusted, and reused by generative engines. A slow, messy, or unstructured page frustrates users and makes your content harder for AI to parse, synthesize, and cite.

Generative Engine Optimization shifts the focus from ranking factors to relevance signals. AI systems need short, scannable passages, clear entity relationships, and unambiguous formatting.

If your content is buried in design bloat, endless scrolls, or vague language, the engines skip you. Clean structure + fast delivery = higher odds your brand shows up in AI Overviews, ChatGPT answers, and other LLM-driven citations.

Think of it this way: speed and structure are about making sure machines see your content as usable fuel for their answer rather than focusing on better rankings anymore.

What you need:

Relevance Engineering audit: A full review of how your site’s content is chunked, structured, and labeled for AI retrieval. This goes beyond page speed and includes clarity, semantic markup, and whether AIs can extract your passages without confusion.
Entity & context recommendations: Specific guidance on adding schema, entity-rich copy, and layout-aware formatting that aligns with AI’s retrieval and synthesis pipelines. This ensures your content is mapped to the right context when engines assemble answers.

AI performance monitoring: Instead of just tracking load times or bounce rates, monitor how often your pages surface in AI Overviews, LLM citations, and multimodal queries. Treat this as your new “core vitals” for AI-era visibility.

Why you need an agency to maximize your opportunities

Companies are preparing to make big changes in how they run marketing, with a heavy focus on AI knowledge. The scope of this is typically too much for an in-house team to handle on their own.

This is exactly why you need an agency.

So let’s get the obvious stuff out of the way. When you work with an agency, you’re getting a full-stack team of specialists who already know how to operate as a unit. No onboarding, no training wheels. For the cost of one in-house hire, you get a mature team focused entirely on your outcomes, not politicking for the C-suite.

You know that. I know that.

What you may not know is that the real difference is both bandwidth and AI fluency plus relevance expertise. A strong agency in 2025 isn’t just running campaigns; it’s reverse-engineering how AI engines read, cite, and reward content.

If your agency knows what it’s doing, it should bring:

Proven GEO frameworks: Tested playbooks for making content citation-worthy in Google AI Overviews, ChatGPT, Claude, and beyond.
Crisis & recovery protocols: Response plans for when AI search tanks your traffic, citations vanish, or a model spits out your competitor instead of you.
Cross-disciplinary operators: Specialists in SEO, GEO, PR, data, and UX who can work independently but also engineer relevance signals together so your brand gets surfaced across AI channels.
Proprietary AI monitoring tools: Systems that track where you’re cited (or ignored) across LLMs – the kind of visibility you’ll never get from GA4 or Search Console.
The edge others won’t chase: The willingness to build structured content, feed AI-friendly formats, and run experiments that most agencies are too slow (or too scared) to try.

In the AI search era, it’s not about “ranking higher.” It’s about being the source the machines can’t skip. That’s the leverage your agency should be delivering.

These details make all the difference.

Imagine walking into your budget meeting with compelling data showing everyone why expanding your marketing budget is the smart play, and being able to speak to the hottest topic in every industry right now – AI.. Management’s decision is obvious if your results continue to compound year-over-year.

Use your end-of-year marketing budget to win

Your end-of-year budget can set your organization up for success in the new year.

But you have to start now.

The expectation is less about economic cycles and more about AI rewriting the playbook. As companies scramble to figure out what AI means for their marketing mix, budgets are shifting in real time.

Investments once locked into traditional SEO or paid channels are being questioned, reallocated, or tested against new AI-driven priorities. The competition for budget is only going to get sharper.

Use your end-of-year spend to double down on content and SEO/GEO strategies that are AI-ready and future-proof, so your visibility doesn’t vanish while everyone else is experimenting.

Create value that compounds.

As we’ve seen your content and search campaigns can produce exceptional rewards, thanks to compounding. Apply your end-of-year marketing budget to the right projects and you’ll find the value you receive from content and search compounds indefinitely into the future.

Do you have an SEO or Content Project that you’d like to invest in with your remaining 2022 marketing budget? Set up a call with iPullRank and earn billions in incremental revenue.

Explore the strategies, tactics, and frameworks that define AI Search.

The AI Search Manual: The Official Documentation for Relevance Engineering in AI Search

The post Strategic Ways to Use Your End-of-Year Marketing Budget appeared first on iPullRank.

Quick Tip: How OpenAI’s Product Feed Redefines Commerce Data

Mike King — Mon, 20 Oct 2025 18:25:14 +0000

For more than a decade, the Google Shopping feed has been the foundation of eCommerce visibility. It defined how merchants describe products to search engines (titles, prices, attributes, and availability) all optimized for crawling, indexing, and ad targeting.

But now we’re seeing the emergence of a new standard: OpenAI’s Product Feed specification. It’s not an incremental change, it’s an architectural shift. Instead of describing your products to a search engine, you’re describing them to an AI that can reason about them.

That means we’re no longer just optimizing for retrieval, we’re engineering for understanding.

If you’re a CMO, although we’re too early in the adoption curve for the agentic commerce protocol to matter for this BFCM, these changes represent a strategic signal about how brand data will live inside conversational ecosystems. If you’re an SEO, data engineer, or digital merchandiser, it’s the next schema you’ll need to master.

From Search Results to Conversations

Google’s Shopping feed was designed for a world of keywords and clicks. Its job is to make sure your product shows up when someone types a query, gets filtered correctly, and leads to a transaction on your site.

OpenAI’s feed is built for a world of questions and reasoning. It gives ChatGPT structured access to your product catalog so it can:

Compare products intelligently, understanding what makes one better for a given use case.
Answer buyer questions conversationally, pulling from your data, descriptions, and reviews.
Enable purchases directly inside ChatGPT, if you choose to allow it. Specifically, you can make a product searchable, but not purchasable.

That shift, from search indexing to semantic reasoning, mirrors the broader evolution of SEO into Relevance Engineering. It’s not about being found. It’s about being correctly understood in context.

What CMOs Need to Understand

This isn’t a technical upgrade. It’s a strategic one. OpenAI’s Product Feed changes the relationship between your catalog and your customer. However, a key distinction between OpenAI and Google is that OpenAI’s specifications expect that the product feed is the source of truth.

Your Catalog Becomes Content

Every field, from titles to reviews, becomes something a model can use to tell your brand’s story. Your product data effectively becomes your copywriting. If your descriptions lack voice, clarity, or context, you’re training the model to recommend someone else’s product. Since the product feed is the source of truth you can prepare different content from what is on your website.

You Gain Control Over Participation

The OpenAI feed includes two new control flags:

enable_search — decides whether a product can appear in ChatGPT search or recommendations.
enable_checkout — controls whether a user can complete the purchase within ChatGPT.

This lets brands experiment with AI visibility without fully ceding conversion control. You can treat ChatGPT like a top-of-funnel discovery engine or a full transaction channel on a per-product basis.

Freshness Becomes Part Of Your Brand

The spec supports feed updates every 15 minutes, making it possible to keep availability, pricing, and stock levels current. This differs from Google Shopping which updates every 24 hours, unless you set a custom frequency. By default, when an AI recommends your product, the data powering that recommendation is always in sync.

Data Structure Becomes Strategy

Where Google splits your product, pricing, inventory, and review data across multiple feeds, OpenAI merges it into a single structure. The result is a unified, semantically rich data model that doubles as both structured content and conversational training data.

The Practitioner’s View: What’s Actually Different

For SEOs and data practitioners, here’s how the two ecosystems compare in practice.

Category	OpenAI Product Feed Attribute	Google Feed Equivalent	Location in Google System	Equivalence Type	Notes / Differences
Identification	id, title, description, link, brand, gtin, mpn	Same	Core Product Feed	Same	Baseline identifiers are consistent.
Media / Assets	image_link, additional_image_link, video_link, model_3d_link	image_link, additional_image_link, (partial video support)	Core Feed / API	Partial	OpenAI adds native support for video and 3D models.
Availability & Inventory	availability, inventory_quantity	availability, quantity	Core Feed / Inventory Feed	Separate feed in Google	OpenAI merges availability and quantity inline.
Pricing & Offers	price, sale_price, geo_price, currency	price, sale_price, regional_price	Core Feed / Regional Pricing Feed	Separate feed in Google	Regional pricing now handled within one record.
Categorization	product_type, google_product_category, custom_label_0–4	Same	Core Product Feed	Same	Category logic carries over directly.
Relationships	relationship_type, related_product_id	(no equivalent)	—	New	Enables reasoning about product bundles and accessories.
Variants & Options	item_group_id, color, size, material, pattern, plus custom_variant1–3	Core variant fields only	Core Product Feed	Expanded	Adds flexibility for unique product attributes.
Merchant Control	enable_search, enable_checkout	(no equivalent)	—	New	Allows control over AI visibility and commerce participation.
Regionalization	geo_availability	regional_availability	Regional Inventory Feed	Separate feed in Google	Inline in OpenAI feed.
Reviews & Q&A	raw_review_data, q_and_a	review_text, rating	Separate Product Reviews Feed	Separate feed in Google	Consolidates user-generated content in one schema.
Compliance	adult, age_group, gender, energy_efficiency_class	Same	Core Product Feed	Same	Maintains parity.
Metadata	updated_at, created_at, feed_source	(no equivalent)	—	New	Adds operational transparency and freshness tracking.

Legend:

= Google requires a separate feed (Inventory, Regional Pricing, or Reviews)
= New attribute unique to OpenAI
= Similar, but expanded or implemented differently

What This Means for SEO and Data Operations

OpenAI’s Product Feed effectively collapses four Google feeds into one. That consolidation creates real operational advantages but also raises the bar for data quality.

Content Engineering Replaces Keyword Targeting

Models don’t care about keywords, they care about meaning. A well-structured feed that captures attributes, features, and emotional value gives ChatGPT more surface area to reason from. The richer your descriptions and review data, the better the AI understands your offering.

Freshness Becomes A Ranking Signal

In an environment that updates every 15 minutes, feed latency is the new technical debt. Real-time synchronization of pricing and inventory isn’t just operationally efficient, it determines whether your product is even eligible for AI recommendation.

Integration Replaces Markup

Where traditional SEO relied on schema.org markup to explain pages to search engines, the OpenAI feed makes your catalog directly machine-readable. You’re not helping an algorithm interpret HTML, you’re feeding structured truth into a reasoning system.

Conversational Accuracy Becomes Conversion Rate

In a conversational commerce experience, there is no “position one.” There’s just the most contextually relevant response. If your feed includes full review context, Q&A, and semantic relationships, your products give the AI more material to recommend confidently. The rewards for feed completeness are exponentially greater in the OpenAI environment.

Transforming a Google Feed into an OpenAI Feed

If you already manage a Google Shopping feed, you’re a strong percentage of the way there. Here’s a simple approach to transforming it for OpenAI’s schema.

Step 1: Consolidate your data sources

Merge your core product feed, inventory feed, regional pricing feed, and product reviews feed into a single dataset. Each product record should include:

Inventory count (inventory_quantity)
Regional availability or pricing (geo_availability, geo_price)
Reviews and Q&A data (raw_review_data, q_and_a)

If you don’t have those sources centralized, build a daily export from your data sources.

Step 2: Add OpenAI-specific attributes

For each product:

Set enable_search to true if it should appear in ChatGPT search or comparison queries.
Set enable_checkout to true only if you’ve enabled in-ChatGPT checkout.
Include updated_at timestamps to track freshness and facilitate partial updates.

Step 3: Extend variant and media support

If you sell products with non-standard variations (e.g., scent, wattage, fabric weight), use custom_variant1_category and custom_variant1_option to define them. Add any product videos or 3D models via video_link and model_3d_link.

Step 4: Automate and validate

Transform your existing Google Shopping CSV with a Python or Node script to match OpenAI’s schema. Schedule feed pushes every 15–30 minutes using your CMS or middleware. Validate against OpenAI’s Product Feed specification.

The Future: From Crawling to Comprehension

Google built its product feed for indexing. OpenAI built theirs for reasoning. One tells a search engine what you sell. The other helps an AI explain why it matters.

As generative search and AI-driven shopping experiences mature, the brands that treat their product data as a narrative that is structured, complete, and continuously updated will be the ones that own visibility in this new era of conversational commerce.

The Google Shopping feed made your catalog visible. The OpenAI Product Feed makes your catalog intelligible.

Post Script: A Complete Attribute Equivalence Table between the Google Shopping Product Feed and OpenAI’s

When I started building a tool to automatically convert a Google Shopping feed into OpenAI’s Product Feed format, it became clear that there is no single way to do it. Google’s ecosystem separates product data into multiple feeds such as core product, inventory, regional pricing, and reviews, while OpenAI brings all of that information together in one.

Instead of trying to create a universal solution, I mapped out the attribute equivalencies below. This gives you and your engineering teams a clear view of how each Google field aligns with the OpenAI schema so you can decide how to merge and transform your data based on your own systems and workflows.

Category	OpenAI Product Feed Attribute	Google Feed Equivalent	Location in Google System	Equivalence Type	Notes/ Differences
Identification	id	id	Core Product Feed	Same	Unique product identifier
	title	title	Core Product Feed	Same	Product name; similar guidelines
	description	description	Core Product Feed	Same	Rich text allowed, but OpenAI encourages natural phrasing for LLMs
	link	link	Core Product Feed	Same	Product page URL
	brand	brand	Core Product Feed	Same	Manufacturer or brand
	gtin, mpn	gtin, mpn	Core Product Feed	Same	Global identifiers
Media / Assets	image_link	image_link	Core Product Feed	Same	Main image
	additional_image_link	additional_image_link	Core Product Feed	Same	Supplementary images
	video_link	video_link	Optional YouTube link via Merchant Center API	Partial	Google supports via rich content schema or YouTube integration; not part of base feed
	model_3d_link	(no equivalent)	—	New	Enables 3D/AR assets for immersive shopping
Availability & Inventory	availability	availability	Core Product Feed	Similar	Google supports limited enums; OpenAI adds more granularity
	inventory_quantity	quantity	Separate Inventory Feed / Content API	Exists in separate feed	OpenAI merges inventory data directly; Google separates it into a dedicated “Inventory” feed
	condition	condition	Core Product Feed	Same	new, used, refurbished
Pricing & Offers	price	price	Core Product Feed	Same	Format and currency similar
	sale_price	sale_price	Core Product Feed	Same	Same semantics
	sale_price_effective _date	sale_price_effective _date	Core Product Feed	Same	Validity window
	geo_price	regional_price	Regional Pricing Feed	Exists in separate feed	OpenAI merges region-specific pricing inline
	currency	price (embedded)	Core Product Feed	Similar	Explicit in OpenAI feed; embedded in Google’s
Categorization	product_type	product_type	Core Product Feed	Same	Merchant-defined hierarchy
	google_product _category	google_product _category	Core Product Feed	Same	Google taxonomy (optional for OpenAI)
	custom_label_0–4	custom_label_0–4	Core Product Feed	Same	Campaign grouping
	relationship_type	(no equivalent)	—	New	Defines relationships (i.e., accessory_of, compatible _with)
	related_product_id	(no equivalent)	—	New	Links to related SKUs
Variants & Options	item_group_id	item_group_id	Core Product Feed	Same	Identifies variant family
	size, color, material, pattern	size, color, material, pattern	Core Product Feed	Same	Shared variant attributes
	custom_variant1 _category / option	(no equivalent)	—	New	Arbitrary variant dimension
	custom_variant2_ category / option	(no equivalent)	—	New	Arbitrary variant dimension
	custom_variant3_ category / option	(no equivalent)	—	New	Arbitrary variant dimension
Merchant Control & Visibility	enable_search	(no equivalent)	—	New	Controls visibility in ChatGPT search
	enable_checkout	(no equivalent)	—	New	Enables in-ChatGPT checkout
Regionalization / Localization	language	language	Core Product Feed	Same	ISO code format
	geo_availability	regional_ availability	Regional Inventory Feed	Exists in separate feed	Combines into one record in OpenAI
Reviews & Q&A	raw_review_data	review_text, rating, reviewer_name	Separate Product Reviews Feed	Exists in separate feed	Google separates reviews; OpenAI embeds review text inline
	q_and_a	(no equivalent)	—	New	Customer question-answer pairs for AI reasoning
Compliance & Attributes	adult	adult	Core Product Feed	Same	Marks adult products
	age_group	age_group	Core Product Feed	Same	Target audience
	gender	gender	Core Product Feed	Same	Target gender
	energy_efficiency_class	energy_efficiency_class	Core Product Feed	Same	Appliances/ electronics
Metadata & Maintenance	updated_at	(no direct equivalent)	—	New	Timestamp for freshness; not present in Google feed
	created_at	(no equivalent)	—	New	First appearance date
	feed_source	(no equivalent)	—	New	Useful for debugging data provenance

Want to find out about how Relevance Engineering can help your business?

Learn about iPullRank's Relevance Engineering Services

The post Quick Tip: How OpenAI’s Product Feed Redefines Commerce Data appeared first on iPullRank.