Claude's Corner

Claude's Corner: Sitefire - The New Marketing Stack for the AI Search Era

Sitefire (YC W2026) built the marketing suite for the AI search era: monitor which AI models cite your brand, analyze what drives citations, and deploy content agents to earn more of them. BMW and DWS are already customers. Here's how the technical stack works and what it would take to replicate it.

Daniel Singer
Daniel Singer

Editor, StartupHub.ai

9 min read
Sitefire homepage screenshot with Claude's Corner badge

TL;DR

Sitefire built the analytics and content stack for brands competing to be cited by AI models instead of ranked by Google. BMW, DWS, and Xtrackers are already customers. The moat is the proprietary citation dataset - the data flywheel that compounds with every new customer and vertical.

5.6
D

Build difficulty

Contents(5)

Google built a two-decade monopoly on the question "how do brands reach customers searching for them?" SEO agencies, content farms, link-building shops, rank-tracking tools - an entire multi-billion dollar industry spun up around answering that question. And now the question has changed.

When someone types "which cloud storage solution should I use for a small team?" into ChatGPT, there is no blue link. There is an answer. That answer cites three or four sources. Those sources get traffic. Everything else gets nothing. The brands that show up in that answer don't rank there because of backlinks or keyword density. They rank there because the model has absorbed enough high-quality, contextually-relevant content about them to include them in its synthesis.

Sitefire (YC W2026) is building the marketing stack for this new reality. Not a monitoring dashboard bolted onto a legacy SEO tool. An end-to-end system: monitor which AI models cite you, understand what content drives those citations, deploy content agents to produce more of it, and push it directly to your CMS. BMW is a customer. DWS and Xtrackers are customers. AVI Medical is a customer. The category is real, the problem is real, and Sitefire is about as far ahead of anyone else as you'd expect from a team with Stanford deep RL and TU Munich robotics backgrounds.

What They Build

Sitefire calls itself a marketing suite for the agentic web. That framing is deliberate. This isn't just about ChatGPT. It's about a world where AI agents - shopping assistants, research assistants, writing assistants, customer service agents - are the primary interface between brands and consumers for an expanding set of queries. Google is one of those interfaces. So is Perplexity, Gemini, Microsoft Copilot, and the hundreds of vertical AI tools that will embed an LLM to answer product questions for their users.

The core product has three phases:

  • Monitor: Track how AI models answer questions relevant to your business. Sitefire generates a set of prompts from your SEO keywords, then submits them daily to ChatGPT, Gemini, and Google AI Mode. It captures not just the final answer but the intermediate fan-out queries each model generates internally - the 3-10 sub-questions an AI search engine formulates before synthesizing a response.
  • Analyze: Identify which pages get cited and why. The platform maps the full citation graph - which URLs appear in which answers, with what frequency, for which query clusters - and reverse-engineers what those pages have in common.
  • Act: Deploy content agents that write brand-aware, AI-optimized articles based on the citation analysis, then push them directly to Webflow, Framer, or whatever CMS the customer uses. Track downstream results via Google Analytics integration and network log analysis of AI crawler bot traffic.

The business model is B2B SaaS, enterprise tier. The go-to-market has been EU-first: BMW Group, DWS Xtrackers, and AVI Medical as early anchors. Pointhound, a mid-market case study, saw a 300 percent increase in site visits from AI search after deploying Sitefire content.

The Technical Architecture

The surface-level product looks like a dashboarding and content tool. The actual engineering challenge is in the data pipeline that feeds it.

Prompt generation and maintenance. Sitefire builds a query library for each customer using their SEO keyword data, then expands those keywords into longer conversational questions - the form factor that maps to how users actually prompt AI models. This is not a static set: it evolves as the customer's product and market evolve, and as Sitefire learns which prompt shapes correlate with citation opportunities in each vertical.

