Infographic AI-Native Search

The Agent-Centric Web: An Interactive Report on AI-Native Search

Goal: Compare -> Viz/Presentation: HTML/Tailwind "Then vs. Now" Table -> Interaction: None (Static) -> Justification: Clear, direct comparison of old vs. new paradigms. -> Library/Method: HTML/Tailwind --> Goal: Organize/Explain -> Viz/Presentation: HTML/Tailwind Flowchart Diagram -> Interaction: None (Static) -> Justification: Visually maps the complex pipeline (Crawl -> Embed -> Index -> Query) without SVG. -> Library/Method: HTML/Tailwind (flex, border) --> Goal: Compare/Inform -> Viz/Presentation: Interactive Clickable Cards (Manager, Parallel) -> Interaction: Click-to-reveal details -> Justification: Breaks down complex patterns into digestible, user-initiated chunks. -> Library/Method: Vanilla JS (toggle visibility) --> Goal: Compare/Organize -> Viz/Presentation: Bubble Chart -> Interaction: Hover tooltips -> Justification: Plots multiple vendors (Exa, Tavily) across two key axes (Reasoning, Freshness) as requested by trade-off map. -> Library/Method: Chart.js --> Goal: Inform/Change -> Viz/Presentation: Line Chart (GPU Burn Rate) & Doughnut Chart (Cost Breakdown) -> Interaction: Hover tooltips -> Justification: Visualizes cost trends and component costs mentioned in prompt. -> Library/Method: Chart.js --> Goal: Organize/Inform -> Viz/Presentation: Clickable HTML/Tailwind Diagram -> Interaction: Click-to-reveal attack details -> Justification: Maps abstract threats (Index Poisoning, Prompt Injection) to pipeline stages interactively. -> Library/Method: Vanilla JS (toggle visibility) --> Goal: Organize -> Viz/Presentation: Tabbed Content Blocks -> Interaction: Click-to-switch content -> Justification: Segments dense text (AI Act/GDPR, Builder/Regulator) into focused views. -> Library/Method: Vanilla JS (toggle active tabs/content) --> Goal: Inform -> Viz/Presentation: Accordion/Toggle List -> Interaction: Click-to-expand details -> Justification: Manages long list of scenarios (Recursive Inflation) without overwhelming the user. -> Library/Method: Vanilla JS (toggle visibility) -->

tailwind.config = { theme: { extend: { fontFamily: { sans: ['Inter', 'sans-serif'], }, colors: { stone: { 50: '#fafaf9', 100: '#f5f5f4', 200: '#e7e5e4', 300: '#d6d3d1', 400: '#a8a29e', 500: '#78716c', 600: '#57534e', 700: '#44403c', 800: '#292524', 900: '#1c1917', }, blue: { 100: '#dbeafe', 600: '#2563eb', 700: '#1d4ed8', } } } } }

.chart-container { position: relative; width: 100%; max-width: 600px; margin-left: auto; margin-right: auto; height: 350px; max-height: 400px; } @media (max-width: 640px) { .chart-container { height: 300px; max-height: 350px; } } .nav-link { @apply px-3 py-2 rounded-md text-sm font-medium text-stone-600 hover:bg-stone-100 hover:text-stone-900 transition-colors; } .nav-link.active { @apply bg-blue-100 text-blue-700; } .tab-btn { @apply px-4 py-2 text-sm font-medium text-stone-600 bg-white rounded-lg shadow-sm hover:bg-stone-50 disabled:opacity-50; } .tab-btn.active { @apply bg-blue-700 text-white hover:bg-blue-600; } .tab-content { @apply hidden p-4 bg-white rounded-lg shadow; } .tab-content.active { @apply block; } .flow-box { @apply bg-white p-4 rounded-lg shadow-md border border-stone-200 text-center; } .flow-arrow { @apply text-stone-400 text-2xl font-bold; }

AI-Native Search

