Expertise · GEO

Visibility in generated answers: we work on the part that can be controlled and we write in the offer what cannot.

What an agent model actually receives when it requests your page, what you decide for each of the three crawler categories, what you publish so you can be used as a source. No rankings, no citation guarantee.

Discuss a project

An offer, with conditionsWe have pieces, not a measured result, and we call them that. The pieces: a `llms.txt` file written by us, served in production with 200 and 2,137 bytes; an access check with ten model-agent identifiers, all receiving 200 and exactly 252,041 bytes on the same page; source lists published alongside claims — 522 citations in 26 content files. What we lack in order to be able to write “already built”: a citation measurement we can show, and an analysis module for that in our own analyser — it has one for direct answers, it does not have one for generated answers. There is another, more important reason: the result does not belong to us. A generated answer has no positions, has no place you can buy, and does not repeat identically from one user to another. A page that promised otherwise would be contradicted first by the client, on the first day.

A generated answer is not a list of links. The model composes a text and, if it chooses, attaches a few sources. There is no first place, there is no guarantee that a page will be cited, and the same question asked by two people, or by the same person the next day, can return a different answer and different sources. That is not a defect of our method, it is the shape of the mechanism. Any offer that starts with “we bring you into ChatGPT” passes over exactly this point.

What remains to be done is the part before the answer: whether the page is accessible to the agents that request it, whether the text is complete in HTML without JavaScript, whether it clearly says what the company is and what it does, and whether the statements on it are verifiable by someone who does not know you. Here everything can be measured, in response codes and in bytes. On this site we requested the same page with ten model agent identifiers — the search ones, the user-triggered ones, the training ones. All received 200 and exactly the same amount of content: 252,041 bytes. That is a finding, not a promise, and it can be repeated with a command.

The second thing that can be controlled is a decision, not a setting: what you do with the three categories of crawlers. The suppliers’ documentation separates them explicitly — at OpenAI, `OAI-SearchBot` for the search index, `GPTBot` for training, `ChatGPT-User` for the request started by a human, about which it is written that the rules in `robots.txt` may not apply; at Perplexity, `PerplexityBot` respects `robots.txt`, and `Perplexity-User` generally does not respect it, because the request comes from a person; `Google-Extended` is related to the training and grounding of Gemini models and, the documentation says, does not affect inclusion or ranking in Google Search. These are three independent decisions, with different consequences. On this site there is today a single general rule, in 129 bytes, so the position is implicit — not decided.

The third thing we say before the contract: for Google, a large part of “GEO” is, mechanically, SEO. Google’s own documentation says that, in order to appear as a supporting link in AI Overviews or in AI Mode, the page must be indexed and eligible to appear in search with a snippet, and that no new machine-readable files are needed to appear there. The practical conclusion is not that the work disappears, but that it moves: without indexing, server-side rendering and a page that says something verifiable, there is nothing to cite. That is why this page is read after the other two, not instead of them.

What it covers

The work, by component

We request the pages with the agent, we do not assume what it receives

Each important page is requested with the published identifiers of the model agents and we compare the response code, size and content fingerprint with what a browser receives. On this site, ten identifiers on the same page — search, user-triggered, training — all received 200 and all 252,041 bytes, and `robots.txt` was identical for all of them. We deliver the table, not the conclusion: agent, address, code, bytes. When a hosting provider or protection service filters one of them, it is visible here, not six months later.

The full text in HTML, checked in bytes

An agent that does not execute JavaScript sees only what is in the server response. We check that the page is server-rendered and that the text that matters is actually there — on this site, the `x-nextjs-prerender: 1` header and identical content for agent and browser. It is a boring check and it is the first one to fail on sites built as an application: the page looks perfect in the browser and is empty for anyone reading it as text.

The position regarding the three categories of crawlers, taken explicitly

Search crawler that sends people back, human-triggered agent that requested the page, training crawler. These are independent rules and different consequences: blocking the user-triggered agent means that the person who asked about you receives an answer without you. We write the rules, we write what you lose with each one, the decision is the owner’s. What we do not do: we do not present a single general rule as a strategy — on this site there are exactly that, 129 bytes, and we say so.

