A GEO Platform With an MCP Server: How BobUpAI Runs Its SEO/GEO Loop Through an AI Agent

Ask an AI assistant to improve your product's visibility in AI answers and it will happily write you a plan. What it usually cannot do is the work: it has no idea where you actually stand, no ranked list of what to fix first, no way to ship a change to your site, and no way to check — weeks later — whether the change did anything.

The short answer: BobUpAI now exposes its entire GEO/SEO improvement loop to AI agents through a Model Context Protocol (MCP) server. Fifteen tools let an agent see where a product stands in AI answers and in Google's index, pick the highest-lift opportunity from the same ranked feed the dashboard shows, draft the fix, stage it as a reviewable change request, and record the URL where it went live — which is where measurement starts. The server is read-only by default, scoped to a single account by design, and every change passes the same human review gate as the dashboard. Today this is how we run BobUpAI on our own products; a hosted version that customers point their own agents at is on the roadmap.

This post is the honest version of that story: what the server does, the security decisions that shaped it, and one real card from the live feed walked end to end — including the part we have not shipped yet.

Why an agent, and not just a dashboard

The internal goal document for this project opens with one sentence: "drive the whole GEO/SEO auto-improve loop from an AI agent instead of the web UI, and only review the results."

That sentence came from watching how Generative Engine Optimization work actually gets done. A dashboard asks you to come to it, read a card, copy a draft, open your CMS, paste, publish, and come back next week. Every one of those steps is a place where the loop quietly stops. Agents invert that: the loop runs where the work already happens — your editor, your repo, your terminal — and the dashboard becomes what it should have been all along: the place a human reviews and approves.

MCP is the piece that makes this portable. It is an open protocol (introduced by Anthropic in late 2024) that lets any compatible agent — Claude Desktop, Claude Code, Cursor, and a growing list of others — call tools a server exposes. Instead of building one integration per assistant, we built one server and every MCP client can drive it.

What the agent can do: the fifteen tools

The tools map one-to-one onto the loop we already ask customers to run by hand.

Stage	Tools	What the agent is really asking
Orient	list_products · get_visibility · get_index_status	"Where do we stand — in AI answers and in Google's index?"
Find	list_opportunities · get_opportunity · refresh_opportunities · dismiss_opportunity	"What is the highest-lift thing to fix next, and what is the evidence?"
Ship	draft_opportunity · create_change_request · get_change_request · apply_change_request · confirm_change_request · cancel_change_request · list_change_requests	"Draft it, stage it for review, publish it, and record exactly where it landed."
Prove	list_shipped	"Did the changes we made actually work?"

Two of these deserve a sentence each, because they are the ones most tools in this category do not have.

confirm_change_request exists because measurement is only as good as its join key. When a change goes live, the agent reports the real URL it landed on — not a guess — and that URL is what every later before/after comparison hangs off. A wrong URL silently misdirects every measurement that follows, so the server verifies the page actually carries the change before recording it.

list_shipped answers the question dashboards in this category rarely can: what did we already ship, and what happened after? It returns published changes with their measurement so far — and it is honest about maturity: today it carries the baseline snapshot taken at publish time, and the +14-day and +30-day probes that fill in measured lift are still being built. The field is there; it says so when it is empty.

A real card, walked end to end

Here is an actual opportunity from our live feed — for 4D Lernen, the VR safety-training company from our case study. The card, verbatim from the agent's view on August 12, 2026:

Type: Mentioned only some of the time · risk: edits a live page · effort: medium

"The page vr-brandschutz-haptik-feuerloeschtrainer covers 'Welches VR-Brandschutztraining eignet sich am besten für Fachkräfte für Arbeitssicherheit (Sifa)?' (68%) but you're cited in only 25% of runs — strengthen the section to make it consistent."

Predicted lift: +0.32 · draft: already generated

The agent found this by calling list_opportunities, read the evidence with get_opportunity, and could carry it the rest of the way in four calls:

list_opportunities(product_id=41)      → the card above, ranked #1
get_opportunity(rec_id=145)            → evidence + the generated draft
create_change_request(rec_id=145)      → a reviewable change, addressed to the exact page section
apply_change_request(cr_id=…)          → hands back the instruction + artifacts (human reviews)
confirm_change_request(cr_id=…, live_url="https://www.4dlernen.de/…")
                                       → measurement starts here

And what should the outcome look like? In the shape we always use for this:

Before / after: what this card is pricing in

Prompt: "Welches VR-Brandschutztraining eignet sich am besten für Fachkräfte für Arbeitssicherheit (Sifa)?"

Today (real, from the live card): the page matches the question well (68% coverage) — but 4D Lernen is cited in only 25% of AI answer runs on this prompt.

After (what the +0.32 predicted lift represents): the same page, with the section strengthened, cited consistently across runs on the same prompt, same models.

The baseline row is real production data. The "after" row is the engine's prediction — we have not shipped this particular change through the agent loop yet. When we do, list_shipped is where the measured number lands, and we will publish it either way.

That last sentence is the point of the whole system. A GEO tool that only predicts is a horoscope; the loop is only closed when the same machinery that proposed the change comes back later and reports what actually happened. That discipline — prompt-level before/after measurement — is what moved 4D Lernen from 0% to past the market leader in seven weeks, and it is the same discipline the agent inherits for free.