Summary History Architecture Index Agents Vendor Economic Security Governance Evaluation Failure Foresight Strategy

Open main menu ☰

Summary History Architecture Index Agents Vendor Economic Security Governance Evaluation Failure Foresight Strategy

Executive Summary

The web is undergoing a foundational shift, moving from a human-centric information repository to an agent-centric, API-driven fabric. This report analyzes the transformation from classical, SEO-driven search to AI-native search, detailing the new architectures, economic models, security risks, and strategic imperatives for builders, enterprises, and regulators.

User Shift: Primary search user is shifting from human to autonomous AI agent.
API-First: Search is becoming an API-first utility, consumed by agent workflows (RAG, TTC).
New Guard: Specialized AI search vendors (Exa, Tavily, Parallel) are emerging, optimized for agentic reasoning.
Hybrid Index: Classical IR (BM25) is fusing with dense vector embeddings (HNSW, IVF) for retrieval.
Economic Upheaval: GPU burn-rate and index maintenance costs are displacing ad-based models.
New Attack Surface: Risks now include index/embedding poisoning and prompt injection via malicious web content.
Governance Gap: AI Act, GDPR, and NIS2 are misaligned with agent-driven profiling and data provenance.
Agent Orchestration: Parallelized, multi-hop query planning by agents is replacing the 10-blue-links SERP.
Incumbent Pivot: Microsoft’s Bing Search API deprecation signals the move away from classical IR APIs.
Outsourcing: High cost and complexity incentivize LLM labs to outsource search to specialized API providers.
Recrawl Strategy: Crawling is shifting from dense pipelines to RL-based sparse recrawls for freshness and novelty.
Zero Trust Search: Data lineage, provenance, and authority scoring are critical to mitigate hallucination propagation.
Recursive Web: Foresight scenarios include recursive web inflation, where AI agents generate content for other AI agents.
New Benchmarks: Metrics are evolving from simple recall (IR) to hybrid reasoning/retrieval (BrowseComp).
Vendor Lock-in: Reliance on specialized search APIs creates new economic and architectural lock-in risks.

Historical Context: 1996 – 2025

The evolution of search reflects the evolution of the web’s primary user. Initially, human-curated directories (Yahoo) gave way to crawler-based engines (Inktomi, Excite). The PageRank revolution prioritized authority for human users. Today, the rise of AI agents as the primary consumer of web data necessitates a new architecture optimized for machine reasoning.

Phase 1: Classical Search (1996-2023)

“The Human-Centric Web”

Primary User: Human
Interface: Search Engine Results Page (SERP)
Core Tech: PageRank, BM25, TF-IDF (Sparse Retrieval)
Economic Model: Advertising (Cost-Per-Click)
Key Goal: Deliver 10 blue links (authority + relevance)
Dominant Actors: Google, Bing (Inktomi, Excite)
Primary Risk: SEO Spam, Misinformation

Phase 2: AI-Native Search (2024+)

“The Agent-Centric Fabric”

Primary User: AI Agent (via API)
Interface: JSON API Response (Token-efficient spans)
Core Tech: Hybrid Retrieval (Dense + Sparse), RAG, TTC
Economic Model: API Calls, GPU Burn Rate (Cost-Per-Inference)
Key Goal: Provide grounded data for multi-hop reasoning
Dominant Actors: Exa, Tavily, Parallel, Seda, Deep Research
Primary Risk: Index Poisoning, Agent Misuse, Hallucination

Technical Decomposition: AI-Native Search

The AI-native architecture is not a monolithic index but a dynamic pipeline. It is designed to service multi-step reasoning from autonomous agents, balancing freshness, cost, and reasoning depth. This involves fusing classical sparse retrieval with modern dense vector search and sophisticated query planning.

AI-Native Retrieval & Reasoning Pipeline

1. Agent Task & Query Planning

AI Agent decomposes task (e.g., “Summarize GOOG Q3 earnings”) into a multi-hop reasoning tree. A query planner generates initial search queries.