A machine-readable summary, written as a document

`llms.txt` is a short file that says what the organisation is, which pages matter and how they should be interpreted. Ours is static, 2,137 bytes, returns 200 in production, and has a section that says what the site does **not** support: that mentioning an institution does not mean partnership, that research projects are not medical devices. The limit, stated in the same sentence in which we offer it: Google’s documentation explicitly says you do not need new machine-readable files to appear in its generative features. We publish it because it forces you to write on a page what you really are, not because it would be a lever.

Statements receive their source next to them, on the page

On our service pages, every statement has a file and a line behind it, published in a list at the end of the page — 522 citations in 26 content files. The purpose is twofold: a person who decides can check, and a text that carries its verification is easier to use as a source than one that does not. What we do not say: that this increases the chance of being cited. It increases the chance of being **usable**. It is not the same thing and we have no way to measure the second.

What other sources say about you, inventoried

A generated response is also composed of pages that are not yours: catalogues, public registers, articles, discussions. We inventory what exists, note what is wrong — different legal name, dead address, description that contradicts the site — and prepare correction requests, which you send yourself, from your own address. What we do not do: we do not buy mentions, we do not write on forums under invented identities and we do not produce “reviews”. It is a lie with your name on it, and when it comes to light it comes out exactly in the place where you were trying to be credible.

Observing responses, as a dated log

We establish a set of real questions, written word for word, and periodically put them into the engines that matter to you. Each entry records the date, the engine, the exact question, the answer received and the sources cited. It is an observation log, reproducible as a method, not as a result — two runs on different days may not match, and we write that in the document header. What we do not produce: a percentage. A percentage here would be an invented figure from a sample we do not control.

Invented labels, treated as such

This site sends three meta-tags called `ai:context`, `ai:category` and `ai:location`, placed there in an earlier version. No engine documents that it reads them. We do not sell them as a service and we do not list them as achievements; we leave them written here as an example of what looks like optimisation without being it. If we find something like this on your site, you receive the same sentence: it costs zero, it proves zero.

What we do not promise, written before the contract

We do not promise that you will be cited, how many times you will be cited, or that you will appear for a particular question. There is no position to buy and no order that forces a model to recommend a company. What we deliver is verifiable in another way: the access table for each agent, the rendering state, the rules decided for each crawler category, the published summary, the inventory of third-party sources and the observation log with date. All of these can be recreated without us.

What it looks like

The path, step by step.

The access and rendering table

First deliverable: each important requested page with the published identifiers of the model agents, with code, size and content fingerprint, plus verification that the text is in HTML without JavaScript. From here on, the discussion has a line behind it. This is where the host provider’s filters, about which nobody knew, come to light.

The decision for the three categories, written before being applied

We put in writing what happens with each category if you leave it open and if you close it, including the awkward case: the agent triggered by a person who asked about you. Only after the decision is made and signed is `robots.txt` changed. We deliver the rules and the reason for each one, not just the file.

The machine-readable summary and the path to it

We write `llms.txt` as a short document — what the organisation is, which pages matter, how statements should be interpreted — and make it findable: mentioned in `robots.txt` and linked from the page. On this site the file exists and responds 200, but it is not mentioned anywhere and has no extended version; both gaps are written as gaps, not hidden.

The inventory of third-party sources and the corrections

A list of the public pages that mention you, what is wrong on each, and the text of the correction request. You send it yourself, from your own address. The reason is simple: a correction requested by an unknown intermediary is ignored, and one sent under a false identity is exactly the thing we refuse.

The observation log and its review

We fix the questions, the engines and the pace. Each run adds entries with a date; we do not rewrite old entries when the answer changes, because the difference between them is the only useful thing in the document. In the review we look at what changed in the mechanism, not only in the answers — crawler categories and their rules change more often than the text on the site.

The answer is composed from sources that orbit the question: your page, catalogues, articles, discussions. You control only one body in the drawing — and the form in which it can be read.

The data

What we touch, where it lives, and how long it stays

The questions anyone with a data protection officer would ask — asked here before they do.

