diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2b8839a..40db6ab 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,15 @@
 ## Unreleased
 
+### Breaking Changes
+
+- **`style_comparison_tool` no longer depends on agent.mapbox.com (#152).** The comparison now runs only in this server's own MCP App panel (`ui://mapbox/style-comparison/index.html`), as part of retiring the old Mapbox Location Agent.
+  - **Removed:** the `share` input, the `agent.mapbox.com/tools/style-compare` link in the result text, the legacy MCP-UI `externalUrl` resource that framed that page, and the panel's "Open in browser" button. Clients without MCP Apps support get the text summary and preview links, with no comparison slider.
+  - **New output:** the tool returns `structuredContent` (`before`, `after`, `accessToken`, `beforePreviewUrl`, `afterPreviewUrl`, and optional `center`/`zoom`) with a matching output schema. The panel reads that payload instead of parsing a URL.
+  - **Sharing:** in place of the hosted comparison link, the result includes a Styles API preview link (`api.mapbox.com/styles/v1/{user}/{id}.html`) for each style, with the map position if one was given. You can open or share them on their own, and clients without MCP Apps support get these links. The links work with the token you pass as `accessToken`. With the auto-generated token they stop after an hour, and the result text says so.
+  - **Auto-generated tokens expire:** when no `accessToken` is passed, the tool now creates a 1-hour `tk.*` token. Before, it created a permanent `pk.*` token on every call, because the hosted page rejected `tk.*`, and each one stayed on the account until revoked. You can still pass your own `pk.*` token as `accessToken`.
+  - **Panel improvements from the hosted page:** styles load with `?fresh=true` so recent edits show up, and a style that fails to load now shows which side failed and why (not found, authentication or access denied). Errors after a style has loaded, such as a missing tile, no longer replace the map. The slider moves only on click and drag.
+- **`preview_style_tool` no longer takes `share` (#152).** `share: true` only checked that an `accessToken` was passed, so passing your own `pk.*` token as `accessToken` does the same thing: the preview link uses that token and keeps working after an hour. Without `accessToken`, the tool still creates a 1-hour `tk.*` token. A call that still sends `share` won't fail; the option is ignored.
+
 ### Maintenance
 
 - **OpenTelemetry JS 3.x (#149, same move as mapbox/mcp-server#325).** `@opentelemetry/sdk-trace-base` is deprecated in every 2.x release and removed in 3.0, and the ox-security scan flags it (mapbox/mcp-server#319). The OpenTelemetry set moves to the 3.0 line: `sdk-trace` 3.0.0 replaces `sdk-trace-base`, along with `resources` 3.0.0, `sdk-node`, `instrumentation` and `exporter-trace-otlp-http` 0.300.0, `auto-instrumentations-node` 0.82.0 and `api` 1.10.0.
diff --git a/src/resources/ui-apps/StyleComparisonUIResource.ts b/src/resources/ui-apps/StyleComparisonUIResource.ts
index d2e5c8b..83d9cda 100644
--- a/src/resources/ui-apps/StyleComparisonUIResource.ts
+++ b/src/resources/ui-apps/StyleComparisonUIResource.ts
@@ -15,6 +15,8 @@ const COMPARE_VERSION = '0.4.0';
  * Serves UI App HTML for Mapbox Style Comparison using mapbox-gl-compare.
  * Renders two synced GL maps with a draggable reveal slider inline —
  * no inner iframe needed, so frame-src CSP is not an issue.
+ * Reads the styles, token and initial position from the tool result's
+ * structuredContent; it does not depend on any hosted comparison page.
  * Implements MCP Apps pattern with ui:// scheme.
  */
 export class StyleComparisonUIResource extends BaseResource {
@@ -63,15 +65,6 @@ export class StyleComparisonUIResource extends BaseResource {
     }
     #before-label { left: 12px; }
     #after-label { right: 12px; }
-    #open-btn {
-      position: absolute; bottom: 12px; left: 50%; transform: translateX(-50%);
-      z-index: 10; display: none;
-      color: #fff; background: rgba(0,0,0,0.6);
-      font-size: 13px; padding: 5px 12px;
-      border: 1px solid rgba(255,255,255,0.4); border-radius: 4px;
-      cursor: pointer; font-family: inherit;
-    }
-    #open-btn:hover { background: rgba(0,0,0,0.8); }
     #fullscreen-btn {
       position: absolute; top: 10px; right: 10px; z-index: 10;
       display: none;
@@ -94,21 +87,19 @@ export class StyleComparisonUIResource extends BaseResource {
   <div id="error" style="display:none"></div>
   <div id="before-label" class="style-label"></div>
   <div id="after-label" class="style-label"></div>
-  <button id="open-btn">↗ Open in browser</button>
   <button id="fullscreen-btn" title="Toggle fullscreen">⛶</button>
 
   <script>
     var beforeMap = null;
     var afterMap = null;
     var compare = null;
-    var currentPreviewUrl = '';
     var currentDisplayMode = 'inline';
+    var STYLE_ID_PATTERN = /^[a-zA-Z0-9_-]+[/][a-zA-Z0-9_-]+$/;
 
     var loadingEl = document.getElementById('loading');
     var errorEl = document.getElementById('error');
     var beforeLabel = document.getElementById('before-label');
     var afterLabel = document.getElementById('after-label');
-    var openBtn = document.getElementById('open-btn');
     var fullscreenBtn = document.getElementById('fullscreen-btn');
 
     var messageId = 0;
@@ -131,6 +122,12 @@ export class StyleComparisonUIResource extends BaseResource {
       sendNotification('ui/notifications/size-changed', { height: 600 });
     }
 
+    function showError(message) {
+      loadingEl.style.display = 'none';
+      errorEl.textContent = message;
+      errorEl.style.display = 'block';
+    }
+
     fullscreenBtn.addEventListener('click', function() {
       var newMode = currentDisplayMode === 'fullscreen' ? 'inline' : 'fullscreen';
       sendRequest('ui/request-display-mode', { mode: newMode }).then(function(result) {
@@ -141,23 +138,6 @@ export class StyleComparisonUIResource extends BaseResource {
       }).catch(function() {});
     });
 
-    openBtn.addEventListener('click', function() {
-      if (!currentPreviewUrl) return;
-      sendRequest('ui/open-link', { url: currentPreviewUrl }).catch(function() {
-        try {
-          var ta = document.createElement('textarea');
-          ta.value = currentPreviewUrl;
-          ta.style.cssText = 'position:fixed;opacity:0';
-          document.body.appendChild(ta);
-          ta.select();
-          document.execCommand('copy');
-          document.body.removeChild(ta);
-          openBtn.textContent = '✓ URL copied';
-          setTimeout(function() { openBtn.textContent = '↗ Open in browser'; }, 2000);
-        } catch (err) {}
-      });
-    });
-
     window.addEventListener('message', function(event) {
       if (event.source !== window.parent) return;
       var message = event.data;
@@ -199,81 +179,93 @@ export class StyleComparisonUIResource extends BaseResource {
       sendNotification('ui/notifications/initialized', {});
     });
 
+    // Turns a GL JS error event into a message naming the side that failed.
+    function describeStyleError(side, styleId, e) {
+      var status = e && e.error && e.error.status;
+      var message = 'Failed to load the "' + side + '" style (' + styleId + ').';
+      if (status === 404) return message + ' The style was not found. Make sure it exists and is accessible with this token.';
+      if (status === 401) return message + ' Authentication failed. Check that the access token is valid.';
+      if (status === 403) return message + ' Access denied. The token may not have permission to read this style.';
+      var detail = e && e.error && e.error.message;
+      if (detail) return message + ' ' + String(detail).slice(0, 120);
+      return message;
+    }
+
     function handleToolResult(result) {
-      const textContent = result.content?.find(c => c.type === 'text');
-      if (!textContent?.text) {
-        loadingEl.style.display = 'none';
-        errorEl.textContent = 'No URL found in tool result';
-        errorEl.style.display = 'block';
+      if (beforeMap) return;
+
+      var data = result && result.structuredContent;
+      if (!data || typeof data.accessToken !== 'string' ||
+          !STYLE_ID_PATTERN.test(data.before) || !STYLE_ID_PATTERN.test(data.after)) {
+        showError('No style comparison found in tool result');
         return;
       }
 
-      const url = textContent.text;
-      currentPreviewUrl = url;
-      openBtn.style.display = 'block';
-
-      if (typeof mapboxgl === 'undefined') {
-        loadingEl.style.display = 'none';
+      if (typeof mapboxgl === 'undefined' || typeof mapboxgl.Compare === 'undefined') {
+        showError('Could not load Mapbox GL JS');
         return;
       }
 
-      try {
-        const parsed = new URL(url);
-        const token = parsed.searchParams.get('access_token');
-        const before = parsed.searchParams.get('before');
-        const after = parsed.searchParams.get('after');
-        if (!token || !before || !after) throw new Error('Missing required params');
-
-        // Parse optional initial position from hash (#zoom/lat/lng)
-        var center = [0, 20];
-        var zoom = 1.5;
-        if (parsed.hash) {
-          var parts = parsed.hash.replace('#', '').split('/');
-          if (parts.length >= 3) {
-            zoom = parseFloat(parts[0]) || 1.5;
-            center = [parseFloat(parts[2]) || 0, parseFloat(parts[1]) || 20];
-          }
-        }
+      var center = [0, 20];
+      var zoom = 1.5;
+      if (data.center && data.center.length === 2 && typeof data.zoom === 'number') {
+        center = [data.center[0], data.center[1]];
+        zoom = data.zoom;
+      }
 
-        mapboxgl.accessToken = token;
+      try {
+        mapboxgl.accessToken = data.accessToken;
 
+        // fresh=true bypasses the style CDN cache so recent edits show up.
         beforeMap = new mapboxgl.Map({
           container: 'before',
-          style: 'mapbox://styles/' + before,
+          style: 'mapbox://styles/' + data.before + '?fresh=true',
           center: center,
           zoom: zoom
         });
 
         afterMap = new mapboxgl.Map({
           container: 'after',
-          style: 'mapbox://styles/' + after,
+          style: 'mapbox://styles/' + data.after + '?fresh=true',
           center: center,
           zoom: zoom
         });
 
-        // Show style names once both styles have loaded
+        var loaded = { before: false, after: false };
         var loadedCount = 0;
-        function onStyleLoad(map, labelEl) {
+        var failed = false;
+
+        function onStyleLoad(map, side, labelEl, styleId) {
+          loaded[side] = true;
           var style = map.getStyle();
-          if (style && style.name) {
-            labelEl.textContent = style.name;
-            labelEl.style.display = 'block';
-          }
+          labelEl.textContent = style && style.name ? style.name + ' (' + styleId + ')' : styleId;
+          labelEl.title = labelEl.textContent;
+          labelEl.style.display = 'block';
           loadedCount++;
-          if (loadedCount === 2) {
+          if (loadedCount === 2 && !failed) {
             loadingEl.style.display = 'none';
-            compare = new mapboxgl.Compare(beforeMap, afterMap, '#comparison-container', {});
+            compare = new mapboxgl.Compare(beforeMap, afterMap, '#comparison-container', {
+              mousemove: false,
+              orientation: 'vertical'
+            });
             requestSizeToFit();
           }
         }
 
-        beforeMap.on('style.load', function() { onStyleLoad(beforeMap, beforeLabel); });
-        afterMap.on('style.load', function() { onStyleLoad(afterMap, afterLabel); });
+        // Only errors before a style has loaded are fatal; later ones (a
+        // missing tile, say) leave the comparison usable.
+        function onError(side, styleId, e) {
+          if (failed || loaded[side]) return;
+          failed = true;
+          showError(describeStyleError(side, styleId, e));
+        }
 
+        beforeMap.on('style.load', function() { onStyleLoad(beforeMap, 'before', beforeLabel, data.before); });
+        afterMap.on('style.load', function() { onStyleLoad(afterMap, 'after', afterLabel, data.after); });
+        beforeMap.on('error', function(e) { onError('before', data.before, e); });
+        afterMap.on('error', function(e) { onError('after', data.after, e); });
       } catch (e) {
-        loadingEl.style.display = 'none';
-        errorEl.textContent = 'Could not load style comparison';
-        errorEl.style.display = 'block';
+        showError('Could not load style comparison');
       }
     }
   </script>
diff --git a/src/tools/preview-style-tool/PreviewStyleTool.input.schema.ts b/src/tools/preview-style-tool/PreviewStyleTool.input.schema.ts
index 78dbb6d..65b2571 100644
--- a/src/tools/preview-style-tool/PreviewStyleTool.input.schema.ts
+++ b/src/tools/preview-style-tool/PreviewStyleTool.input.schema.ts
@@ -11,14 +11,7 @@ export const PreviewStyleSchema = z.object({
     )
     .optional()
     .describe(
-      'Existing Mapbox public token (must start with pk.* and have styles:read permission). Required when share is true, to build a durable link with a token you control. Optional otherwise — if omitted, a short-lived (~1 hour) preview token is generated automatically, so no existing token is needed for a quick inline look.'
-    ),
-  share: z
-    .boolean()
-    .optional()
-    .default(false)
-    .describe(
-      'Set to true to build a durable, shareable preview link using accessToken (required together with share). Defaults to false: generates a short-lived preview token automatically for viewing the style right now — the returned URL expires in about an hour and is not meant to be bookmarked or shared with others.'
+      'Existing Mapbox public token (must start with pk.* and have styles:read permission). Optional — if omitted, a short-lived (~1 hour) preview token is generated automatically, so no existing token is needed. Pass your own token when you want a preview URL that keeps working after that hour.'
     ),
   title: z
     .boolean()
diff --git a/src/tools/preview-style-tool/PreviewStyleTool.ts b/src/tools/preview-style-tool/PreviewStyleTool.ts
index c69a923..d679a94 100644
--- a/src/tools/preview-style-tool/PreviewStyleTool.ts
+++ b/src/tools/preview-style-tool/PreviewStyleTool.ts
@@ -17,7 +17,7 @@ import type { HttpRequest } from '../../utils/types.js';
 export class PreviewStyleTool extends BaseTool<typeof PreviewStyleSchema> {
   readonly name = 'preview_style_tool';
   readonly description =
-    'Generate a live preview of a Mapbox style. By default, auto-generates a short-lived preview token so you can view it right away — no existing token needed. Pass `share: true` with an existing public `accessToken` instead to generate a durable, shareable preview link.';
+    'Generate a live preview of a Mapbox style. By default, auto-generates a short-lived preview token so you can view it right away — no existing token needed. Pass an existing public `accessToken` instead to get a preview link that keeps working after the hour.';
   readonly annotations = {
     readOnlyHint: true,
     destructiveHint: false,
@@ -52,7 +52,7 @@ export class PreviewStyleTool extends BaseTool<typeof PreviewStyleSchema> {
     let publicToken: string;
 
     if (input.accessToken) {
-      // Caller-supplied token — used as-is, for either mode.
+      // Caller-supplied token — used as-is.
       try {
         userName = getUserNameFromToken(input.accessToken);
       } catch (error) {
@@ -67,19 +67,6 @@ export class PreviewStyleTool extends BaseTool<typeof PreviewStyleSchema> {
         };
       }
       publicToken = input.accessToken;
-    } else if (input.share) {
-      return {
-        isError: true,
-        content: [
-          {
-            type: 'text',
-            text:
-              '`share: true` requires an existing public token via `accessToken` — a persistent ' +
-              'pk.* token is needed for a durable, shareable link. Get one via list_tokens_tool ' +
-              'or create_token_tool, or omit `share` for a quick inline preview (no token needed).'
-          }
-        ]
-      };
     } else {
       if (!accessToken) {
         return {
diff --git a/src/tools/style-comparison-tool/StyleComparisonTool.schema.ts b/src/tools/style-comparison-tool/StyleComparisonTool.input.schema.ts
similarity index 68%
rename from src/tools/style-comparison-tool/StyleComparisonTool.schema.ts
rename to src/tools/style-comparison-tool/StyleComparisonTool.input.schema.ts
index f23d215..17a6998 100644
--- a/src/tools/style-comparison-tool/StyleComparisonTool.schema.ts
+++ b/src/tools/style-comparison-tool/StyleComparisonTool.input.schema.ts
@@ -26,18 +26,11 @@ export const StyleComparisonSchema = z.object({
     .string()
     .startsWith(
       'pk.',
-      'Invalid token type. Style comparison requires a public token (pk.*) that can be used in browser URLs. Secret tokens (sk.*) cannot be exposed in client-side applications. Please provide a public token with styles:read permission.'
+      'Invalid token type. Style comparison requires a public token (pk.*) that can be used in the browser. Secret tokens (sk.*) cannot be exposed in client-side applications. Please provide a public token with styles:read permission.'
     )
     .optional()
     .describe(
-      'Existing Mapbox public token (must start with pk.* and have styles:read permission). Required when share is true, to build the comparison link with a token you control. Optional otherwise — if omitted, a scoped preview token is generated automatically, so no existing token is needed for a quick inline comparison.'
-    ),
-  share: z
-    .boolean()
-    .optional()
-    .default(false)
-    .describe(
-      'Set to true to build the comparison link with an existing public token you provide via accessToken (required together with share) — use this for a link you intend to keep or share with someone else. Defaults to false: generates a scoped preview token automatically, tied to this comparison only and not tracked or named by you, so no existing token is needed for a quick look right now.'
+      'Existing Mapbox public token (must start with pk.* and have styles:read permission). Optional — if omitted, a short-lived scoped preview token is generated automatically, so no existing token is needed.'
     ),
   zoom: z
     .number()
diff --git a/src/tools/style-comparison-tool/StyleComparisonTool.output.schema.ts b/src/tools/style-comparison-tool/StyleComparisonTool.output.schema.ts
new file mode 100644
index 0000000..ea194af
--- /dev/null
+++ b/src/tools/style-comparison-tool/StyleComparisonTool.output.schema.ts
@@ -0,0 +1,35 @@
+// Copyright (c) Mapbox, Inc.
+// Licensed under the MIT License.
+
+import { z } from 'zod';
+
+export const StyleComparisonOutputSchema = z.object({
+  before: z
+    .string()
+    .describe('Resolved "before" style in username/styleId format'),
+  after: z
+    .string()
+    .describe('Resolved "after" style in username/styleId format'),
+  accessToken: z
+    .string()
+    .describe(
+      'Public token the comparison view uses to load both styles (the one supplied, or a short-lived auto-generated tk.* token)'
+    ),
+  beforePreviewUrl: z
+    .string()
+    .describe(
+      'Styles API preview page for the "before" style, to open or share on its own'
+    ),
+  afterPreviewUrl: z
+    .string()
+    .describe(
+      'Styles API preview page for the "after" style, to open or share on its own'
+    ),
+  center: z
+    .tuple([z.number().describe('Longitude'), z.number().describe('Latitude')])
+    .optional()
+    .describe('Initial map center as [longitude, latitude], if provided'),
+  zoom: z.number().optional().describe('Initial zoom level, if provided')
+});
+
+export type StyleComparisonOutput = z.infer<typeof StyleComparisonOutputSchema>;
diff --git a/src/tools/style-comparison-tool/StyleComparisonTool.ts b/src/tools/style-comparison-tool/StyleComparisonTool.ts
index 5fc064d..eae9134 100644
--- a/src/tools/style-comparison-tool/StyleComparisonTool.ts
+++ b/src/tools/style-comparison-tool/StyleComparisonTool.ts
@@ -3,13 +3,19 @@
 
 import { randomUUID } from 'node:crypto';
 import type { CallToolResult } from '@modelcontextprotocol/server';
-import { createUIResource } from '@mcp-ui/server';
 import { BaseTool } from '../BaseTool.js';
 import {
   StyleComparisonSchema,
   StyleComparisonInput
-} from './StyleComparisonTool.schema.js';
-import { getUserNameFromToken } from '../../utils/jwtUtils.js';
+} from './StyleComparisonTool.input.schema.js';
+import {
+  StyleComparisonOutputSchema,
+  StyleComparisonOutput
+} from './StyleComparisonTool.output.schema.js';
+import {
+  getUserNameFromToken,
+  mapboxApiEndpoint
+} from '../../utils/jwtUtils.js';
 import {
   mintScopedPreviewToken,
   describeAutoMintFailure
@@ -17,11 +23,12 @@ import {
 import type { HttpRequest } from '../../utils/types.js';
 
 export class StyleComparisonTool extends BaseTool<
-  typeof StyleComparisonSchema
+  typeof StyleComparisonSchema,
+  typeof StyleComparisonOutputSchema
 > {
   readonly name = 'style_comparison_tool';
   readonly description =
-    'Generate a live side-by-side comparison of two Mapbox styles. By default, auto-generates a scoped preview token so you can compare them right away — no existing token needed. Pass `share: true` with an existing public `accessToken` instead to generate a comparison link using a token you manage yourself.';
+    'Show a live side-by-side comparison of two Mapbox styles with a draggable slider, rendered inline in clients that support MCP Apps. By default, auto-generates a short-lived scoped preview token so you can compare them right away — no existing token needed. Also returns a Styles API preview link for each style, to open or share on its own. Pass an existing public `accessToken` to use a token you manage yourself, so those links keep working after the hour.';
   readonly annotations = {
     readOnlyHint: true,
     destructiveHint: false,
@@ -35,8 +42,7 @@ export class StyleComparisonTool extends BaseTool<
       resourceUri: 'ui://mapbox/style-comparison/index.html',
       csp: {
         connectDomains: ['https://*.mapbox.com'],
-        resourceDomains: ['https://*.mapbox.com'],
-        frameDomains: ['https://*.mapbox.com']
+        resourceDomains: ['https://*.mapbox.com']
       }
     }
   };
@@ -44,7 +50,10 @@ export class StyleComparisonTool extends BaseTool<
   private readonly httpRequest: HttpRequest;
 
   constructor(params: { httpRequest: HttpRequest }) {
-    super({ inputSchema: StyleComparisonSchema });
+    super({
+      inputSchema: StyleComparisonSchema,
+      outputSchema: StyleComparisonOutputSchema
+    });
     this.httpRequest = params.httpRequest;
   }
 
@@ -100,21 +109,7 @@ export class StyleComparisonTool extends BaseTool<
     let publicToken: string;
 
     if (input.accessToken) {
-      // Caller-supplied token — used as-is, for either mode.
       publicToken = input.accessToken;
-    } else if (input.share) {
-      return {
-        isError: true,
-        content: [
-          {
-            type: 'text',
-            text:
-              '`share: true` requires an existing public token via `accessToken` — a persistent ' +
-              'pk.* token is needed for a durable, shareable link. Get one via list_tokens_tool ' +
-              'or create_token_tool, or omit `share` for a quick inline comparison (no token needed).'
-          }
-        ]
-      };
     } else {
       if (!accessToken) {
         return {
@@ -128,20 +123,14 @@ export class StyleComparisonTool extends BaseTool<
         };
       }
       try {
-        // Unlike the inline style preview, the comparison page this URL
-        // points to (agent.mapbox.com/tools/style-compare) validates the
-        // token prefix itself and hard-rejects anything but pk.* — a
-        // short-lived tk.* token (this repo's usual auto-mint default)
-        // fails there with a "Configuration Error", confirmed live. So
-        // this mints a real, non-expiring pk.* token instead: narrowly
-        // scoped, but it persists on the account until manually revoked.
+        // The comparison renders in our own ui:// panel with GL JS, which
+        // accepts a short-lived tk.* token, so nothing persists on the account.
         publicToken = await mintScopedPreviewToken(
           this.httpRequest,
           accessToken,
           {
             note: 'Style Comparison (auto-generated)',
-            scopes: ['styles:tiles', 'styles:read', 'fonts:read'],
-            expiresInMs: null
+            scopes: ['styles:tiles', 'styles:read', 'fonts:read']
           }
         );
       } catch (error) {
@@ -173,49 +162,52 @@ export class StyleComparisonTool extends BaseTool<
       };
     }
 
-    // Build the comparison URL
-    const params = new URLSearchParams();
-    params.append('access_token', publicToken);
-    params.append('before', beforeStyleId);
-    params.append('after', afterStyleId);
-
-    // Build base URL
-    let url = `https://agent.mapbox.com/tools/style-compare?${params.toString()}`;
-
-    // Add hash fragment for map position if all coordinates are provided
+    let position = '';
+    let hash = '';
+    let view: Pick<StyleComparisonOutput, 'center' | 'zoom'> = {};
     if (
       input.zoom !== undefined &&
       input.latitude !== undefined &&
       input.longitude !== undefined
     ) {
-      // Format: #zoom/latitude/longitude
-      url += `#${input.zoom}/${input.latitude}/${input.longitude}`;
+      position = ` at zoom ${input.zoom}, ${input.latitude}, ${input.longitude}`;
+      hash = `#${input.zoom}/${input.latitude}/${input.longitude}`;
+      view = { center: [input.longitude, input.latitude], zoom: input.zoom };
     }
 
-    // Build content array with URL
-    const content: CallToolResult['content'] = [
-      {
-        type: 'text',
-        text: url
-      }
-    ];
-
-    // Add MCP-UI resource (for legacy MCP-UI clients)
-    const uiResource = createUIResource({
-      uri: `ui://mapbox/style-comparison/${beforeStyleId}/${afterStyleId}`,
-      content: {
-        type: 'externalUrl',
-        iframeUrl: url
-      },
-      encoding: 'text',
-      uiMetadata: {
-        'preferred-frame-size': ['1000px', '700px']
-      }
-    });
-    content.push(uiResource);
+    // Standalone Styles API preview pages for each side, so the styles can
+    // be opened or shared outside the inline comparison panel.
+    const previewUrl = (styleId: string) =>
+      `${mapboxApiEndpoint()}styles/v1/${styleId}.html?${new URLSearchParams({
+        access_token: publicToken,
+        fresh: 'true'
+      }).toString()}${hash}`;
+
+    const structuredContent: StyleComparisonOutput = {
+      before: beforeStyleId,
+      after: afterStyleId,
+      accessToken: publicToken,
+      beforePreviewUrl: previewUrl(beforeStyleId),
+      afterPreviewUrl: previewUrl(afterStyleId),
+      ...view
+    };
+
+    const expiry = input.accessToken
+      ? 'They use the access token you supplied.'
+      : 'They use an auto-generated token and stop working in about an hour; pass your own public accessToken for links that last.';
 
     return {
-      content,
+      content: [
+        {
+          type: 'text',
+          text:
+            `Comparing ${beforeStyleId} (before, left) with ${afterStyleId} (after, right)${position}.\n\n` +
+            `Preview links to open or share each style on its own. ${expiry}\n` +
+            `- Before: ${structuredContent.beforePreviewUrl}\n` +
+            `- After: ${structuredContent.afterPreviewUrl}`
+        }
+      ],
+      structuredContent,
       isError: false,
       _meta: {
         viewUUID: randomUUID()
diff --git a/src/utils/mintScopedPreviewToken.ts b/src/utils/mintScopedPreviewToken.ts
index fafeccd..a2cd238 100644
--- a/src/utils/mintScopedPreviewToken.ts
+++ b/src/utils/mintScopedPreviewToken.ts
@@ -14,10 +14,8 @@ import { getUserNameFromToken, mapboxApiEndpoint } from './jwtUtils.js';
  * short-lived **`tk.*`** temporary token — confirmed live against the real
  * API — which is what GL JS and the Styles API's embeddable HTML preview
  * page both accept. Pass `expiresInMs: null` to mint a genuine, non-expiring
- * **`pk.*`** public token instead — required for any consumer that validates
- * the token prefix itself and rejects non-`pk.*` tokens outright (confirmed
- * live: `agent.mapbox.com/tools/style-compare`, which `style_comparison_tool`
- * embeds, does exactly this and 400s on a `tk.*` token). A `pk.*` token
+ * **`pk.*`** public token instead — only for a consumer that validates the
+ * token prefix itself and rejects non-`pk.*` tokens outright. A `pk.*` token
  * minted this way does not self-expire; it persists on the account (scoped
  * narrowly to `scopes`) until manually revoked.
  *
diff --git a/test/resources/ui-apps/StyleComparisonUIResource.test.ts b/test/resources/ui-apps/StyleComparisonUIResource.test.ts
index 14c92ab..b03eb9f 100644
--- a/test/resources/ui-apps/StyleComparisonUIResource.test.ts
+++ b/test/resources/ui-apps/StyleComparisonUIResource.test.ts
@@ -8,28 +8,42 @@ import { resourceTextOf } from '../../utils/resultTestUtils.js';
 
 const uri = new URL('ui://mapbox/style-comparison/index.html');
 
-async function inlineScript(): Promise<string> {
+async function resourceHtml(): Promise<string> {
   const resource = new StyleComparisonUIResource();
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const html = resourceTextOf(await resource.readCallback(uri, {} as any));
-  const match = html.match(/<script>([\s\S]*?)<\/script>/);
+  return resourceTextOf(await resource.readCallback(uri, {} as any));
+}
+
+async function inlineScript(): Promise<string> {
+  const match = (await resourceHtml()).match(/<script>([\s\S]*?)<\/script>/);
   if (!match) throw new Error('Could not find inline <script> block');
   return match[1];
 }
 
-// Runs the inline script without mapboxgl, so a handled tool-result only
-// shows the "Open in browser" button.
-async function runScript() {
+type FakeElement = {
+  style: Record<string, string>;
+  textContent: string;
+  title?: string;
+};
+
+type FakeMap = {
+  options: { container: string; style: string; center: number[]; zoom: number };
+  fire: (event: string, payload?: unknown) => void;
+};
+
+// Runs the inline script against a stub DOM and, unless `withGl` is false, a
+// stub mapboxgl that records the maps and Compare instances it creates.
+async function runScript({ withGl = true } = {}) {
   let listener: ((event: { data: unknown; source: unknown }) => void) | null =
     null;
-  const elements: Record<string, { style: Record<string, string> }> = {};
+  const elements: Record<string, FakeElement> = {};
   const element = (id: string) =>
     (elements[id] ??= {
       style: {},
       textContent: '',
       classList: { add: () => {} },
       addEventListener: () => {}
-    } as { style: Record<string, string> });
+    } as FakeElement);
   const posted: Array<{ id?: number; method?: string }> = [];
   const parentWindow = {
     postMessage: (message: { id?: number; method?: string }) => {
@@ -37,6 +51,30 @@ async function runScript() {
     }
   };
 
+  const maps: FakeMap[] = [];
+  const compares: unknown[][] = [];
+  const mapboxgl = {
+    accessToken: '',
+    Map: function (this: unknown, options: FakeMap['options']) {
+      const handlers: Record<string, Array<(payload?: unknown) => void>> = {};
+      const map = {
+        options,
+        on: (event: string, cb: (payload?: unknown) => void) => {
+          (handlers[event] ??= []).push(cb);
+        },
+        getStyle: () => ({ name: `Name of ${options.container}` }),
+        resize: () => {},
+        fire: (event: string, payload?: unknown) =>
+          (handlers[event] ?? []).forEach((cb) => cb(payload))
+      };
+      maps.push(map);
+      return map;
+    },
+    Compare: function (...args: unknown[]) {
+      compares.push(args);
+    }
+  };
+
   vm.runInContext(
     await inlineScript(),
     vm.createContext({
@@ -47,21 +85,28 @@ async function runScript() {
         parent: parentWindow
       },
       document: { getElementById: element, createElement: () => element('') },
+      ...(withGl ? { mapboxgl } : {}),
       console,
       setTimeout,
-      URL,
       Map
     })
   );
 
-  const sendToolResult = (source: unknown) =>
+  const sendToolResult = (
+    source: unknown,
+    structuredContent: unknown = {
+      before: 'mapbox/streets-v12',
+      after: 'mapbox/outdoors-v12',
+      accessToken: 'tk.test',
+      center: [-122.4, 37.7],
+      zoom: 10
+    }
+  ) =>
     listener?.({
       data: {
         jsonrpc: '2.0',
         method: 'ui/notifications/tool-result',
-        params: {
-          content: [{ type: 'text', text: 'https://attacker.example/' }]
-        }
+        params: { content: [], structuredContent }
       },
       source
     });
@@ -83,21 +128,114 @@ async function runScript() {
     answerInitialize,
     initialized,
     parentWindow,
-    openBtn: element('open-btn')
+    mapboxgl,
+    maps,
+    compares,
+    element
   };
 }
 
-describe('StyleComparisonUIResource message handling', () => {
-  it('handles a tool-result from the host window', async () => {
-    const { sendToolResult, parentWindow, openBtn } = await runScript();
+describe('StyleComparisonUIResource', () => {
+  it('loads only Mapbox-hosted scripts and never frames a hosted comparison page', async () => {
+    const html = await resourceHtml();
+    expect(html).not.toContain('agent.mapbox.com');
+    expect(html).not.toContain('<iframe');
+    for (const [, src] of html.matchAll(/<script src="([^"]+)"/g)) {
+      expect(src).toMatch(/^https:\/\/api\.mapbox\.com\//);
+    }
+  });
+
+  it('builds both maps from the tool result structured content', async () => {
+    const { sendToolResult, parentWindow, mapboxgl, maps, compares, element } =
+      await runScript();
+    sendToolResult(parentWindow);
+
+    expect(mapboxgl.accessToken).toBe('tk.test');
+    expect(maps.map((m) => m.options)).toEqual([
+      {
+        container: 'before',
+        style: 'mapbox://styles/mapbox/streets-v12?fresh=true',
+        center: [-122.4, 37.7],
+        zoom: 10
+      },
+      {
+        container: 'after',
+        style: 'mapbox://styles/mapbox/outdoors-v12?fresh=true',
+        center: [-122.4, 37.7],
+        zoom: 10
+      }
+    ]);
+
+    // The slider is only created once both styles have loaded.
+    maps[0].fire('style.load');
+    expect(compares).toHaveLength(0);
+    maps[1].fire('style.load');
+    expect(compares).toHaveLength(1);
+    expect(compares[0][3]).toEqual({
+      mousemove: false,
+      orientation: 'vertical'
+    });
+
+    expect(element('before-label').textContent).toBe(
+      'Name of before (mapbox/streets-v12)'
+    );
+    expect(element('loading').style.display).toBe('none');
+  });
+
+  it('shows which side failed and why when a style cannot be loaded', async () => {
+    const { sendToolResult, parentWindow, maps, compares, element } =
+      await runScript();
+    sendToolResult(parentWindow);
+
+    maps[0].fire('style.load');
+    maps[1].fire('error', { error: { status: 404 } });
+    maps[1].fire('style.load');
+
+    expect(compares).toHaveLength(0);
+    expect(element('error').style.display).toBe('block');
+    expect(element('error').textContent).toContain(
+      'Failed to load the "after" style (mapbox/outdoors-v12).'
+    );
+    expect(element('error').textContent).toContain('not found');
+  });
+
+  it('ignores errors after a style has loaded, such as a missing tile', async () => {
+    const { sendToolResult, parentWindow, maps, element } = await runScript();
     sendToolResult(parentWindow);
-    expect(openBtn.style.display).toBe('block');
+
+    maps[0].fire('style.load');
+    maps[0].fire('error', { error: { status: 404 } });
+
+    expect(element('error').style.display).toBeUndefined();
+  });
+
+  it('rejects a tool result whose style IDs are not username/styleId', async () => {
+    const { sendToolResult, parentWindow, maps, element } = await runScript();
+    sendToolResult(parentWindow, {
+      before: 'mapbox/streets-v12',
+      after: '../../evil',
+      accessToken: 'tk.test'
+    });
+
+    expect(maps).toHaveLength(0);
+    expect(element('error').textContent).toBe(
+      'No style comparison found in tool result'
+    );
+  });
+
+  it('reports a GL JS load failure instead of hanging on the loading message', async () => {
+    const { sendToolResult, parentWindow, element } = await runScript({
+      withGl: false
+    });
+    sendToolResult(parentWindow);
+
+    expect(element('error').textContent).toBe('Could not load Mapbox GL JS');
   });
 
   it('ignores a tool-result posted by a window other than the host', async () => {
-    const { sendToolResult, openBtn } = await runScript();
+    const { sendToolResult, maps } = await runScript();
     sendToolResult({ postMessage: () => {} });
-    expect(openBtn.style.display).toBeUndefined();
+    expect(maps).toHaveLength(0);
   });
 
   it('ignores a reply to a pending request posted by a window other than the host', async () => {
diff --git a/test/tools/__snapshots__/tool-naming-convention.test.ts.snap b/test/tools/__snapshots__/tool-naming-convention.test.ts.snap
index fe074f7..4c99fbd 100644
--- a/test/tools/__snapshots__/tool-naming-convention.test.ts.snap
+++ b/test/tools/__snapshots__/tool-naming-convention.test.ts.snap
@@ -74,7 +74,7 @@ exports[`Tool Naming Convention > should maintain consistent tool list (snapshot
   },
   {
     "className": "PreviewStyleTool",
-    "description": "Generate a live preview of a Mapbox style. By default, auto-generates a short-lived preview token so you can view it right away — no existing token needed. Pass \`share: true\` with an existing public \`accessToken\` instead to generate a durable, shareable preview link.",
+    "description": "Generate a live preview of a Mapbox style. By default, auto-generates a short-lived preview token so you can view it right away — no existing token needed. Pass an existing public \`accessToken\` instead to get a preview link that keeps working after the hour.",
     "toolName": "preview_style_tool",
   },
   {
@@ -149,7 +149,7 @@ If a layer type is not recognized, the tool will provide helpful suggestions sho
   },
   {
     "className": "StyleComparisonTool",
-    "description": "Generate a live side-by-side comparison of two Mapbox styles. By default, auto-generates a scoped preview token so you can compare them right away — no existing token needed. Pass \`share: true\` with an existing public \`accessToken\` instead to generate a comparison link using a token you manage yourself.",
+    "description": "Show a live side-by-side comparison of two Mapbox styles with a draggable slider, rendered inline in clients that support MCP Apps. By default, auto-generates a short-lived scoped preview token so you can compare them right away — no existing token needed. Also returns a Styles API preview link for each style, to open or share on its own. Pass an existing public \`accessToken\` to use a token you manage yourself, so those links keep working after the hour.",
     "toolName": "style_comparison_tool",
   },
   {
diff --git a/test/tools/preview-style-tool/PreviewStyleTool.test.ts b/test/tools/preview-style-tool/PreviewStyleTool.test.ts
index 5bd2568..ff37a78 100644
--- a/test/tools/preview-style-tool/PreviewStyleTool.test.ts
+++ b/test/tools/preview-style-tool/PreviewStyleTool.test.ts
@@ -204,7 +204,7 @@ describe('PreviewStyleTool', () => {
     });
   });
 
-  describe('auto-minted inline preview (no accessToken, no share)', () => {
+  describe('auto-minted inline preview (no accessToken)', () => {
     function stubMintingFetch() {
       return vi.fn(
         async (_input: string | URL | Request, _init?: RequestInit) =>
@@ -240,28 +240,18 @@ describe('PreviewStyleTool', () => {
       });
     });
 
-    it('errors clearly when share is true but accessToken is missing', async () => {
-      const httpRequest = stubMintingFetch();
-      const result = await new PreviewStyleTool({ httpRequest }).run({
-        styleId: 'cmojrmkc9002t01ry96yi6h48',
-        share: true,
-        title: false,
-        zoomwheel: false
-      });
-
-      expect(result.isError).toBe(true);
-      expect(httpRequest).not.toHaveBeenCalled();
-      expect(result.content[0]).toMatchObject({
-        type: 'text',
-        text: expect.stringContaining('share: true` requires')
-      });
+    it('no longer accepts a share option', () => {
+      expect(
+        Object.keys(
+          new PreviewStyleTool({ httpRequest: vi.fn() }).inputSchema.shape
+        )
+      ).not.toContain('share');
     });
 
-    it('an explicit accessToken is honored even when share is true', async () => {
+    it('uses an explicit accessToken without minting', async () => {
       const httpRequest = stubMintingFetch();
       const result = await new PreviewStyleTool({ httpRequest }).run({
         styleId: 'cmojrmkc9002t01ry96yi6h48',
-        share: true,
         accessToken: TEST_ACCESS_TOKEN,
         title: false,
         zoomwheel: false
diff --git a/test/tools/style-comparison-tool/StyleComparisonTool.test.ts b/test/tools/style-comparison-tool/StyleComparisonTool.test.ts
index 6bd01a8..83b51b2 100644
--- a/test/tools/style-comparison-tool/StyleComparisonTool.test.ts
+++ b/test/tools/style-comparison-tool/StyleComparisonTool.test.ts
@@ -4,6 +4,11 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { StyleComparisonTool } from '../../../src/tools/style-comparison-tool/StyleComparisonTool.js';
 import * as jwtUtils from '../../../src/utils/jwtUtils.js';
+import type { StyleComparisonOutput } from '../../../src/tools/style-comparison-tool/StyleComparisonTool.output.schema.js';
+
+function payloadOf(result: { structuredContent?: unknown }) {
+  return result.structuredContent as StyleComparisonOutput;
+}
 
 describe('StyleComparisonTool', () => {
   let tool: StyleComparisonTool;
@@ -20,7 +25,7 @@ describe('StyleComparisonTool', () => {
   });
 
   describe('run', () => {
-    it('should generate comparison URL and MCP-UI resource with provided access token (default)', async () => {
+    it('returns the resolved styles and token as structured content for the comparison view', async () => {
       const input = {
         before: 'mapbox/streets-v12',
         after: 'mapbox/outdoors-v12',
@@ -30,43 +35,53 @@ describe('StyleComparisonTool', () => {
       const result = await tool.run(input);
 
       expect(result.isError).toBe(false);
-      expect(result.content).toHaveLength(2);
-      expect(result.content[0].type).toBe('text');
-      const url = (result.content[0] as { type: 'text'; text: string }).text;
-      expect(url).toContain('https://agent.mapbox.com/tools/style-compare');
-      expect(url).toContain('access_token=pk.test.token');
-      expect(url).toContain('before=mapbox%2Fstreets-v12');
-      expect(url).toContain('after=mapbox%2Foutdoors-v12');
-
-      // Verify MCP-UI resource is included by default
-      expect(result.content[1]).toMatchObject({
-        type: 'resource',
-        resource: {
-          uri: expect.stringMatching(
-            /^ui:\/\/mapbox\/style-comparison\/mapbox\/streets-v12\/mapbox\/outdoors-v12$/
-          ),
-          mimeType: 'text/html;profile=mcp-app',
-          text: expect.stringContaining(
-            'https://agent.mapbox.com/tools/style-compare'
-          )
-        }
+      expect(payloadOf(result)).toEqual({
+        before: 'mapbox/streets-v12',
+        after: 'mapbox/outdoors-v12',
+        accessToken: 'pk.test.token',
+        beforePreviewUrl:
+          'https://api.mapbox.com/styles/v1/mapbox/streets-v12.html?access_token=pk.test.token&fresh=true',
+        afterPreviewUrl:
+          'https://api.mapbox.com/styles/v1/mapbox/outdoors-v12.html?access_token=pk.test.token&fresh=true'
+      });
+      expect(result.content).toHaveLength(1);
+      expect(result.content[0]).toEqual({
+        type: 'text',
+        text:
+          'Comparing mapbox/streets-v12 (before, left) with mapbox/outdoors-v12 (after, right).\n\n' +
+          'Preview links to open or share each style on its own. They use the access token you supplied.\n' +
+          '- Before: https://api.mapbox.com/styles/v1/mapbox/streets-v12.html?access_token=pk.test.token&fresh=true\n' +
+          '- After: https://api.mapbox.com/styles/v1/mapbox/outdoors-v12.html?access_token=pk.test.token&fresh=true'
       });
     });
 
-    it('requires an access token when share is true', async () => {
-      const input = {
+    it('uses the resolved username in the preview URL for a bare style ID', async () => {
+      vi.spyOn(jwtUtils, 'getUserNameFromToken').mockReturnValue('testuser');
+
+      const result = await tool.run({
+        before: 'style-id-1',
+        after: 'mapbox/outdoors-v12',
+        accessToken: 'pk.test.token'
+      });
+
+      expect(payloadOf(result).beforePreviewUrl).toContain(
+        '/styles/v1/testuser/style-id-1.html?'
+      );
+    });
+
+    it('does not link to or embed a hosted comparison page', async () => {
+      const result = await tool.run({
         before: 'mapbox/streets-v12',
-        after: 'mapbox/satellite-v9',
-        share: true
-        // Missing accessToken
-      };
+        after: 'mapbox/outdoors-v12',
+        accessToken: 'pk.test.token'
+      });
 
-      const result = await tool.run(input);
+      expect(JSON.stringify(result)).not.toContain('agent.mapbox.com');
+      expect(result.content.some((c) => c.type === 'resource')).toBe(false);
+    });
 
-      expect(result.isError).toBe(true);
-      expect(
-        (result.content[0] as { type: 'text'; text: string }).text
-      ).toContain('share: true` requires');
+    it('no longer accepts a share option', () => {
+      expect(Object.keys(tool.inputSchema.shape)).not.toContain('share');
     });
 
     it('should handle full style URLs', async () => {
@@ -79,9 +94,8 @@ describe('StyleComparisonTool', () => {
       const result = await tool.run(input);
 
       expect(result.isError).toBe(false);
-      const url = (result.content[0] as { type: 'text'; text: string }).text;
-      expect(url).toContain('before=mapbox%2Fstreets-v12');
-      expect(url).toContain('after=mapbox%2Foutdoors-v12');
+      expect(payloadOf(result).before).toBe('mapbox/streets-v12');
+      expect(payloadOf(result).after).toBe('mapbox/outdoors-v12');
     });
 
     it('should handle just style IDs with valid public token', async () => {
@@ -96,9 +110,8 @@ describe('StyleComparisonTool', () => {
       const result = await tool.run(input);
 
       expect(result.isError).toBe(false);
-      const url = (result.content[0] as { type: 'text'; text: string }).text;
-      expect(url).toContain('before=testuser%2Fstyle-id-1');
-      expect(url).toContain('after=testuser%2Fstyle-id-2');
+      expect(payloadOf(result).before).toBe('testuser/style-id-1');
+      expect(payloadOf(result).after).toBe('testuser/style-id-2');
     });
 
     it('should reject secret tokens', async () => {
@@ -186,23 +199,7 @@ describe('StyleComparisonTool', () => {
       ).toContain('Could not determine username for style ID');
     });
 
-    it('should properly encode URL parameters', async () => {
-      const input = {
-        before: 'user-name/style-id-1',
-        after: 'user-name/style-id-2',
-        accessToken: 'pk.test.token'
-      };
-
-      const result = await tool.run(input);
-
-      expect(result.isError).toBe(false);
-      const url = (result.content[0] as { type: 'text'; text: string }).text;
-      // Check that forward slashes are URL encoded
-      expect(url).toContain('before=user-name%2Fstyle-id-1');
-      expect(url).toContain('after=user-name%2Fstyle-id-2');
-    });
-
-    it('should include hash fragment with map position when coordinates are provided', async () => {
+    it('includes the initial map position when coordinates are provided', async () => {
       const input = {
         before: 'mapbox/streets-v12',
         after: 'mapbox/outdoors-v12',
@@ -215,11 +212,20 @@ describe('StyleComparisonTool', () => {
       const result = await tool.run(input);
 
       expect(result.isError).toBe(false);
-      const url = (result.content[0] as { type: 'text'; text: string }).text;
-      expect(url).toContain('#5.72/9.503/-67.473');
+      expect(payloadOf(result).center).toEqual([-67.473, 9.503]);
+      expect(payloadOf(result).zoom).toBe(5.72);
+      expect(
+        (result.content[0] as { type: 'text'; text: string }).text
+      ).toContain('at zoom 5.72, 9.503, -67.473');
+      expect(payloadOf(result).beforePreviewUrl).toMatch(
+        /\.html\?access_token=pk\.test\.token&fresh=true#5\.72\/9\.503\/-67\.473$/
+      );
+      expect(payloadOf(result).afterPreviewUrl).toMatch(
+        /#5\.72\/9\.503\/-67\.473$/
+      );
     });
 
-    it('should not include hash fragment when coordinates are incomplete', async () => {
+    it('omits the initial map position when coordinates are incomplete', async () => {
       // Only zoom provided
       const input1 = {
         before: 'mapbox/streets-v12',
@@ -230,8 +236,8 @@ describe('StyleComparisonTool', () => {
 
       const result1 = await tool.run(input1);
       expect(result1.isError).toBe(false);
-      const url1 = (result1.content[0] as { type: 'text'; text: string }).text;
-      expect(url1).not.toContain('#');
+      expect(payloadOf(result1).center).toBeUndefined();
+      expect(payloadOf(result1).zoom).toBeUndefined();
 
       // Only latitude and longitude, no zoom
       const input2 = {
@@ -244,36 +250,19 @@ describe('StyleComparisonTool', () => {
 
       const result2 = await tool.run(input2);
       expect(result2.isError).toBe(false);
-      const url2 = (result2.content[0] as { type: 'text'; text: string }).text;
-      expect(url2).not.toContain('#');
-    });
-
-    it('should return URL and MCP-UI resource for backward compatibility', async () => {
-      const input = {
-        before: 'mapbox/streets-v12',
-        after: 'mapbox/outdoors-v12',
-        accessToken: 'pk.test.token'
-      };
-
-      const result = await tool.run(input);
-
-      expect(result.isError).toBe(false);
-      // Now returns both URL (for text) and MCP-UI resource (for backward compat)
-      expect(result.content).toHaveLength(2);
-      expect(result.content[0].type).toBe('text');
-      // Second item is MCP-UI resource
-      expect(result.content[1].type).toBe('resource');
+      expect(payloadOf(result2).center).toBeUndefined();
+      expect(payloadOf(result2).zoom).toBeUndefined();
     });
   });
 
-  describe('auto-minted inline comparison (no accessToken, no share)', () => {
+  describe('auto-minted inline comparison (no accessToken)', () => {
     const SERVER_TOKEN = 'sk.eyJ1IjoidGVzdC11c2VyIn0.signature';
 
     function stubMintingFetch() {
       return vi.fn(
         async (_input: string | URL | Request, _init?: RequestInit) =>
           new Response(
-            JSON.stringify({ token: 'pk.eyJ1IjoidGVzdC11c2VyIn0.minted' }),
+            JSON.stringify({ token: 'tk.eyJ1IjoidGVzdC11c2VyIn0.minted' }),
             { status: 200 }
           )
       );
@@ -293,18 +282,23 @@ describe('StyleComparisonTool', () => {
         expect(httpRequest).toHaveBeenCalledTimes(1);
         const [url] = httpRequest.mock.calls[0];
         expect(String(url)).toContain('tokens/v2/test-user');
-        const resultUrl = (result.content[0] as { type: 'text'; text: string })
-          .text;
-        expect(resultUrl).toContain(
-          'access_token=pk.eyJ1IjoidGVzdC11c2VyIn0.minted'
+        expect(payloadOf(result).accessToken).toBe(
+          'tk.eyJ1IjoidGVzdC11c2VyIn0.minted'
+        );
+        expect(payloadOf(result).beforePreviewUrl).toContain(
+          'access_token=tk.eyJ1IjoidGVzdC11c2VyIn0.minted'
         );
+        // The links carry a 1-hour token, so the text warns they expire.
+        expect(
+          (result.content[0] as { type: 'text'; text: string }).text
+        ).toContain('stop working in about an hour');
       } finally {
         if (saved !== undefined) process.env.MAPBOX_ACCESS_TOKEN = saved;
         else delete process.env.MAPBOX_ACCESS_TOKEN;
       }
     });
 
-    it('mints a non-expiring token, not the short-lived tk.* the other preview tools use — agent.mapbox.com/tools/style-compare rejects tk.* outright (confirmed live)', async () => {
+    it('mints a short-lived token that expires in about an hour, so nothing persists on the account', async () => {
       const saved = process.env.MAPBOX_ACCESS_TOKEN;
       process.env.MAPBOX_ACCESS_TOKEN = SERVER_TOKEN;
       try {
@@ -316,27 +310,31 @@ describe('StyleComparisonTool', () => {
 
         const [, init] = httpRequest.mock.calls[0];
         const body = JSON.parse((init as RequestInit).body as string);
-        expect(body).not.toHaveProperty('expires');
+        const expiresInMs = Date.parse(body.expires) - Date.now();
+        expect(expiresInMs).toBeGreaterThan(55 * 60 * 1000);
+        expect(expiresInMs).toBeLessThanOrEqual(60 * 60 * 1000);
+        expect(body.scopes).toEqual([
+          'styles:tiles',
+          'styles:read',
+          'fonts:read'
+        ]);
       } finally {
         if (saved !== undefined) process.env.MAPBOX_ACCESS_TOKEN = saved;
         else delete process.env.MAPBOX_ACCESS_TOKEN;
       }
     });
 
-    it('an explicit accessToken is honored even when share is true', async () => {
+    it('uses an explicit accessToken without minting', async () => {
       const httpRequest = stubMintingFetch();
       const result = await new StyleComparisonTool({ httpRequest }).run({
         before: 'mapbox/streets-v12',
         after: 'mapbox/outdoors-v12',
-        share: true,
         accessToken: 'pk.test.token'
       });
 
       expect(result.isError).toBe(false);
       expect(httpRequest).not.toHaveBeenCalled();
-      const resultUrl = (result.content[0] as { type: 'text'; text: string })
-        .text;
-      expect(resultUrl).toContain('access_token=pk.test.token');
+      expect(payloadOf(result).accessToken).toBe('pk.test.token');
     });
 
     it('errors when no server access token is available to mint from', async () => {
@@ -404,8 +402,9 @@ describe('StyleComparisonTool', () => {
     it('should have correct name and description', () => {
       expect(tool.name).toBe('style_comparison_tool');
       expect(tool.description).toContain(
-        'auto-generates a scoped preview token'
+        'auto-generates a short-lived scoped preview token'
       );
+      expect(tool.description).not.toContain('`share`');
     });
   });
 });