import type { BrutalComparison } from './BrutalComparisonPage';

const standardAxes = {
  crossProvider: 'OpenAI, Anthropic, local models, SaaS APIs, MCP servers, and internal services can share one enforcement story.',
  crossRail: 'Model tokens, API credits, paid MCP tools, L402/x402-style access, prepaid budgets, and internal chargeback are policy inputs, not separate silos.',
  preExecution: 'Deny, scope, meter, or require proof before the expensive call, tool invocation, or paid resource executes.',
  delegation: 'Issue scoped, budgeted, revocable capability for an agent, task, session, tenant, or sub-agent instead of handing out broad static keys.',
  evidence: 'Evidence Packs connect identity, delegated authority, policy, budget, route/tool, decision, and receipt into an audit-ready artifact.',
  hybrid: 'Run enforcement close to private APIs, regulated data, self-hosted MCP tools, or customer-controlled gateways while keeping a consistent policy plane.',
  mcp: 'Proxy MCP sessions and tool calls at the protocol boundary, with per-tool budget, risk tier, identity, and decision evidence.',
};

export const brutalComparisons: Record<string, BrutalComparison> = {
  'aws-agentcore-payments': {
    slug: 'aws-agentcore-payments',
    competitor: 'AWS AgentCore Payments',
    eyebrow: 'Managed agent payments vs economic firewall',
    title: 'SatGate vs AWS AgentCore Payments',
    description: 'AWS AgentCore Payments helps agents transact inside the AWS AgentCore ecosystem. SatGate governs whether agents are allowed to access, spend, delegate, call MCP tools, or use paid rails before execution across the multi-provider enterprise environment.',
    verdict: 'If your world is AWS AgentCore, AWS gives you managed payments. If your environment spans OpenAI, Anthropic, local agents, MCP tools, internal APIs, hybrid gateways, and multiple payment rails, SatGate is the control layer.',
    competitorGoodAt: [
      'Managed payment enablement for agents built around AWS AgentCore patterns.',
      'Tight fit for teams standardizing agent runtime, identity, tools, and observability inside AWS.',
      'Cloud-native integration with AWS operations, identity, and monitoring primitives.',
    ],
    satgateGoodAt: [
      standardAxes.crossProvider,
      standardAxes.crossRail,
      standardAxes.preExecution,
      standardAxes.evidence,
    ],
    rows: [
      { axis: 'Primary job', satgate: 'Economic firewall: decide what an autonomous agent may access, spend, delegate, and prove before execution.', competitor: 'Managed agent payment capability in the AWS AgentCore stack.', winner: 'SatGate' },
      { axis: 'Cross-provider', satgate: standardAxes.crossProvider, competitor: 'Strongest for organizations standardized on AWS, Bedrock, and AgentCore.', winner: 'SatGate' },
      { axis: 'Cross-rail', satgate: standardAxes.crossRail, competitor: 'Payment/session rails in AWS-managed agent flows; not a general economic control plane for every provider and private API.', winner: 'SatGate' },
      { axis: 'Pre-execution control', satgate: standardAxes.preExecution, competitor: 'Can help with managed agent access/payment flows, but the center is not provider-neutral policy before every external spend event.', winner: 'SatGate' },
      { axis: 'Delegation', satgate: standardAxes.delegation, competitor: 'AWS identity and agent controls help inside AWS; portability across heterogeneous agents and sub-agents requires additional governance.', winner: 'SatGate' },
      { axis: 'Evidence Packs', satgate: standardAxes.evidence, competitor: 'AWS observability gives logs/traces. SatGate packages the policy decision and economic proof itself.', winner: 'SatGate' },
      { axis: 'Hybrid deployment', satgate: standardAxes.hybrid, competitor: 'AWS-managed by default; excellent cloud integration, weaker story when enforcement must live beside private non-AWS systems.', winner: 'SatGate' },
      { axis: 'MCP-native proxying', satgate: standardAxes.mcp, competitor: 'AgentCore has gateway/tool surfaces; SatGate frames MCP as the enforcement boundary for spend and authority.', winner: 'SatGate' },
    ],
    bullets: [
      { title: 'AWS is strongest inside AWS-native architectures', body: 'That is valuable. It is also the limitation. Most enterprises will not put every agent, model, API, MCP server, and paid rail inside one AWS-native box.' },
      { title: 'Payments are not permission', body: 'A payment session does not answer whether this agent, task, tenant, budget, route, or delegated child should be allowed to act right now.' },
      { title: 'Receipts need policy context', body: 'Finance and security need more than “a payment happened.” They need who delegated authority, what policy applied, why it was allowed, and what evidence remains.' },
      { title: 'Hybrid matters', body: 'Regulated APIs, private MCP tools, and customer-controlled gateways need enforcement near the trust boundary, not only in a managed cloud console.' },
    ],
    faqs: [
      { question: 'Does SatGate replace AWS AgentCore Payments?', answer: 'Not necessarily. AWS AgentCore Payments is useful for AWS-native agent payments. SatGate is the cross-provider control layer for agent authority, budgets, MCP tools, APIs, and paid rails.' },
      { question: 'What is the key difference?', answer: 'AgentCore Payments helps an AWS agent pay. SatGate decides whether any agent is allowed to spend, access, delegate, or pay before execution.' },
      { question: 'Can they work together?', answer: 'Yes. SatGate can govern broader enterprise agent authority while AWS handles AWS-native runtime or payment mechanics where that stack is used.' },
    ],
    ctaPrimary: { href: '/policy-to-proof', label: 'See Policy-to-Proof' },
    ctaSecondary: { href: '/agent-payment-controls', label: 'Compare payment controls' },
  },
  'cloudflare-ai-gateway': {
    slug: 'cloudflare-ai-gateway',
    competitor: 'Cloudflare AI Gateway',
    eyebrow: 'AI traffic gateway vs economic firewall',
    title: 'SatGate vs Cloudflare AI Gateway',
    description: 'Cloudflare AI Gateway is strong AI traffic infrastructure: analytics, logging, caching, rate limits, retries, fallback, and provider access on Cloudflare. SatGate is pre-execution economic governance for agents, APIs, MCP tools, delegated authority, and paid rails.',
    verdict: 'Cloudflare helps move and observe AI traffic. SatGate decides whether an autonomous agent is authorized to spend before that traffic exists.',
    competitorGoodAt: [
      'Edge-native AI traffic analytics, logging, caching, rate limits, retries, and fallback.',
      'Great fit for teams already building AI applications on Cloudflare Workers and Cloudflare’s network.',
      'Practical model/provider gateway features around AI app traffic.',
    ],
    satgateGoodAt: [standardAxes.crossRail, standardAxes.preExecution, standardAxes.delegation, standardAxes.mcp],
    rows: [
      { axis: 'Primary job', satgate: 'Pre-execution economic policy enforcement for autonomous agents.', competitor: 'AI traffic gateway for analytics, caching, rate limits, retries, fallback, and provider access.', winner: 'Tie' },
      { axis: 'Cross-provider', satgate: 'Provider choice is an implementation detail behind one agent authority policy.', competitor: 'Strong multi-provider AI traffic gateway features.', winner: 'Tie' },
      { axis: 'Cross-rail', satgate: standardAxes.crossRail, competitor: 'Primarily AI/model traffic; not payment/API/MCP economic rail governance as the center of the product.', winner: 'SatGate' },
      { axis: 'Pre-execution control', satgate: standardAxes.preExecution, competitor: 'Rate limits and gateway controls are useful, but they are not delegated economic authority.', winner: 'SatGate' },
      { axis: 'Delegation', satgate: standardAxes.delegation, competitor: 'No native SatGate-style attenuated agent capability and delegation-depth model.', winner: 'SatGate' },
      { axis: 'Evidence Packs', satgate: standardAxes.evidence, competitor: 'Logs and analytics explain traffic; they do not package authority, budget, and proof as the core artifact.', winner: 'SatGate' },
      { axis: 'Hybrid deployment', satgate: standardAxes.hybrid, competitor: 'Cloudflare-managed edge platform.', winner: 'SatGate' },
      { axis: 'MCP-native proxying', satgate: standardAxes.mcp, competitor: 'AI Gateway is not primarily an MCP economic policy proxy.', winner: 'SatGate' },
    ],
    bullets: [
      { title: 'Gateway is not governance', body: 'Routing, caching, and retry logic do not decide whether a delegated agent should be allowed to spend on a protected tool.' },
      { title: 'Rate limits are blunt', body: 'A request count does not encode tenant budget, tool risk, delegated authority, evidence requirements, or paid-rail settlement.' },
      { title: 'MCP changes the boundary', body: 'Agents spend through tools. SatGate treats the MCP tool call as the enforcement event, not just raw AI HTTP traffic.' },
      { title: 'Complement, do not confuse', body: 'Use Cloudflare for AI traffic operations. Put SatGate where the security and finance question is “should this agent be allowed?”' },
    ],
    faqs: [
      { question: 'Is SatGate a Cloudflare AI Gateway replacement?', answer: 'No. Cloudflare AI Gateway is AI traffic infrastructure. SatGate is agent economic governance. They can sit in the same architecture.' },
      { question: 'What does SatGate add?', answer: 'Delegated budgets, pre-execution policy, cross-rail enforcement, MCP tool governance, revocation, and Evidence Packs.' },
      { question: 'When does Cloudflare win?', answer: 'When the problem is edge-native AI traffic analytics, caching, routing, rate limits, retries, or fallback. SatGate wins when the problem is agent authority and spend.' },
    ],
    ctaPrimary: { href: '/mcp-governance', label: 'Govern MCP tools' },
    ctaSecondary: { href: '/ai-agent-cost-control', label: 'Control agent spend' },
  },
  'langsmith-helicone-datadog': {
    slug: 'langsmith-helicone-datadog',
    competitor: 'LangSmith, Helicone, and Datadog',
    eyebrow: 'Observability vs pre-execution control',
    title: 'SatGate vs LangSmith, Helicone, and Datadog',
    description: 'LangSmith, Helicone, and Datadog help teams trace, debug, monitor, evaluate, and analyze LLM systems. SatGate sits before execution to enforce agent budgets, delegated authority, MCP tool policy, paid-rail access, and Evidence Packs.',
    verdict: 'Observability tells you what agents did. SatGate controls what agents are allowed to do before they do it.',
    competitorGoodAt: [
      'Tracing, debugging, monitoring, evaluations, usage analytics, latency, errors, and cost dashboards.',
      'Understanding model/application behavior after or around execution.',
      'Feeding engineering teams the telemetry they need to improve LLM applications.',
    ],
    satgateGoodAt: [standardAxes.preExecution, standardAxes.delegation, standardAxes.evidence, standardAxes.mcp],
    rows: [
      { axis: 'Primary job', satgate: 'Control agent authority and spend before execution.', competitor: 'Trace, debug, evaluate, monitor, and analyze LLM behavior.', winner: 'Tie' },
      { axis: 'Cross-provider', satgate: standardAxes.crossProvider, competitor: 'Often provider/framework flexible at the tracing and observability layer.', winner: 'Tie' },
      { axis: 'Cross-rail', satgate: standardAxes.crossRail, competitor: 'Mostly LLM/app telemetry and cost visibility; not unified economic enforcement across paid APIs and rails.', winner: 'SatGate' },
      { axis: 'Pre-execution control', satgate: standardAxes.preExecution, competitor: 'Primarily after/during execution visibility; some gateway controls exist, but enforcement is not the core category.', winner: 'SatGate' },
      { axis: 'Delegation', satgate: standardAxes.delegation, competitor: 'Users, sessions, traces, and properties are not portable delegated spend authority.', winner: 'SatGate' },
      { axis: 'Evidence Packs', satgate: standardAxes.evidence, competitor: 'Logs and traces are raw material; SatGate packages policy proof as the artifact.', winner: 'SatGate' },
      { axis: 'Hybrid deployment', satgate: standardAxes.hybrid, competitor: 'Varies by product and enterprise tier; often SaaS/agent-centric observability.', winner: 'SatGate' },
      { axis: 'MCP-native proxying', satgate: standardAxes.mcp, competitor: 'Not primarily MCP economic enforcement proxies.', winner: 'SatGate' },
    ],
    bullets: [
      { title: 'Postmortems are expensive', body: 'Finding runaway spend in a dashboard after the fact is better than nothing. It is still too late.' },
      { title: 'Telemetry is not authority', body: 'A trace can show which agent called a tool. It does not mean that agent had bounded permission to call it.' },
      { title: 'Evidence needs decisions', body: 'Compliance needs the allow/deny decision, policy, budget, delegation chain, and receipt — not just spans and logs.' },
      { title: 'Use both layers', body: 'Send traces to LangSmith, Helicone, or Datadog. Put SatGate in the path where the agent is about to spend.' },
    ],
    faqs: [
      { question: 'Does SatGate replace observability?', answer: 'No. SatGate complements observability. It enforces policy before execution and can feed cleaner evidence into tracing and monitoring systems.' },
      { question: 'What is the governance gap?', answer: 'Observability explains what happened. It usually does not provide portable delegated budgets, MCP tool enforcement, paid-rail governance, or pre-execution authority.' },
      { question: 'Why group LangSmith, Helicone, and Datadog?', answer: 'They differ in product scope, but the comparison axis is the same: visibility and analytics versus pre-execution control and proof.' },
    ],
    ctaPrimary: { href: '/evidence-pack-demo', label: 'See Evidence Packs' },
    ctaSecondary: { href: '/llm-cost-monitoring', label: 'From monitoring to control' },
  },
  'api-gateway-rate-limits': {
    slug: 'api-gateway-rate-limits',
    competitor: 'API Gateway rate limits',
    eyebrow: 'Traffic primitive vs authority primitive',
    title: 'SatGate vs API Gateway Rate Limits',
    description: 'API Gateway rate limits throttle request volume. SatGate governs delegated agent authority: budget, route, tool, tenant, payment rail, evidence requirement, and revocation before the request executes.',
    verdict: 'Rate limits answer “how many requests?” SatGate answers “is this agent allowed to spend this budget on this resource right now, and can we prove why?”',
    competitorGoodAt: [
      'Basic traffic shaping: requests per second, bursts, quotas, usage plans, and abuse reduction.',
      'Protecting APIs from generic floods or accidental high-volume clients.',
      'Fitting into existing API gateway stacks such as AWS API Gateway, Kong, NGINX, Envoy, Apigee, or Tyk.',
    ],
    satgateGoodAt: [standardAxes.preExecution, standardAxes.delegation, standardAxes.evidence, standardAxes.crossRail],
    rows: [
      { axis: 'Primary job', satgate: 'Agent-aware economic authorization and proof.', competitor: 'Request throughput control.', winner: 'SatGate' },
      { axis: 'Cross-provider', satgate: standardAxes.crossProvider, competitor: 'Possible only if you custom-route everything through one gateway estate.', winner: 'SatGate' },
      { axis: 'Cross-rail', satgate: standardAxes.crossRail, competitor: 'HTTP/API traffic primitive; not economic rail governance.', winner: 'SatGate' },
      { axis: 'Pre-execution control', satgate: 'Semantic policy before spend: who, what, why, budget, route, tool, rail, evidence.', competitor: 'Pre-request count/quota checks. Useful, but blunt.', winner: 'SatGate' },
      { axis: 'Delegation', satgate: standardAxes.delegation, competitor: 'API keys, JWTs, IAM, or usage plans rarely encode agent delegation depth and bounded spend.', winner: 'SatGate' },
      { axis: 'Evidence Packs', satgate: standardAxes.evidence, competitor: 'Access logs exist, but they do not usually explain delegated economic authority.', winner: 'SatGate' },
      { axis: 'Hybrid deployment', satgate: standardAxes.hybrid, competitor: 'Many gateway stacks can be hybrid; the primary comparison is whether policy follows delegated agent authority across tools, rails, and providers.', winner: 'Tie' },
      { axis: 'MCP-native proxying', satgate: standardAxes.mcp, competitor: 'Generic API gateways are HTTP-aware, not MCP authority-aware by default.', winner: 'SatGate' },
    ],
    bullets: [
      { title: 'A quota is not a policy', body: '“1000 requests/day” does not say whether a child agent was delegated authority for this tool, tenant, dataset, or paid route.' },
      { title: 'Agents need spend semantics', body: 'One request can cost one cent or one thousand dollars. Volume is the wrong control plane for economic risk.' },
      { title: 'MCP tools are not just URLs', body: 'Tool name, server, session, arguments, risk tier, and budget matter. A generic route limit loses the agent context.' },
      { title: 'Logs are not proof', body: 'Access logs provide raw event data. Evidence Packs are constructed around policy, authority, decision, and receipt.' },
    ],
    faqs: [
      { question: 'Should I remove API Gateway rate limits?', answer: 'No. Keep them. SatGate adds agent-aware economic policy above blunt traffic controls.' },
      { question: 'What does SatGate know that a rate limit does not?', answer: 'Delegated authority, remaining budget, MCP tool identity, route policy, paid-rail context, tenant, agent lineage, and evidence requirements.' },
      { question: 'Can SatGate run with existing gateways?', answer: 'Yes. SatGate can sit before, beside, or behind existing gateway infrastructure depending on where enforcement belongs.' },
    ],
    ctaPrimary: { href: '/agent-capability-tokens', label: 'Use capability tokens' },
    ctaSecondary: { href: '/mcp-budget-enforcement', label: 'Enforce MCP budgets' },
  },
  'openai-anthropic-budget-controls': {
    slug: 'openai-anthropic-budget-controls',
    competitor: 'native OpenAI and Anthropic budget controls',
    eyebrow: 'Provider caps vs cross-provider control',
    title: 'SatGate vs Native OpenAI and Anthropic Budget Controls',
    description: 'OpenAI and Anthropic budget controls are useful provider-specific guardrails. SatGate is the cross-provider economic firewall above them: delegated budgets, MCP tool governance, paid API access, hybrid enforcement, and Evidence Packs.',
    verdict: 'Native budgets are necessary last-mile guardrails. They are not a portable agent authorization layer across providers, tools, APIs, rails, and hybrid systems.',
    competitorGoodAt: [
      'Capping or tracking spend inside a single model provider account, project, workspace, or organization.',
      'Provider-native usage dashboards, API keys, rate limits, and admin controls.',
      'Last-mile protection against runaway usage within that vendor’s platform.',
    ],
    satgateGoodAt: [standardAxes.crossProvider, standardAxes.crossRail, standardAxes.delegation, standardAxes.mcp],
    rows: [
      { axis: 'Primary job', satgate: 'One delegated authority layer across agents, providers, APIs, MCP tools, and paid rails.', competitor: 'Provider-specific spend caps, rate limits, usage dashboards, and keys.', winner: 'SatGate' },
      { axis: 'Cross-provider', satgate: standardAxes.crossProvider, competitor: 'OpenAI controls OpenAI. Anthropic controls Anthropic.', winner: 'SatGate' },
      { axis: 'Cross-rail', satgate: standardAxes.crossRail, competitor: 'Model-provider usage only; not internal APIs, SaaS tools, MCP servers, or payment-style access rails.', winner: 'SatGate' },
      { axis: 'Pre-execution control', satgate: standardAxes.preExecution, competitor: 'Can stop calls when provider limits are reached, but lacks rich business policy across external tools and rails.', winner: 'SatGate' },
      { axis: 'Delegation', satgate: standardAxes.delegation, competitor: 'Projects, keys, and workspaces are not portable delegated capabilities for autonomous subagents.', winner: 'SatGate' },
      { axis: 'Evidence Packs', satgate: standardAxes.evidence, competitor: 'Usage exports and dashboards help accounting; they do not explain policy and delegation across the full workflow.', winner: 'SatGate' },
      { axis: 'Hybrid deployment', satgate: standardAxes.hybrid, competitor: 'Provider-side SaaS controls.', winner: 'SatGate' },
      { axis: 'MCP-native proxying', satgate: standardAxes.mcp, competitor: 'Native provider budgets do not govern arbitrary MCP tool calls.', winner: 'SatGate' },
    ],
    bullets: [
      { title: 'Provider controls stop at the vendor boundary', body: 'The moment an agent leaves OpenAI or Anthropic for an MCP tool, SaaS API, database, or payment rail, native budgets no longer cover the full workflow.' },
      { title: 'Keys are not delegation', body: 'An API key or project limit is not the same as a scoped, expiring, budgeted capability for a specific task or child agent.' },
      { title: 'Cross-provider agents need one policy', body: 'Real agents call multiple models and tools. One provider dashboard per vendor is not an enterprise control plane.' },
      { title: 'Evidence must span the workflow', body: 'When a task touches Anthropic, OpenAI, a private MCP tool, and a paid API, the proof cannot live in four disconnected consoles.' },
    ],
    faqs: [
      { question: 'Should teams still use OpenAI and Anthropic budgets?', answer: 'Yes. Native budgets are useful provider-side backstops. SatGate adds cross-provider agent authority before traffic reaches those providers.' },
      { question: 'What does SatGate add above native budgets?', answer: 'Delegated capabilities, per-agent and per-tool budgets, MCP-native enforcement, paid-rail policy, hybrid deployment, and Evidence Packs.' },
      { question: 'Why not just set lower provider limits?', answer: 'Lower limits reduce blast radius inside one vendor. They do not govern the agent’s full workflow across other models, APIs, tools, and payment rails.' },
    ],
    ctaPrimary: { href: '/openai-budget-policy-generator', label: 'Generate an OpenAI policy' },
    ctaSecondary: { href: '/ai-api-budget-enforcement', label: 'Enforce AI API budgets' },
  },
};