Daily LLM interrogation. For every query in a customer's library, Sitefire submits the prompt to multiple AI models on a daily cadence. The key insight the founders identified from their own testing: AI search engines don't just answer the question you asked. They expand it into fan-out sub-queries first, and those sub-queries are where the actual source retrieval happens. Capturing this fan-out layer - rather than just the final answer - is what makes the citation analysis actionable. You can see exactly which of your pages got pulled into the sub-query retrieval process.

The ranking inside that retrieval process uses a variant of Reciprocal Rank Fusion: a method that blends multiple ranked lists into a single relevance signal. Understanding this means Sitefire can predict with reasonable accuracy why a page gets cited, not just observe that it does.

Content agents and CMS push. Once Sitefire identifies a citation opportunity - "there are 12 prompts in this cluster where competitors are cited and we're not, and the top-cited content shares these three structural attributes" - it hands off to a content agent that synthesizes what the cited pages have in common, uses that as a brief, and produces a draft optimized for citation likelihood. The article goes through a review step before pushing. CMS integrations cover Webflow and Framer natively, with broader support on the roadmap.

Attribution and measurement. The measurement side is underrated and genuinely hard. Unlike a Google click, AI referral traffic is often invisible to standard analytics - models don't always pass referrer headers when linking out. Sitefire builds attribution through two channels: Google Analytics integration that catches the referrals it can, and network log analysis that tracks AI crawler bot activity directly. The bot traffic layer tells customers that a given AI model has indexed their new content and is actively using it in answer synthesis, before human referral traffic materializes. That's a useful signal for validating content investments.

Difficulty Score

DimensionScoreWhy
ML/AI4/10Primarily consuming commercial LLM APIs rather than training proprietary models. The technical sophistication is in the data collection methodology and RRF-based citation analysis, not in the models themselves.
Data8/10The citation pattern dataset - which content gets cited by which model for which queries across which verticals - is genuinely hard to replicate at scale. This is the real product. It compounds with every customer added and every day of daily querying.
Backend6/10Multi-LLM orchestration with daily scheduled queries at scale, fan-out query capture, RRF ranking analysis, bot traffic analytics from network logs, and reliable CMS push integrations. Each piece is solvable; making them work together without flaking is real engineering work.
Frontend5/10A citation analytics dashboard, competitive benchmarking views, and a content review + CMS push workflow. Non-trivial UX but not the core moat.
DevOps5/10Managing rate limits across multiple LLM APIs, handling model updates that change citation behavior, maintaining reliable daily schedules at scale. More operational complexity than a weekend project.

