With Sitecore's acquisition of Scrunch in June 2026, “agent experience” is about to become a first-class concern in enterprise DXP architecture. This article looks at how Scrunch's platform works technically — and what solution architects should do about it.
This analysis is based on Scrunch's published product documentation and both companies' public announcements. Where integration details have not been made public, we say so explicitly rather than speculate.
1. The Technical Problem: Agents Don't Browse, They Parse
A modern enterprise web page is optimized for human perception: client-side rendering, animation frameworks, navigation chrome, cookie banners, personalization scripts, and megabytes of JavaScript. An AI crawler or agent experiences none of that as value — it experiences it as noise and token cost.
The practical consequences for machine consumers:
- Heavy client-side rendering can leave critical content invisible to agents that do not execute JavaScript fully
- Boilerplate markup (navigation, footers, consent UI) dilutes the semantic signal of the actual content
- Poor heading hierarchy and missing structured data force models to guess at meaning and relationships
- Key facts locked in images, PDFs, or interactive widgets may never reach the model at all
The page a human sees and the page an agent understands are increasingly two different artifacts.
2. How AXP Works: Adaptive Serving at the Edge
Scrunch's Agent Experience Platform (AXP) sits in the content delivery path — at the edge/CDN layer, in front of the origin. Its core mechanism, per Scrunch's own product description, is straightforward:
- Detection — incoming requests are classified at the edge; known AI crawlers and agents are identified (user agents, request signatures) before the page is served
- Transformation — for agent traffic, AXP serves a clean, structured, semantically rich HTML version of the page, stripping non-essential markup and scripts
- Isolation — human visitors continue to receive the standard experience; traditional search engine indexing is left untouched
Conceptually, this is dynamic rendering reborn for the LLM era. A decade ago, teams pre-rendered JavaScript-heavy pages for Googlebot. AXP applies the same architectural pattern, but the target consumer is now a language model with a token budget, and the optimization target is semantic density rather than crawlability.
A governance note architects should not skip: serving different markup to agents than to humans inevitably raises the cloaking question. The defensible position — and the one this pattern depends on — is strict semantic parity: the agent version must carry the same information as the human version, in a machine-friendlier container. Teams should codify that parity requirement and review search engine guidelines as they evolve, because policy in this area is still moving.
3. The Observability Layer: Traffic, Citations, Site Maps
Serving optimized content is only half the loop. The other half is telemetry, and Scrunch ships three distinct instruments:
- Agent Traffic — analytics on which AI bots and agents actually hit your site, how often, and what they consume; effectively an access-log analysis specialized for machine visitors
- Monitoring & Citations — tracks how your brand appears in AI-generated answers across major platforms, and which sources those answers cite; this is your feedback signal for whether optimization is working
- Site Maps — models how AI systems traverse and interpret your site structure, exposing which sections are consumed and which are effectively invisible
Together these close the loop: observe how agents consume your estate, adjust what you serve, and measure the change in citations.
Architecture Review
Schedule a session with DCX Transform to review your rendering strategy, content models, and edge delivery against agent-readiness requirements.
4. Why This Maps Cleanly onto Sitecore Architecture
Sitecore has not yet published integration specifics, but the architectural fit is easy to see. Modern Sitecore implementations — XM Cloud and headless in particular — already separate structured content from presentation. Content lives as typed, componentized items; delivery happens through APIs and edge rendering.
That separation is precisely what agent experience requires:
- Structured content models give AXP-style transformation clean semantic input instead of scraped presentation markup
- Headless delivery via APIs means an agent-optimized rendering is just another head — no origin rework required
- Edge delivery pipelines already in place for personalization are the natural insertion point for agent detection and adaptive serving
- Workflow and governance in the CMS is where citation insights can become content actions — the closed loop both companies describe
Personalization asked: who is this human, and what should they see? Agent experience asks: which machine is this, and what should it understand?
Architecturally, they are the same problem — audience-conditional delivery — which is exactly why a DXP vendor acquiring an agent experience platform makes structural sense.
5. What Solution Architects Should Do Now
Regardless of when the Sitecore–Scrunch integration ships, these preparations pay off immediately:
- Audit agent traffic today — segment known AI crawlers (GPTBot, PerplexityBot, ClaudeBot, Google-Extended and peers) in your logs and quantify what they can actually retrieve
- Render critical content server-side — anything essential to your value proposition should be present in initial HTML, not hydrated later
- Invest in structured data — Article, Product, FAQ, Organization and Breadcrumb schema are the cheapest semantic signal you can ship
- Enforce semantic HTML discipline — proper heading hierarchy, landmark elements, and meaningful markup in your component library
- Define your robots policy for AI crawlers deliberately — blocking everything and allowing everything are both decisions with consequences; make them consciously
- Treat bilingual estates carefully — for Arabic-English platforms in KSA and UAE, ensure both languages carry equivalent structure and schema, or agents will systematically favor one
6. Open Questions Worth Tracking
Several things are genuinely not yet public, and honest architecture planning should track them rather than assume them:
- Integration depth and timeline — Sitecore has committed to integrating Scrunch into its DXP, but has not published a feature roadmap
- Licensing and packaging — whether agent experience capabilities land in existing Sitecore SKUs or as an add-on is unannounced
- Sovereign deployment coverage — whether Scrunch capabilities will be available in Sitecore's dedicated KSA and UAE deployments is not yet confirmed
- Agent detection arms race — as AI agents diversify beyond well-known crawlers, edge classification will need to keep pace
Frequently Asked Questions
What is Scrunch AXP?
AXP (Agent Experience Platform) is Scrunch's content delivery layer that detects AI agents and crawlers at the edge and serves them a clean, structured, semantically rich version of a page — without changing the experience for human visitors.
How does AXP relate to Sitecore architecture?
Following Sitecore's acquisition of Scrunch in June 2026, Scrunch's technology is expected to be integrated into Sitecore's digital experience platform. Structured content models, headless delivery, and edge rendering pipelines in Sitecore implementations align naturally with serving machine-optimized content to AI agents.
Is serving different content to AI agents considered cloaking?
Adaptive serving for AI agents aims to deliver the same content in a machine-friendlier format, not different information. Teams should still govern this carefully: keep semantic parity between human and agent versions and review search engine guidelines as they evolve.
The Architectural Takeaway
The Scrunch acquisition formalizes something architects have felt for two years: the web now has a second, machine-native audience, and serving it well is an infrastructure concern — detection, transformation, and delivery at the edge — not a content-team afterthought.
Teams whose platforms already practice structured content, server-side rendering, and edge delivery will find agent experience an extension of what they do. Teams who skipped that discipline will find it a migration.