↓

2. Hybrid Retrieval (Search API Call)

Query hits a specialized API (e.g., Exa, Tavily). The API fuses two retrieval methods:

Sparse (BM25): Fast, keyword-based. Good for specific terms. Dense (Vector): Semantic, meaning-based. Good for concepts.

↓

3. Reranking & Snippet Generation

A reranker model scores the fused results. Token-efficient, context-rich spans (not full pages) are generated.

↓

4. Grounding & Synthesis (RAG + TTC)

The agent receives the data. Retrieval-Augmented Generation (RAG) grounds the LLM. Tools-Time-Context (TTC) allows the agent to reformulate queries and loop.

↕

5. Semantic Reformulation Loop

Agent self-corrects, generates new queries, and calls the search API again to build a comprehensive answer. (e.g., “Find analyst commentary on GOOG Q3”).

Index Engineering & Recrawl Policy

The “index” is no longer a static snapshot. It’s a living system of embeddings, classical indexes, and authority scores, all under constant threat of poisoning and drift. Recrawl strategies must now be anti-adversarial, prioritizing novelty and authority over simple breadth.

Embedding Pipeline Architecture

Vectorization: Billions of web content chunks are passed through embedding models (e.ACTION: “e.g., text-embedding-ada-002” or similar) and converted into vectors.
Approximate Nearest Neighbor (ANN): Stored in high-speed indexes like HNSW (Hierarchical Navigable Small Worlds) or IVF (Inverted File) for fast semantic search.
Compression: Techniques like Product Quantization (PQ) reduce the memory footprint (GPU VRAM) of these massive vector stores.
Drift Management: Models are retrained, but embeddings must be refreshed. Handling quality drift vs. index freshness is a core challenge.

Anti-Adversarial Recrawl Strategy

RL Sparse Recrawl: Instead of dense GPU pipelines crawling everything, Reinforcement Learning (RL) models prioritize the URL frontier.
Novelty & Authority: The RL agent is rewarded for finding novel, high-authority content, disincentivizing visits to known spam or AI-generated content farms.
Poisoning Defense: Curation is security-hardened. New domains are sandboxed; known high-authority domains (e.g., academic, government, top-tier journalism) are prioritized.
Authority Scoring: A PageRank-like score is vital to mitigate propagation of hallucinations (AI content citing other AI content).

Agent-Centric Search Pipelines

Autonomous agents require new orchestration patterns to conduct deep research. These patterns manage parallel search, shared memory, and tool-use safety, fundamentally changing the nature of a “search query” from a single shot to a complex, multi-agent workflow. Click a pattern to learn more.

1. Manager-Worker Pattern

A “Manager” agent decomposes the main task and dispatches sub-queries to specialized “Worker” agents (e.g., “Finance-Searcher”, “News-Searcher”).

Pros: Centralized control, easy to debug, good for defined tasks.Cons: Can be a bottleneck, less resilient.Use Case: Generating a financial report by dispatching workers to pull stock data, news, and SEC filings.

2. Parallelized Strategy

Multiple agents search different facets of a query simultaneously, then synthesize their findings. This mimics a “research team” approach.

Pros: Extremely fast, diverse results, resilient to single-point failure.Cons: High API cost, results can be contradictory.Use Case: “What is the consensus on [new topic]?” Agents A, B, and C search for pro, con, and neutral viewpoints.

3. Safe Failover & Caching

Agents use shared memory/cache pipelines to avoid redundant API calls. Tool-misuse detection rolls back failed or unsafe search paths.

Pros: Cost-efficient, secure, prevents recursive loops.Cons: Complex to implement, cache can become stale.Use Case: A long-running research agent caches intermediate reasoning artifacts and search results, with failovers if a search API call is poisoned or fails.

Vendor Landscape & Trade-Offs

A new ecosystem of AI-native search vendors is emerging, each making different architectural trade-offs. Incumbents offer massive scale but are not optimized for agentic reasoning. Startups are API-first but have varying index freshness and depth. This chart plots vendors on hypothetical axes of Reasoning Depth vs. Index Freshness.