Where the Moat Is (and Isn't)

The honest answer on moat: this is primarily a data business wearing a SaaS suit.

The technical components are valuable but reproducible. Multi-LLM querying pipelines, CMS integrations, analytics dashboards - none of this is conceptually novel. A well-funded team could build a functional copy of Sitefire's surface product in a few months. The parts that matter are the ones that don't show up in a product demo.

StartupHub.ai data shows 447 companies have positioned themselves in the answer-engine optimization and AI search visibility category since large language models became consumer products. The vast majority are either manual services (consultancies teaching brands to optimize for AI) or basic monitoring tools (track your brand mentions across ChatGPT). Fewer than a handful are operating at Sitefire's level of automation, and most of those don't have enterprise customers providing the domain-specific data that makes citation analysis accurate.

The real moat is the dataset. Every customer Sitefire adds contributes citation signal across a new vertical. A BMW deployment teaches the system what content drives citations for luxury automotive queries in German-language AI models. A DWS deployment does the same for ETF product queries in European financial contexts. That dataset doesn't just improve Sitefire's ability to serve those customers - it improves the citation prediction model for adjacent customers in similar verticals.

This is the same flywheel dynamic that made Google's ad product defensible long after the underlying ad auction technology was well-understood by competitors. The technology was never the moat. The data was. Sitefire is making the same bet in a new domain.

What's not a moat: the content generation piece. Writing AI-optimized articles is a commodity capability. Every major LLM can produce competent long-form content with the right prompt engineering. Competitors will be able to replicate the content agent layer without difficulty. The value Sitefire adds is the brief the agent works from - the citation analysis that says "this query cluster, this structural pattern, this content attribute" - not the generation step itself.

What It Would Take to Replicate This

Technically, building a Sitefire clone is a medium-difficulty project for a competent software team. The hard part isn't the code - it's the go-to-market and the data. Getting BMW, DWS, and Xtrackers as early customers when you're two founders from Munich with no prior enterprise sales network is an extraordinary distribution achievement. It's also what gives them the data flywheel that will compound into a durable advantage.

The founders' backgrounds matter here in a way that isn't obvious from the product alone. Jochen Madler was the valedictorian of Germany's top finance program and a deep RL researcher at Stanford before doing PhD work at TU Munich. Vincent Jeltsch ran a robotics makerspace before building robots at RobCo. These aren't resume credentials - they're the context for why they ended up building a data collection and optimization system for a new information environment, rather than a simpler SaaS wrapper. The methodology Sitefire uses to analyze citation patterns has more in common with how you'd approach a reinforcement learning problem (observe behavior, understand reward signal, optimize toward it) than with how a traditional SEO tool works.

For a solo developer or small team looking to enter this space: the monitoring piece is accessible. Querying ChatGPT and Gemini for a set of prompts and tracking citations is a few hundred lines of Python. What's not accessible is the enterprise distribution needed to get enough verticals covered quickly enough to make the dataset valuable before a better-funded competitor does. Sitefire's EU-first strategy exploited a genuine geographic gap - US competitors were focused on English-language AI models while they were building for BMW's German-language queries. That's a real first-mover advantage, and replicating it requires geographic timing that's already expired.

Replicability score: 38 out of 100. The technical stack is reproducible; the data asset and enterprise relationships are not.

© 2026 StartupHub.ai. All rights reserved. You may not republish this article in full without a license. Search engines and AI research tools may crawl and summarize for reference. Bulk reproduction or model training requires a license. See our terms.

Build This Startup with Claude Code

Complete replication guide, install as a slash command or rules file

# Build Sitefire: AI Visibility Platform - Step-by-Step with Claude Code

A developer's guide to building an AI search citation monitoring and optimization platform like Sitefire.

## Step 1: Database Schema

Design a PostgreSQL schema (Supabase works well) for the core data model:

```sql
-- Brands / customers
CREATE TABLE brands (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  website TEXT,
  industry TEXT,
  cms_type TEXT, -- 'webflow' | 'framer' | 'wordpress'
  cms_token TEXT, -- encrypted
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Prompt library: queries to run daily
CREATE TABLE prompts (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  brand_id UUID REFERENCES brands(id),
  text TEXT NOT NULL,
  keyword TEXT,
  cluster TEXT, -- semantic cluster label
  active BOOLEAN DEFAULT true,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Daily runs: LLM responses and citation data
CREATE TABLE citation_runs (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  prompt_id UUID REFERENCES prompts(id),
  model TEXT NOT NULL, -- 'chatgpt' | 'gemini' | 'google-ai-mode'
  ran_at TIMESTAMPTZ DEFAULT now(),
  fan_out_queries JSONB, -- array of sub-queries the model generated
  cited_urls JSONB, -- [{url, rank, snippet}]
  brand_cited BOOLEAN DEFAULT false,
  raw_response TEXT
);

-- Content pieces: articles produced by content agents
CREATE TABLE content_pieces (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  brand_id UUID REFERENCES brands(id),
  title TEXT,
  body_markdown TEXT,
  target_prompts UUID[], -- prompt IDs this content targets
  status TEXT DEFAULT 'draft', -- draft | published
  cms_url TEXT,
  published_at TIMESTAMPTZ,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Bot traffic log: AI crawler visits parsed from network logs
CREATE TABLE bot_traffic (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  brand_id UUID REFERENCES brands(id),
  crawler_name TEXT, -- 'GPTBot' | 'Googlebot-Extended' | 'PerplexityBot'
  url_visited TEXT,
  visited_at TIMESTAMPTZ,
  user_agent TEXT
);
```

## Step 2: API Design

Build a REST API (Next.js API routes or FastAPI) with these core endpoints:

```
POST /api/brands              - Create a new brand / customer
GET  /api/brands/:id/dashboard - Return visibility scores by model + trend
POST /api/brands/:id/prompts  - Seed prompts from keyword list
GET  /api/brands/:id/citations - Citation history with competitor comparison
POST /api/brands/:id/generate - Trigger content agent for a prompt cluster
POST /api/brands/:id/publish  - Push approved draft to CMS

POST /api/internal/run-daily  - Cron: submit all active prompts to all models
POST /api/internal/ingest-logs - Ingest bot traffic logs from CDN/Cloudflare
```

Auth: JWT per brand. Internal endpoints protected by a CRON_SECRET header.

## Step 3: The LLM Query Pipeline

Core algorithm for daily citation harvesting:

```python
import openai, anthropic, google.generativeai as genai
import asyncio, httpx

MODELS = {
    "chatgpt": "gpt-4o-search-preview",
    "gemini": "gemini-2.0-flash",
}

async def run_prompt(prompt_text: str, model: str) -> dict:
    if model == "chatgpt":
        # Use web search variant that cites sources
        resp = openai.chat.completions.create(
            model=MODELS["chatgpt"],
            messages=[{"role": "user", "content": prompt_text}],
            web_search_options={"enabled": True}
        )
        citations = extract_openai_citations(resp)
        fan_out = extract_openai_fanout(resp)  # from search queries metadata
    elif model == "gemini":
        resp = genai.GenerativeModel(MODELS["gemini"]).generate_content(
            prompt_text,
            tools=[genai.Tool.from_google_search()]
        )
        citations = extract_gemini_citations(resp)
        fan_out = extract_gemini_fanout(resp)

    return {"cited_urls": citations, "fan_out_queries": fan_out}

# RRF-based citation scoring: rank pages across models using Reciprocal Rank Fusion
def compute_rrf_scores(model_rankings: list[list[str]], k=60) -> dict[str, float]:
    scores = {}
    for ranking in model_rankings:
        for rank, url in enumerate(ranking):
            scores[url] = scores.get(url, 0) + 1 / (k + rank + 1)
    return dict(sorted(scores.items(), key=lambda x: x[1], reverse=True))
```

## Step 4: Fan-Out Query Extraction

The key technical differentiator: capture sub-queries the AI generates internally.

```python
def extract_openai_fanout(response) -> list[str]:
    """Parse web search queries from OpenAI's tool_calls metadata."""
    fan_out = []
    for choice in response.choices:
        if hasattr(choice.message, 'tool_calls') and choice.message.tool_calls:
            for tool_call in choice.message.tool_calls:
                if tool_call.function.name == "web_search":
                    args = json.loads(tool_call.function.arguments)
                    fan_out.append(args.get("query", ""))
    return fan_out

def extract_gemini_fanout(response) -> list[str]:
    """Parse grounding metadata from Gemini responses."""
    fan_out = []
    if hasattr(response, 'candidates'):
        for cand in response.candidates:
            if hasattr(cand, 'grounding_metadata'):
                meta = cand.grounding_metadata
                if hasattr(meta, 'web_search_queries'):
                    fan_out.extend(meta.web_search_queries)
    return fan_out
```

## Step 5: Content Agent

Build the citation-optimized content agent:

```python
from anthropic import Anthropic

client = Anthropic()

def generate_citation_optimized_article(
    target_prompts: list[str],
    top_cited_pages: list[dict],  # [{url, title, snippet}]
    brand_context: dict
) -> str:
    """Generate an article that mirrors what top-cited pages do well."""
    
    # Synthesize what top-cited content has in common
    synthesis_prompt = f"""
You are analyzing {len(top_cited_pages)} pages that AI models frequently cite 
for queries like: {target_prompts[:3]}

Here are the top-cited pages: {json.dumps(top_cited_pages[:5])}

Identify: (1) common structural patterns, (2) depth of coverage, 
(3) specific claims or data points that appear repeatedly,
(4) content format signals (lists, comparisons, definitions, how-tos).
"""
    
    brief = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=1000,
        messages=[{"role": "user", "content": synthesis_prompt}]
    ).content[0].text
    
    # Generate the article
    article_prompt = f"""
Write a comprehensive article for {brand_context['name']} ({brand_context['website']}).

Target queries: {target_prompts}
Brand context: {brand_context['description']}
Content brief based on top-cited pages: {brief}

Requirements:
- Match the depth and structure of top-cited pages
- Include specific, verifiable claims
- Write for AI model ingestion (clear structure, direct answers, cited facts)
- Brand-aware but authoritative
- 800-1200 words
"""
    
    return client.messages.create(
        model="claude-opus-4-7",
        max_tokens=2000,
        messages=[{"role": "user", "content": article_prompt}]
    ).content[0].text
```

## Step 6: CMS Integration

Push approved content to Webflow or Framer:

```python
import httpx

async def publish_to_webflow(content: str, title: str, token: str, collection_id: str):
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"https://api.webflow.com/v2/collections/{collection_id}/items",
            headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
            json={
                "fieldData": {
                    "name": title,
                    "slug": title.lower().replace(" ", "-"),
                    "post-body": markdown_to_richtext(content),
                    "_archived": False,
                    "_draft": False
                }
            }
        )
        return resp.json()

async def publish_to_framer(content: str, title: str, token: str):
    # Framer CMS API - similar pattern
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            "https://api.framer.com/sites/YOUR_SITE_ID/pages",
            headers={"Authorization": f"Bearer {token}"},
            json={"title": title, "content": content}
        )
        return resp.json()
```

## Step 7: Deployment and Cron Jobs

Deploy with Vercel + Supabase + GitHub Actions:

```yaml
# .github/workflows/daily-run.yml
name: Daily Citation Harvest
on:
  schedule:
    - cron: '0 6 * * *'  # 6am UTC daily
  workflow_dispatch:

jobs:
  harvest:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run citation harvest
        env:
          DATABASE_URL: ${{ secrets.DATABASE_URL }}
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
        run: python scripts/run_daily_harvest.py

      - name: Ingest bot logs from Cloudflare
        run: python scripts/ingest_cf_logs.py
```

**Infrastructure checklist:**
- Supabase for database + storage
- Vercel for API routes + dashboard frontend
- GitHub Actions for daily cron (or Inngest for event-driven alternative)
- Cloudflare for CDN + bot traffic log access (Workers AI Logs)
- Resend for customer report emails
- Stripe for subscription billing

**Rate limit management:** Use exponential backoff with jitter for all LLM API calls. Budget 1 API call per prompt per model per day. At 100 prompts x 3 models = 300 calls/day per customer.

**Prompt caching:** Enable Anthropic prompt caching for the content brief synthesis step to reduce generation costs by 80% on repeat runs.
claude-code-skills.md
#YC W2026#Marketing Technology#AI Search#Answer Engine Optimization#Sitefire#Agentic AI#GEO#Content Marketing
Daniel Singer

Written by

Daniel Singer

Editor, StartupHub.ai

Daniel Singer is the editor of StartupHub.ai, a technology expert and thought leader on AI and its applications across sectors, from fintech and healthcare to developer tooling and consumer software. He writes and tests the tools covered here thoroughly and regularly, and built StartupHub.ai to give founders, operators and buyers a clearer read on what they are actually being sold.

More from Daniel SingerLinkedIn