What we read from your site: Only what is public: the HTML, response headers, `robots.txt`, the site map. We request the same pages several times, once for each agent identifier, at a limited pace. We do not need administrative access for the verification part.
What we read from outside the site: Public pages that mention you: catalogues, registers, articles, profiles. We read them like any visitor. We do not create accounts to reach closed content and we do not extract automatically, at scale, from generative engines — their terms forbid that, and a service built on breaking them stops on its own one day.
What we need from you: A decision, not access: what you do with each of the three crawler categories. Plus the right to publish two files in the root of the site, `robots.txt` and the machine-readable summary. And the list of the questions your clients actually ask — the observation log is useful only if the questions in it are theirs, not ours.
What the observation log contains: The date, the engine, the question written word for word, the answer received and the sources cited in it. No personal data of the person who asked the question, because the questions are ours, asked deliberately. If you want us to track questions coming from real users, it is set separately what is anonymised before it enters the document.
Where they are stored and how long they remain: The access table, the decided rules and the log are versioned in the project repository, alongside the code, not in a subscription tool from which you can no longer remove them. They live as long as the repository lives. When a figure changes, the history shows who changed it and when.

A case

Ten agents, the same page: what a model receives when it requests our site

The situation

Our own site, about 250 public addresses, 147 in the site map. The starting question was not “how do we appear in ChatGPT”, but one that can be answered: what does an agent model actually receive when it requests one of our pages, and how does that differ from what a browser receives.

What we built

We requested the same page with ten published agent identifiers — for assistant indexing, user-triggered, training — and compared the code, size and `robots.txt` served to each. Separately we checked whether the text is in the server response or is built in the browser, read the machine-readable summary file and searched for the path to it, and inventoried what the site sends as signals aimed at models.

What came out

All ten received 200 and exactly 252.041 bytes; `robots.txt` was identical for all, 129 bytes, with a single general group — so the position towards the three crawler categories is implicit, not decided. The page is server-rendered. The summary file exists, is static and returns 200 with 2.137 bytes, but it is not mentioned in `robots.txt`, is not linked from any page, and the extended variant required by convention returns 404. We also found three meta tags aimed at models, added in an earlier version, which no engine documents as reading.

What the case does not say

Nothing above says that we will be cited anywhere, and nothing of that kind was measured. The findings are about access and form — the part we control. From them, only one decision is made today (the summary file exists); the rest are open works, including the substantive decision on crawlers, which is not technical and is not made by the provider.

Questions

What people ask us before they call

Do you guarantee that ChatGPT or Perplexity will recommend my company?

No, and nobody can. A generated answer is composed on request, not chosen from an ordered list: it has no rankings, no place to buy, and it is not repeated identically for two users or for two days. There is no command that forces a model to recommend a company. What can be done is to avoid being impossible to find and impossible to verify when the model looks: a page accessible to the agent that requests it, full text in HTML, statements that can be confirmed from other sources. The rest does not belong to us, and we do not sell what does not belong to us.

Then what exactly is this page for, compared with SEO and direct answers?

For the question of what a model gets about you and in what form. SEO deals with the site’s inventory — every address crawled, one official version, titles that do not repeat — for engines that return a list. Direct answers deal with translating the page into data a machine reads without guessing, and there the result can be tested with the engine’s tool. Here there is neither list nor test tool: there is a composed text, in which you may be used as a source or not. That is why it is the only one of the three we write as an offer with conditions.

How do you measure it, if there is no position?

With an observation log, not with a metric. We establish your clients’ real questions, ask them periodically, and each time note the date, the engine, the question word for word, the answer and the cited sources. What comes out is a series of dated observations, from which a trend can be seen. What does not come out is a percentage, because a percentage here would mean a sample we do not control, from a system that may answer differently the second time. A provider who gives you an “AI visibility” score gives you a figure taken from a method they do not show you.

Does `llms.txt` really do anything?

It is a proposed convention, not an adopted standard, and Google’s documentation explicitly says you do not need new machine-readable files to appear in its generative features. We publish it anyway, for two practical reasons: it costs a static file, and writing it forces you to set out on one page who you are, what you do and what you do not claim — an exercise that usually reveals contradictions elsewhere on the site. Ours has 2,137 bytes and a section on how claims should be interpreted. What we do not do: we do not sell it as a lever for visibility.