Security by design, not by disclaimer

Handing an AI agent the keys to a platform that can edit live websites is exactly as dangerous as it sounds, so the server's defaults assume the worst:

Writes are off by default. Out of the box the server is read-only: an agent can look at everything and change nothing. The seven tools that dismiss, draft, publish or spend money refuse to run until write access is explicitly enabled for that session.
Scoped to one account, and it fails closed. The server refuses to start unless it is told which account it may see, and every tool checks ownership on every call. We did not get this right on day one: the first version fell back to reading across accounts if the scope was missing, and we hardened it to refuse instead — before writing this post, and with regression tests that prove the guards catch exactly that bug.
No new publish path. An agent's change goes through the same reviewable change request, the same approval step, and the same real-URL confirmation as a change made in the dashboard. The agent gets no shortcut around the human.
Local, not exposed. The server runs where we run it, speaks over stdio to the agent on the same machine, and adds no new endpoint to the internet and no new credential that could leak.

That last bullet is also the honest limitation: this is an operator's tool today, not a hosted feature. Making it something customers point their own agents at requires proper agent credentials and another round of authorization work on the HTTP side — that is the roadmap, and we would rather ship it late than ship it leaky.

One list, two disciplines: why GEO and SEO share the same feed

People keep asking whether they can run BobUpAI in "SEO mode" or "GEO mode." The feed deliberately refuses the split, because the two disciplines feed each other in both directions:

AI answer engines that ground their answers in live search can only cite what they can retrieve — so your Google position is an input to your odds of being cited. The winnability math behind every growth card uses it.
The most "SEO-looking" cards in the feed — restore a page that fell out of the index, merge two pages competing with each other — are priced by what they do to your AI citation rate, because that is where the recovered page earns its keep.

One ranked list, one currency of predicted lift, both disciplines in it on merit. The agent interface does give you something the app does not, though: every opportunity carries its type, so you can simply ask your agent for "only the Google-side work this week" and it will filter the list for you. get_index_status is pure Google; get_visibility is pure AI answers; the feed is deliberately both.

SEO tools are growing MCP servers — what matters is what sits underneath

We are not the only ones here, and honesty is house style (that's us in this paragraph, so read it knowing that). Frase ships a customer-facing MCP server — "Run Frase from Claude, Cursor, and any MCP tool," per their site (verified August 12, 2026) — and Ranketta listed an MCP server among its e-commerce features in our July 2026 market research. Theirs are available to customers today; ours runs operator-local while the credential and authorization work lands. On availability, they are ahead.

The question we would ask of any of them — ours included — is not "does it have MCP?" but "what do the tools sit on top of?" An MCP server in front of a content editor gives your agent a faster way to write drafts. An MCP server in front of a closed loop gives your agent a way to find the highest-lift gap, ship the fix through a review gate, and come back with a measured answer to "did it work?". The protocol is the easy part; the loop is the product.

What's next

Three things, in order. First, ship changes through the agent loop on our own products and publish the measured before/after — the section above owes you a number. Second, the +14-day and +30-day measurement probes, so list_shipped reports measured lift instead of just baselines. Third, the hosted MCP endpoint with per-user agent credentials, so "connect your agent" becomes a settings page instead of a blog post about our own tooling. No dates promised; the order will not change.

Frequently asked questions

Can I focus on only SEO or only GEO?

In the app, no — and it is deliberate. The feed is one ranked list because the disciplines are entangled: Google rank feeds AI citation odds, and index repairs are priced in citation rate. What you can do today, via the agent interface, is filter: every opportunity carries its type, so an agent can show you only the Google-side work or only the AI-answer work on request. There is no plan for a separate "SEO mode."

Which AI agents can use it?

Any MCP-compatible client — Claude Desktop, Claude Code, Cursor, and the growing list of assistants that speak the protocol. Today the server runs operator-local next to our own infrastructure, so in practice it is our team driving it; the hosted version for customer agents is on the roadmap.

Is my data safe when an agent is involved?

The server refuses to start without an account scope, checks ownership on every call, and is read-only unless writes are explicitly enabled per session. It runs locally over stdio — no new internet-facing endpoint, no new credential. And agent or no agent, every site change goes through the same review-and-approve gate as the dashboard.

Does the agent publish without a human?

No. The agent prepares everything — the draft, the change request, the exact target section — but applying a change requires writes to be explicitly enabled, the change request keeps a human-reviewable preview at every step, and confirmation records the URL a human verified. Review-then-apply is the contract, for agents and dashboards alike.

When can customers use the MCP server?

When we can hand it over without caveats: it needs proper per-user agent credentials and hosted-API authorization work first. The loop it drives — the ranked feed, drafts, one-click publishing, and measurement — is the product you can use today.

Want to see what an agent would find for your site? Run the free AI visibility check → — it is the same first step the agent takes: where do you stand, and what is the highest-lift thing to fix?

Sources: Model Context Protocol documentation · Anthropic: Introducing the Model Context Protocol · Frase — agents & MCP (verified August 12, 2026) · Ranketta feature listing per our market research (July 2026)

A GEO Platform With an MCP Server: How BobUpAI Runs Its SEO/GEO Loop Through an AI Agent