Vendor Trade-Off Map

Data is illustrative, based on public positioning. Size of bubble represents hypothetical market adoption or index size.

Economic Models & Sustainability

The shift from ad-based economics to inference-based economics is profound. Sustainability depends on managing the GPU burn-rate, the cost of index maintenance (crawl + embedding refresh), and mitigating vendor lock-in. Vertical integration (owning the full stack from crawl to LLM) is costly, creating a market for specialized search vendors.

Projected AI Search Cost Curve

This illustrates the high, non-linear cost of GPU inference and embedding refresh, which must be balanced against API revenue. Vendor collapse is a real risk if this balance fails.

Vendor Cost Structure Breakdown

Maintaining a fresh, deep, and secure index (crawl + embed) is a massive, fixed cost, while inference costs scale with agent usage. This dynamic drives vendor lock-in strategies.

Security, Provenance & Zero Trust

The attack surface for AI-native search is dramatically larger than for classical search. A Zero Trust architecture is required, assuming no retrieved content is safe. This demands robust data lineage, provenance tracking, and defense against attacks targeting the embedding pipeline itself. Click on a stage to see its unique risks.

Attack Surface Map

Crawl & Frontier

→ ↓

Index & Embedding

→ ↓

API & Retrieval

→ ↓

Agent & Reasoning

Stage 1: Crawl & Frontier

Risks: Recrawl Hijacking, URL Frontier Manipulation, Adversarial Saturation (generating millions of fake pages), and resource exhaustion attacks on the crawler.

Stage 2: Index & Embedding

Risks: Index Poisoning (injecting false data), Embedding Poisoning (manipulating vectors to create false semantic links), and poisoning authority scores to promote malicious content.

Stage 3: API & Retrieval

Risks: Denial of Service (DoS) on the API, data exfiltration, and attacks that exploit compression or quantization to return garbage data.

Stage 4: Agent & Reasoning

Risks: Prompt Injection via malicious web content (content is designed to be read by an agent, not a human, and contains hidden instructions), tool-misuse, and recursive loops.

Governance & Compliance

Existing regulations were not designed for agent-centric search. An agent performing deep research on a topic may constitute automated profiling under GDPR, and the “black box” nature of retrieval models conflicts with the EU AI Act’s transparency requirements. NIS2 also applies as search APIs become critical infrastructure.

EU AI Act GDPR NIS2 Directive

EU AI Act Mapping

Risk Layer: AI-native search could be classified as “high-risk” if used in critical applications (e.g., law, finance), requiring strict transparency and logging.
Transparency: Opaque retrieval models (dense embeddings) make explaining why a piece of information was surfaced difficult, challenging explainability rules.
Data Provenance: Tracing the lineage of a synthesized answer back to its source indexes is a mandatory but technically complex requirement.

GDPR Mapping

Automated Profiling: An agent conducting research (e.g., “Find all information on John Doe”) may constitute automated decision-making or profiling, triggering Article 22.
Right to be Forgotten: How is a “right to erasure” request processed when data is embedded in vectors and part of a model’s “knowledge”?
Data Minimization: RAG pipelines that pull and process large swaths of web data may conflict with data minimization principles.

NIS2 Directive Mapping

Critical Infrastructure: As enterprises build agentic workflows on search APIs, these APIs become “essential entities” under NIS2.
Security Obligations: This mandates robust security measures, incident reporting, and supply chain (vendor) risk management.
Systemic Risk: A poisoning attack on a major search vendor could have cascading systemic effects, a key concern of NIS2.

Evaluation Frameworks & Benchmarks

Classical IR metrics (like nDCG, MRR) are insufficient. New benchmarks must evaluate the entire retrieval and reasoning pipeline, measuring the utility of search results for a downstream agent task, not just for human eyeballs. This includes long-horizon correctness and uncertainty awareness.