Should I block AI crawlers?

There are three decisions, not one, and only they make up the answer. The search crawler of an assistant brings you into its results and sends people back. The agent triggered by a user appears because someone has just asked about you — if you block it, that person gets an answer without you, and the documentation of at least two providers says these agents may not respect `robots.txt`. The training crawler is the one that is usually discussed, and at Google it is separated by `Google-Extended`, about which the documentation says it does not affect inclusion or ranking in search. We put the three consequences on the table; the choice is the site owner’s.

I read that models cite forums a lot. Should we buy mentions there?

No. We do not write under invented identities, we do not pay for posts and we do not produce reviews. The reason is not moral in the abstract: a paid mention is a statement about your company that you cannot stand behind, published in a place you do not control, with your name on it. When someone checks — a client, a journalist, a model comparing sources — the discovery happens exactly where you were trying to be credible. What we do instead: inventory of existing real mentions, correcting the wrong ones, and content on your site that is worth citing.

Why is this page an “offer” and not “already built”, like the others?

Because our rule requires at least two proprietary implementations cited with file and line, and here we have pieces, not a result. We have the published and live summary file, we have the access check with ten agents on our own site, we have source lists under each statement. We do not have a citation measurement we can show, and our analyser has a module for direct answers and not one for generated answers. We could have written “already built” anyway. It would have been the first statement contradicted by an attentive client, and we have just written an entire page about why we do not do that.

What changes in six months?

Almost the whole surface: the names of the agents, their rules, the way an engine shows sources, which products display generated answers. That is why we do not sell a list of tactics. What does not change is the layer underneath: a page that is not accessible to the agent, that is built in the browser and not in the server response, or that does not verifiably say what the company is, cannot be used by anything — not by a search engine, not by a model, not by the person who opens it. That thing is done once and it lasts.

Do you do this separately from SEO or together?

Together, and not out of commercial convenience. Google’s documentation says that, to appear as a supporting link in its generative features, a page must be indexed and eligible to appear in search with a snippet. In other words, at Google the entry condition into the generated answer is the indexing work itself. It is possible to start with access and summarisation alone — it is useful on its own — but if the site is not indexable, that part has nothing to rest on, and we say so before, not after.

What the statements above rest on (12 sources)

Ten model agent identifiers on the same page: all receive 200 and all 252.041 bytes; `robots.txt` identical, 129 bytes, a single `User-Agent: *` grouphttps://www.megapromoting.com/servicii · 2026-09-06
OpenAI documents three agents with separate roles: `OAI-SearchBot` for the search index, `GPTBot` for training, `ChatGPT-User` for a user-initiated request, about which it writes that the rules in `robots.txt` may not applyhttps://developers.openai.com/api/docs/bots · 2026-09-06
Perplexity documents `PerplexityBot`, which respects `robots.txt`, and `Perplexity-User`, which it says generally does not respect it, because the request comes from a personhttps://docs.perplexity.ai/guides/bots · 2026-09-06
`Google-Extended` relates to the training and grounding of Gemini models and does not influence inclusion or ranking in Google Searchhttps://developers.google.com/search/docs/crawling-indexing/google-common-crawlers · 2026-09-06
Google’s documentation says that no new machine-readable files are required to appear in its generative features, and that a page must be indexed and eligible to appear with a snippet in order to be shown as a supporting link in AI Overviews or AI Modehttps://developers.google.com/search/docs/appearance/ai-features · 2026-09-06
The summary cannot be found: it is not mentioned in `robots.txt`, it is not linked from any page, and the extended `llms-full.txt` variant returns 404https://www.megapromoting.com/llms-full.txt · 2026-09-06
The page is server-rendered, so an agent that does not execute JavaScript receives the full texthttps://www.megapromoting.com/servicii · 2026-09-06

5 of them are code and files from our repositories. We don't publish their name or line: together, on a single page, they would describe too precisely how systems that aren't only ours are built. We go through them with you, in the repository, on request — verification stays possible, it just happens in a conversation.

How we work All services

What would you want to work better?

Tell us about your process. Together we decide what is worth building, what we can connect, and how we check the result.

Let's talk