Evolving Metrics

Metric Type Description Example V

Classical IR Measures relevance and ranking of static links. nDCG, Mean Reciprocal Rank (MRR)

Hybrid Retrieval Measures the quality of data for RAG. How useful is the content for grounding an LLM? RAG-precision, Context Relevance

Agentic / Task-Based Measures end-to-end task success. Did the agent achieve its goal using the search API? BrowseComp, Long-horizon Correctness

Safety & Consistency Measures robustness to adversarial content and consistency of answers. Multi-agent Self-Consistency, Uncertainty Scoring

Failure Modes & Adversarial Scenarios

The high-stakes, high-complexity nature of this new ecosystem creates novel failure modes, from economic collapse to systemic reality decay. Understanding these risks is the first step to mitigating them.

Recursive Web Inflation (“Hallucination Collapse”) +

AI agents generate content based on AI-native search results. Other AI agents then crawl this new content, index it, and treat it as a primary source. This feedback loop progressively pollutes the index with LLM-generated artifacts, leading to a collapse in factual authority and a web optimized for machines, not truth.

Large-Scale Adversarial Saturation An attacker generates billions of low-cost, AI-generated pages with subtle poisoning (e.g., “Stock X is a ‘buy'” or “Candidate Y has ‘strong support'”). This mass of content is designed to skew embedding models and overwhelm authority scores, manipulating agentic consensus on a global scale.

Economic Collapse & Index Fragmentation +

The GPU burn-rate and index maintenance costs prove unsustainable. Major vendors collapse or consolidate, creating a monopoly. In response, fragmented, specialized indexes emerge (e.g., “Sovereign” indexes for nations, “Enterprise” indexes for internal data, “Domain” indexes for science), ending the dream of a unified global information fabric.

Foresight 2030: Scenarios & Trajectories

Looking ahead, the web of 2030 will be shaped by how we resolve the tensions between centralization, cost, and trust. The primary “user” will be an agent, and the web’s content will reflect this, forcing new markets and new regulatory interventions.

Scenario A: The “Utility” Web

Consolidation occurs. One or two massive, vertically-integrated vendors (like today’s cloud providers) control the entire stack from crawl to agent. Search is a high-cost, reliable utility. Lock-in is extreme, and regulatory intervention is heavy.

Scenario B: The “Fragmented” Web

Economic pressures and trust deficits (due to poisoning) lead to fragmentation. Nations build “sovereign” indexes, corporations build “enterprise” indexes, and open-source communities build “domain” indexes. Agents must negotiate across dozens of fragmented, incompatible search APIs.

Scenario C: The “Agent-to-Agent” Web

A new protocol layer emerges where agents negotiate for information directly, bypassing static indexes. Search becomes a real-time, agent-to-agent negotiation, with agents bartering data based on trust, cost, and provenance. The web becomes a live, conversational fabric.

Strategic Recommendations

This paradigm shift demands immediate, tailored strategies for all participants in the ecosystem. Builders face new architectural choices, enterprises face new vendor risks, and regulators face a governance gap. Find your role below for actionable insights.

For Builders & Developers For Enterprises & C-Suite For Regulators & Policymakers

Strategy for Builders (Developers, Architects)

Adopt a Zero Trust Mentality: Treat all search API results as untrusted. Implement your own layer of validation, self-consistency checks, and authority scoring.
Mitigate Lock-In: Architect your agentic systems with an abstraction layer for search. This allows you to swap vendors (e.g., from Exa to Tavily) without a full rewrite.
Implement Safe Orchestration: Build robust tool-misuse detection, resource limiting (to cap API costs), and caching for intermediate reasoning steps.
Prioritize Provenance: Log the source of all retrieved data to enable downstream auditing and compliance, even if the vendor provides it.

Strategy for Enterprises (C-Suite, SOC/NOC)

Model Vendor Risk: The AI search vendor is now part of your critical supply chain. Model the risk of vendor collapse, poisoning, or-driven, and plan for redundancy.
Update Your Threat Model: Your SOC/NOC must now monitor for prompt injection via web content and data poisoning. Classical IR security models are obsolete.
Differentiate Internal vs. External Search: Use specialized enterprise search vendors for internal RAG. Use external AI-native APIs for web research, but ensure the two are isolated to prevent internal data leakage.
Quantify ROI vs. Burn Rate: Agentic workflows are expensive. Track the GPU/API cost per task and measure it against business value to prevent runaway “research” costs.

Strategy for Regulators (Policymakers)

Update Definitions: Re-evaluate “profiling” (GDPR) and “critical infrastructure” (NIS2) in the context of autonomous agents conducting research on a massive scale.
Mandate Provenance Standards: Focus on enforcing data lineage and provenance. Mandate that search APIs provide traceable, verifiable sources for all retrieved information.
Fund Anti-Poisoning Research: Prioritize funding for “index poisoning” and “adversarial saturation” defense. This is a matter of national information security.
Prepare for Fragmentation: Develop policies for a world of fragmented “sovereign indexes” to ensure interoperability and prevent information silos.

An interactive report on the transformation of web search. This application is a synthesis of the provided research prompt, designed for analysis and exploration. All diagrams and charts are generated via HTML/CSS/Canvas (Chart.js).

document.addEventListener('DOMContentLoaded', () => {

const setupNavigation = () => { const mobileMenuBtn = document.getElementById('mobile-menu-btn'); const mobileMenu = document.getElementById('mobile-menu'); mobileMenuBtn.addEventListener('click', () => { mobileMenu.classList.toggle('hidden'); });

document.querySelectorAll('.nav-link').forEach(link => { link.addEventListener('click', () => { if (!mobileMenu.classList.contains('hidden')) { mobileMenu.classList.add('hidden'); } }); }); };

const setupScrollSpy = () => { const sections = document.querySelectorAll('section[id]'); const navLinksDesktop = document.querySelectorAll('#nav-links-desktop .nav-link'); const navLinksMobile = document.querySelectorAll('#nav-links-mobile .nav-link');

const observer = new IntersectionObserver((entries) => { entries.forEach(entry => { if (entry.isIntersecting) { const id = entry.target.getAttribute('id'); const activeLinks = [ ...navLinksDesktop, ...navLinksMobile ].filter(link => link.getAttribute('href') === #$\{id\});

[...navLinksDesktop, ...navLinksMobile].forEach(link => link.classList.remove('active')); activeLinks.forEach(link => link.classList.add('active')); } }); }, { rootMargin: '-20% 0px -70% 0px', threshold: 0 });

sections.forEach(section => observer.observe(section)); };

const setupTabs = (containerId) => { const container = document.getElementById(containerId); if (!container) return;

const tabs = container.querySelectorAll('.tab-btn'); const contents = container.querySelectorAll('.tab-content');

tabs.forEach(tab => { tab.addEventListener('click', () => { const targetId = tab.dataset.target;

tabs.forEach(t => t.classList.remove('active')); tab.classList.add('active');

contents.forEach(c => c.classList.remove('active')); document.getElementById(targetId).classList.add('active'); }); }); };

const setupAccordions = () => { document.querySelectorAll('.accordion-btn').forEach(button => { button.addEventListener('click', () => { const content = button.nextElementSibling; const icon = button.querySelector('.accordion-icon'); const isOpen = !content.classList.contains('hidden');

content.classList.toggle('hidden'); icon.textContent = isOpen ? '+' : '−'; }); }); };

const setupAgentPatterns = () => { document.querySelectorAll('.agent-pattern-btn').forEach(button => { button.addEventListener('click', () => { const targetId = button.dataset.target; const targetDetail = document.getElementById(targetId);

const allDetails = document.querySelectorAll('.agent-pattern-detail');

if (targetDetail.classList.contains('hidden')) { allDetails.forEach(d => d.classList.add('hidden')); targetDetail.classList.remove('hidden'); } else { allDetails.forEach(d => d.classList.add('hidden')); } }); }); };

const setupAttackMap = () => { const detailBox = document.getElementById('attack-detail-box'); document.querySelectorAll('.attack-btn').forEach(button => { button.addEventListener('click', () => { const targetId = button.dataset.target; const dataContainer = document.getElementById($\{targetId\}-data);

if (dataContainer) { detailBox.innerHTML = dataContainer.innerHTML; detailBox.classList.remove('hidden'); } else { detailBox.classList.add('hidden'); } }); }); };

const renderVendorChart = () => { const ctx = document.getElementById('vendorChart'); if (!ctx) return;

new Chart(ctx.getContext('2d'), { type: 'bubble', data: { datasets: [ { label: 'Exa (Startup)', data: [{ x: 8, y: 7, r: 15 }], backgroundColor: 'rgba(29, 78, 216, 0.7)', }, { label: 'Tavily (Startup)', data: [{ x: 7, y: 8, r: 12 }], backgroundColor: 'rgba(30, 159, 115, 0.7)', }, { label: 'Parallel (Startup)', data: [{ x: 6, y: 6, r: 10 }], backgroundColor: 'rgba(217, 119, 6, 0.7)', }, { label: 'Classical Incumbent (e.g. Bing API)', data: [{ x: 3, y: 9, r: 25 }], backgroundColor: 'rgba(110, 110, 110, 0.7)', } ] }, options: { responsive: true, maintainAspectRatio: false, scales: { x: { title: { display: true, text: 'Reasoning Depth & Agent Optimization' }, min: 0, max: 10 }, y: { title: { display: true, text: 'Index Freshness & Scale' }, min: 0, max: 10 } }, plugins: { tooltip: { callbacks: { label: function(context) { return $\{context.dataset.label\}: (Depth: $\{context.parsed.x\}, Freshness: $\{context.parsed.y\}); } } } } } }); };

const renderGpuCostChart = () => { const ctx = document.getElementById('gpuCostChart'); if (!ctx) return;

new Chart(ctx.getContext('2d'), { type: 'line', data: { labels: ['Q1', 'Q2', 'Q3', 'Q4', 'Q1_Next', 'Q2_Next'], datasets: [ { label: 'API Revenue (Linear Growth)', data: [100, 120, 140, 160, 180, 200], borderColor: 'rgb(29, 78, 216)', backgroundColor: 'rgba(29, 78, 216, 0.1)', fill: true, tension: 0.1 }, { label: 'GPU/Index Cost (Exponential Growth)', data: [80, 90, 110, 150, 210, 300], borderColor: 'rgb(219, 39, 119)', backgroundColor: 'rgba(219, 39, 119, 0.1)', fill: true, tension: 0.2 } ] }, options: { responsive: true, maintainAspectRatio: false, scales: { y: { title: { display: true, text: 'Relative Cost/Revenue Units' } } }, plugins: { title: { display: false } } } }); };

const renderCostBreakdownChart = () => { const ctx = document.getElementById('costBreakdownChart'); if (!ctx) return;

new Chart(ctx.getContext('2d'), { type: 'doughnut', data: { labels: ['Crawl & Storage', 'Embedding Refresh', 'Inference (API Serving)'], datasets: [{ data: [35, 25, 40], backgroundColor: [ 'rgb(13, 148, 136)', 'rgb(217, 119, 6)', 'rgb(219, 39, 119)' ], hoverOffset: 4 }] }, options: { responsive: true, maintainAspectRatio: false, plugins: { title: { display: false } } } }); };

setupNavigation(); setupScrollSpy(); setupTabs('governance-tabs'); setupTabs('recommendations-tabs'); setupAccordions(); setupAgentPatterns(); setupAttackMap(); renderVendorChart(); renderGpuCostChart(); renderCostBreakdownChart(); });