hanzo.ai/lib/data/solutions.ts

/**
 * What Hanzo does for each team, each industry and each kind of work.
 *
 * ONE LIST, FOUR READERS. `/solutions` draws the index from it, `/solutions/<slug>`
 * draws one entry through `components/solutions/Solution.tsx`, `app/sitemap.ts`
 * offers every slug, and the header's Solutions menu lists it by `kind`. A
 * solution is added here and nowhere else.
 *
 * Every product an entry names links a page this site publishes (`PRODUCTS`),
 * and every sentence is a fact about software that runs today. Prices and counts
 * are never typed: the reserved tier's rates are read from `pricing.json` where
 * the page renders them. What an entry says about compliance follows `/trust`:
 * controls built to be compatible with SOC 2, the audit report on request, and
 * regulated data (PHI, card data, student records) only under the written terms
 * `/legal/terms` names.
 *
 * NOTHING HERE IMPORTS A SNAPSHOT. The header's menu reads this file, so it
 * ships on every page; `pricing.json` would ride along with it.
 */

import { phrase } from '@hanzo/i18n'

export type Kind = 'team' | 'industry' | 'usecase' | 'reserved'

/** One thing the solution does, or one fact a reviewer needs. */
export interface Point {
  title: string
  body: string
}

export interface Solution {
  /** The address segment: /solutions/<slug>. */
  slug: string
  kind: Kind
  /** The menu label, marked with `phrase` (@hanzo/i18n) so the header draws it in the reader's language. */
  name: string
  /** One line under the label, in the menu and on the index. */
  hint: string
  /** The page's <h1>, and its title. */
  title: string
  /** The hero paragraph, and the meta description. */
  lede: string
  /** What it does for you: three to five workflows. */
  work: Point[]
  /** The products it runs on, as keys of PRODUCTS. */
  products: Product[]
  /** Security and compliance, where a buyer in this seat asks. */
  trust?: Point[]
  /** Show the on-demand GPU rates beside it, read from the pricing snapshot. */
  rates?: true
}

/** The kinds, by the column title the header gives each, marked with `phrase` as `name` is. */
export const KINDS: { id: Kind; label: string }[] = [
  { id: 'team', label: phrase('Teams') },
  { id: 'industry', label: phrase('Industries') },
  { id: 'usecase', label: phrase('Use cases') },
  { id: 'reserved', label: phrase('Reserved tier') },
]

export const INDEX = '/solutions'

/** The products a solution can name: a label, the page, and what it does. */
const PRODUCT = {
  agents: { label: 'Agents', href: '/products/agents', line: 'Define an agent once — model, instructions, tools and a budget — and run it by name.' },
  sdk: { label: 'Agents SDK', href: '/agents/sdk', line: 'A Python SDK for agents that hand work to each other behind a router.' },
  bot: { label: 'Hanzo Bot', href: '/bot', line: 'A teammate with its own computer that signs in to your tools and reports back.' },
  app: { label: 'Hanzo App', href: '/dev', line: 'Describe an app and it ships to a live URL with data, sign-in and storage wired in.' },
  auto: { label: 'Hanzo Auto', href: '/auto', line: 'Workflows fired by a webhook or a schedule, with runs that survive a restart.' },
  connectors: { label: 'Connectors', href: '/automations', line: 'The apps a workflow can read from, write to, or be started by.' },
  mcp: { label: 'MCP', href: '/mcp', line: 'A shell, a filesystem, a code index, git and HTTP for any MCP client.' },
  computer: { label: 'Hanzo Computer', href: '/computer', line: 'An agent that drives any app by screenshot, mouse and keyboard.' },
  extension: { label: 'Hanzo Extension', href: '/extension', line: 'Lets an agent work in the browser you are already signed into.' },
  cli: { label: 'Hanzo CLI', href: '/cli', line: 'Plan, edit and ship code with a model in your terminal.' },
  ide: { label: 'Hanzo IDE', href: '/ide', line: 'The VS Code workbench with an agent that remembers your codebase.' },
  api: { label: 'Hanzo API', href: '/api', line: 'One base URL and one key for models, agents and tools.' },
  models: { label: 'Models', href: '/models', line: 'Every model behind one endpoint and one key, in the wire format your client speaks.' },
  enso: { label: 'Enso', href: '/enso', line: 'Routes each call to the model that should take it.' },
  zen: { label: 'Zen', href: '/zen', line: 'Open-weight models you can download and run on your own hardware.' },
  engine: { label: 'Hanzo Engine', href: '/engine', line: 'The inference engine, for serving models on machines you control.' },
  studio: { label: 'Hanzo Studio', href: '/studio', line: 'A node graph for generating images, video, audio and 3D.' },
  search: { label: 'Hanzo Search', href: '/search', line: 'Keyword and meaning in one query over the documents you push.' },
  crawl: { label: 'Hanzo Crawl', href: '/crawl', line: 'Turns a website into clean Markdown a model can read.' },
  memory: { label: 'Memory', href: '/products/memory', line: 'A graph of what was true and when it was known, answered with citations.' },
  base: { label: 'Hanzo Base', href: '/base', line: 'Data, users, files and live updates in one store per organization.' },
  datastore: { label: 'Hanzo Datastore', href: '/datastore', line: 'A column store for analytical SQL.' },
  insights: { label: 'Hanzo Insights', href: '/insights', line: 'Events, funnels, session replay, feature flags and experiments.' },
  o11y: { label: 'Hanzo O11y', href: '/o11y', line: 'Traces, metrics, logs and profiles in one place.' },
  sentinel: { label: 'Hanzo Sentinel', href: '/sentinel', line: 'Exceptions, regressions and slow requests, caught before users report them.' },
  guard: { label: 'Hanzo Guard', href: '/guard', line: 'Catches prompt injection and pasted secrets going in, and leaks coming out.' },
  iam: { label: 'Hanzo IAM', href: '/iam', line: 'Sign-in through your identity provider, SCIM provisioning and org-scoped roles.' },
  kms: { label: 'Hanzo KMS', href: '/kms', line: 'Secrets held per organization, never in the code that uses them.' },
  record: { label: 'Record', href: '/products/record', line: 'Every act by a person or an agent, in one audit trail.' },
  idv: { label: 'Hanzo IDV', href: '/idv', line: 'One interface to the identity-verification vendors for KYC, KYB and AML.' },
  ledger: { label: 'Hanzo Ledger', href: '/ledger', line: 'A programmable double-entry ledger.' },
  payments: { label: 'Hanzo Payments', href: '/payments', line: 'One integration in front of the processors that move the money.' },
  commerce: { label: 'Hanzo Commerce', href: '/commerce', line: 'A headless API for the catalog, the cart, checkout and orders.' },
  dataroom: { label: 'Dataroom', href: '/dataroom', line: 'Share documents with access controls and see who opened what.' },
  sign: { label: 'Hanzo Sign', href: '/sign', line: 'Send a PDF, get it signed, keep the record of who signed and when.' },
  machines: { label: 'Machines', href: '/products/machines', line: 'Sandboxes, metered machines and functions, each the organization’s own.' },
  gpus: { label: 'GPUs', href: '/cloud/gpus', line: 'Accelerators on demand, metered by the second.' },
  evals: { label: 'Evals', href: '/cloud/evals', line: 'Score a prompt or a model change against a dataset before it ships.' },
  team: { label: 'Hanzo Team', href: 'https://hanzo.team', line: 'Channels, messages and AI teammates in one workspace.' },
  gui: { label: 'Hanzo GUI', href: '/gui', line: 'The cross-platform kit and tokens every Hanzo app is drawn with.' },
  ui: { label: 'Hanzo UI', href: '/ui', line: 'Open-source React components built on those tokens.' },
  enterprise: { label: 'Enterprise', href: '/enterprise', line: 'Our cloud or yours: air-gapped deployment, SSO, audit logs and a person to call.' },
} as const

export type Product = keyof typeof PRODUCT
export const PRODUCTS: Record<Product, { label: string; href: string; line: string }> = PRODUCT

/* Statements several entries make, said once. */
const FRAMEWORKS: Point = {
  title: 'Frameworks',
  body: 'Our controls are built to be compatible with SOC 2 and audited internally, continually. The audit report is available on request.',
}
const APART: Point = {
  title: 'One organization, one store',
  body: 'Each organization’s data is its own SQLite file, opened under its own derived key where a master key is set. A query in one organization has no second file to reach into.',
}
const TRAIL: Point = {
  title: 'An audit trail you can query',
  body: 'Every request is a row: the organization and user who acted, the address they came from, what they called and what the server answered. An agent’s run is recorded the same way.',
}
const INSIDE: Point = {
  title: 'Or keep it inside',
  body: 'The platform is open source and runs in your cloud, on your own hardware, or air-gapped, with Zen weights served on machines you control. Then nothing reaches us.',
}
const UNTRAINED: Point = {
  title: 'Your content is not training data',
  body: 'By default your content is used only to provide the service — never to train, tune or evaluate Hanzo models. Any research use takes an election you make, and you can withdraw it.',
}

export const SOLUTIONS: Solution[] = [
  /* ── Teams ─────────────────────────────────────────────────────────────── */
  {
    slug: 'finance',
    kind: 'team',
    name: phrase('Finance'),
    hint: 'Close faster, with every number traced to its source.',
    title: 'Hanzo for finance teams',
    lede: 'Agents that reconcile, report and chase, on a ledger that refuses an unbalanced entry — and a record of every run, so the auditor reads what happened instead of asking.',
    work: [
      {
        title: 'Reconcile against a ledger that balances',
        body: 'Post every movement to a double-entry ledger. An agent matches payouts against it and brings back only what does not tie, instead of a person scanning two spreadsheets.',
      },
      {
        title: 'Run the monthly pack on a schedule',
        body: 'On the first of the month a workflow pulls the numbers from Stripe, Google Sheets or your warehouse, drafts the variance commentary and posts it for review. If step seven fails, the run resumes at step seven.',
      },
      {
        title: 'Ask the warehouse in plain English',
        body: 'An agent writes the SQL, shows it to you and runs it against Datastore. You read the query before you trust the number.',
      },
      {
        title: 'Know what AI costs, agent by agent',
        body: 'Every agent carries a budget it cannot pass, and its spend is readable to the micro-dollar. The line on the invoice has a name next to it.',
      },
      {
        title: 'Diligence without the email chain',
        body: 'Share the data room with access controls and see who opened what. Send the agreement for signature and keep the cap table beside it.',
      },
    ],
    products: ['ledger', 'auto', 'datastore', 'agents', 'dataroom', 'sign'],
    trust: [
      TRAIL,
      {
        title: 'Credentials stay in KMS',
        body: 'The keys a workflow uses to reach your systems are held per organization in KMS, never in the workflow itself, and every privileged action is logged.',
      },
    ],
  },
  {
    slug: 'data',
    kind: 'team',
    name: phrase('Data'),
    hint: 'Answers in SQL you can read, from data agents can reach.',
    title: 'Hanzo for data teams',
    lede: 'Put events, tables and documents where agents can query them — and keep every answer tied to the query, the file or the assertion it came from.',
    work: [
      {
        title: 'Analytics at column-store speed',
        body: 'Datastore keeps each column in its own compressed file, so a query reads only the columns it names. It speaks a ClickHouse-compatible HTTP API and ingests JSONEachRow and Parquet.',
      },
      {
        title: 'Product events without a pipeline',
        body: 'Insights captures events, funnels and retention, and hands you SQL when a chart cannot say it. The flag that shipped the change and the replay of someone using it sit beside the metric.',
      },
      {
        title: 'Answers with receipts',
        body: 'The memory graph records each assertion with who said it and when it was true, and never overwrites one. Ask a question and the answer cites what it rests on; ask as of last quarter and you get last quarter.',
      },
      {
        title: 'One search over everything you own',
        body: 'Push documents once. Full text finds the exact string, vectors find what you described, and one request runs both.',
      },
      {
        title: 'A computer for the analysis',
        body: 'Lease a sandbox for the organization, run Python against the extract, and give it back. A paused machine meters nothing.',
      },
    ],
    products: ['datastore', 'insights', 'memory', 'search', 'crawl', 'machines'],
  },
  {
    slug: 'sales',
    kind: 'team',
    name: phrase('Sales'),
    hint: 'Research, follow-up and a CRM that stays current.',
    title: 'Hanzo for sales teams',
    lede: 'Give every rep a bot that researches the account before the call, drafts the follow-up after it, and keeps the CRM current — working in the tools the rep already uses.',
    work: [
      {
        title: 'The brief before the meeting',
        body: 'A bot reads the prospect’s site, recent news and your notes, and hands the rep one page with every source linked.',
      },
      {
        title: 'A CRM that updates itself',
        body: 'After the call a workflow writes the notes, next step and close date back to Salesforce, HubSpot or Pipedrive. The rep reviews; nobody retypes.',
      },
      {
        title: 'Follow-ups in the rep’s voice',
        body: 'The bot drafts the email from the call and the thread, in the tone the rep already writes in, and brings it back. The rep decides whether it goes.',
      },
      {
        title: 'Every channel in one inbox',
        body: 'Slack, Teams, Discord and Telegram land in one inbox, with the agent that helps answer them sitting beside it.',
      },
      {
        title: 'Pipeline questions, answered with the query',
        body: 'Ask what closed, what slipped and why. The answer comes with the SQL it ran, against the numbers in your warehouse.',
      },
    ],
    products: ['bot', 'auto', 'connectors', 'crawl', 'team', 'datastore'],
  },
  {
    slug: 'marketing',
    kind: 'team',
    name: phrase('Marketing'),
    hint: 'From brief to published campaign, measured.',
    title: 'Hanzo for marketing teams',
    lede: 'Go from a brief to a published campaign — copy, images, video and the landing page — and measure it with the same platform that shipped it.',
    work: [
      {
        title: 'Brief to draft in one thread',
        body: 'Write the positioning, the long post and the short variants in one conversation. Enso picks a fast model for the variants and a strong one for the essay, or you name the one you want.',
      },
      {
        title: 'Make the images and the video',
        body: 'Studio wires image, video and audio models into a node graph. Save the graph, and the next campaign starts from the look you settled on.',
      },
      {
        title: 'Ship the landing page',
        body: 'Describe the page and Hanzo App builds it on a live URL, with the form, the database and sign-in already there.',
      },
      {
        title: 'Publish on schedule',
        body: 'A workflow posts to LinkedIn, X, Instagram, TikTok and YouTube, and sends through Mailchimp, Customer.io or Brevo, on the dates you set.',
      },
      {
        title: 'Know what worked',
        body: 'An experiment is a flag with a metric attached. Pick the goal before launch and read the result when it means something.',
      },
    ],
    products: ['studio', 'app', 'auto', 'connectors', 'insights', 'enso'],
  },
  {
    slug: 'operations',
    kind: 'team',
    name: phrase('Operations'),
    hint: 'Recurring work, run by agents, with a record.',
    title: 'Hanzo for operations teams',
    lede: 'Turn the checklist nobody wants into a workflow that runs itself, with a budget on every agent and a record of every step it took.',
    work: [
      {
        title: 'Workflows that survive failure',
        body: 'Draw the workflow, connect the apps and fire it from a webhook or a schedule. Each step is written down as it runs, so a crash resumes where it stopped instead of starting over.',
      },
      {
        title: 'Bots with standing jobs',
        body: 'Keep bots as workers with their own machine, tools, secrets and schedule: the Monday report, the nightly check, the vendor follow-up.',
      },
      {
        title: 'Apps with no API',
        body: 'When a system has only a screen, an agent drives it by screenshot, mouse and keyboard, or through the browser you are already signed into.',
      },
      {
        title: 'A budget and a trail',
        body: 'Each agent session has a spending cap it cannot pass, and every run is recorded with its input, output, model and duration.',
      },
      {
        title: 'Paperwork as a step',
        body: 'Render the document from a template, send it for signature and file it, from inside the workflow rather than from somebody’s desk.',
      },
    ],
    products: ['auto', 'bot', 'computer', 'extension', 'agents', 'sign'],
  },
  {
    slug: 'engineering',
    kind: 'team',
    name: phrase('Engineering'),
    hint: 'Coding agents, one API, and machines to run it all.',
    title: 'Hanzo for engineering teams',
    lede: 'An agent that plans, edits and opens pull requests; one API for every model behind it; and the sandboxes, machines and observability to ship what it writes.',
    work: [
      {
        title: 'Hand off a task, get a pull request',
        body: 'Give the agent an issue. It reads the code, makes the change, runs the tests and opens a pull request for review — from the terminal, the editor or the browser.',
      },
      {
        title: 'One API for every model',
        body: 'Point the OpenAI or Anthropic client you already use at api.hanzo.ai and name a model. Change the name and the model changes; the key and the bill stay the same.',
      },
      {
        title: 'Tools your agents can reach',
        body: 'The MCP server gives any client a shell, a filesystem, a code index, git and HTTP. Skills load the right playbook only when the work calls for it.',
      },
      {
        title: 'Real computers, by the second',
        body: 'Lease a sandbox for the agent’s work, launch a metered machine or publish a function. There is no creation fee, and a paused computer costs nothing.',
      },
      {
        title: 'See it in production',
        body: 'Traces, metrics, logs and profiles in one place, and Sentinel catches exceptions and regressions before a user reports them.',
      },
    ],
    products: ['cli', 'ide', 'api', 'mcp', 'machines', 'o11y'],
  },
  {
    slug: 'design',
    kind: 'team',
    name: phrase('Design'),
    hint: 'Explore visuals and ship prototypes that run.',
    title: 'Hanzo for design teams',
    lede: 'Explore visuals in a graph you can edit, turn the direction into a working app instead of a mockup, and hand engineering the components they already build with.',
    work: [
      {
        title: 'Generate, then direct',
        body: 'Studio chains image, video, audio and 3D models in a graph you can see. Change one node and regenerate; the rest of the look holds.',
      },
      {
        title: 'Prototypes that run',
        body: 'Describe the flow and Hanzo App builds it with real data and sign-in. Refine it by talking to it or by editing the code — what previews is what deploys.',
      },
      {
        title: 'One system across surfaces',
        body: 'Hanzo GUI and Hanzo UI are the open-source tokens and components every Hanzo app is drawn with, for web, mobile and desktop from the same code.',
      },
      {
        title: 'Research that stays findable',
        body: 'Read reference sites as clean text, keep the findings in one index, and find them again by phrase or by what you meant.',
      },
    ],
    products: ['studio', 'app', 'gui', 'ui', 'crawl', 'search'],
  },

  /* ── Industries ────────────────────────────────────────────────────────── */
  {
    slug: 'cybersecurity',
    kind: 'industry',
    name: phrase('Cybersecurity'),
    hint: 'Triage, investigation and fixes, on controls you can read.',
    title: 'Hanzo for cybersecurity',
    lede: 'Put agents on the queue — the triage, the investigation, the fix — on a platform whose own controls are written down mechanism by mechanism, with every agent action in the audit trail.',
    work: [
      {
        title: 'Triage with the evidence attached',
        body: 'An agent reads the alert, pulls the related traces and logs, and writes up what happened with a link to every line it relied on. The analyst decides; the agent gathers.',
      },
      {
        title: 'From advisory to pull request',
        body: 'Hand a bot the CVE and the repository. It finds the affected code, makes the change, runs the tests and opens a pull request for review.',
      },
      {
        title: 'Reproduce it somewhere else',
        body: 'Run a proof of concept or open a suspicious file in a leased sandbox, a separate computer for the organization, and read the exit code, stdout and stderr back.',
      },
      {
        title: 'Guard the model boundary',
        body: 'Guard reads prompts on the way in for injection and pasted secrets, and replies on the way out for leaks — as a proxy, a CLI wrapper or a filter in front of an MCP server.',
      },
      {
        title: 'Identity your review can press on',
        body: 'PKCE with S256 only, argon2id password hashes, single-use refresh tokens that revoke their whole family on replay, and SCIM from your directory.',
      },
    ],
    products: ['guard', 'o11y', 'bot', 'machines', 'iam', 'kms'],
    trust: [
      {
        title: 'Controls you can read',
        body: 'The trust page describes each mechanism as the code implements it: sign-in, token verification, tenancy, the audit trail and key custody — including what is not built yet.',
      },
      FRAMEWORKS,
      INSIDE,
    ],
  },
  {
    slug: 'financial-services',
    kind: 'industry',
    name: phrase('Financial services'),
    hint: 'Onboarding, ledgers, payments and reporting, with a trail.',
    title: 'Hanzo for financial services',
    lede: 'Automate onboarding, reconciliation and reporting on a platform that records who did what — person or agent — and keeps each organization’s data in its own store.',
    work: [
      {
        title: 'Onboarding without a rewrite',
        body: 'IDV puts one interface in front of the verification vendors, so switching vendor is configuration. A webhook must prove it came from the vendor before its verdict counts.',
      },
      {
        title: 'Money on a ledger that balances',
        body: 'Model accounts, holds and transfers on a double-entry ledger, and let agents move money only through it.',
      },
      {
        title: 'Processors as a routing decision',
        body: 'One integration in front of the payment processors, so which one moves the money is a choice you can change without touching checkout.',
      },
      {
        title: 'Reports an examiner can trace',
        body: 'Every request is a row in the audit trail, and the platform’s own entries — consent answers, credentials issued and revoked — cannot be written or edited through the API.',
      },
      {
        title: 'Filings, read and remembered',
        body: 'Agents read filings and disclosures as text, keep each extracted fact with its source and date, and answer as of any date you name.',
      },
    ],
    products: ['idv', 'ledger', 'payments', 'record', 'memory', 'datastore'],
    trust: [
      APART,
      {
        title: 'Regulated data by agreement',
        body: 'Payment-card data and other regulated data go through Hanzo’s service only under separate written terms. Where data must not leave, run the platform in your own environment.',
      },
      FRAMEWORKS,
    ],
  },
  {
    slug: 'healthcare',
    kind: 'industry',
    name: phrase('Healthcare'),
    hint: 'Less paperwork, with patient data kept on your terms.',
    title: 'Hanzo for healthcare',
    lede: 'Take documentation, scheduling and research off clinicians’ desks, with patient data kept in your own environment unless a Business Associate Agreement covers it.',
    work: [
      {
        title: 'Notes a clinician signs',
        body: 'Turn a visit transcript into a structured draft note for the clinician to review, correct and sign. The model drafts; a person decides.',
      },
      {
        title: 'Scheduling and follow-up',
        body: 'Workflows confirm appointments, chase missing forms and route referrals, on a schedule or on a webhook from the systems you already run.',
      },
      {
        title: 'Literature with sources',
        body: 'Search published literature and your own protocols together, and get summaries that link each claim to the passage it came from.',
      },
      {
        title: 'Policies people can find',
        body: 'Push policies, protocols and runbooks once. Staff find the exact phrase or the thing they meant from one search box.',
      },
    ],
    products: ['search', 'auto', 'memory', 'guard', 'zen', 'enterprise'],
    trust: [
      {
        title: 'Patient data needs a BAA first',
        body: 'Protected health information may go through Hanzo’s service only once a Business Associate Agreement covering that service is signed. Until then, keep PHI in your own deployment, or talk to sales.',
      },
      INSIDE,
      {
        title: 'Identifiers out before the model',
        body: 'Guard replaces identifiers such as social security numbers, emails and phone numbers with typed markers before a prompt reaches a model, and reads the reply on the way back.',
      },
    ],
  },
  {
    slug: 'law',
    kind: 'industry',
    name: phrase('Law'),
    hint: 'Review, research and drafting, kept confidential.',
    title: 'Hanzo for legal teams',
    lede: 'Contract review, research and first drafts, with every answer tied to the clause or source it came from — and client content kept out of model training by default.',
    work: [
      {
        title: 'Contract review at volume',
        body: 'Read a stack of agreements against your playbook. For each one, get the clauses that deviate and the words that make them deviate.',
      },
      {
        title: 'Research with citations',
        body: 'Search your precedents and the public record in one query. Answers cite the passage they rest on, so checking is reading, not re-researching.',
      },
      {
        title: 'Drafts from your own templates',
        body: 'Render first drafts from your templates and precedents, then send the final for signature from the same account.',
      },
      {
        title: 'A data room for the deal',
        body: 'Share documents with the other side under access controls, and see what was opened and when.',
      },
      {
        title: 'What the file said, on any date',
        body: 'The memory graph never overwrites. It keeps what was asserted, by whom and when, so you can read the matter as it stood on the day it mattered.',
      },
    ],
    products: ['search', 'memory', 'dataroom', 'sign', 'bot', 'enterprise'],
    trust: [
      UNTRAINED,
      {
        title: 'You choose the model',
        body: 'Name a specific model and the request goes to that model rather than through the router. The subprocessor register lists the providers a request can reach.',
      },
      APART,
      INSIDE,
    ],
  },
  {
    slug: 'retail',
    kind: 'industry',
    name: phrase('Retail'),
    hint: 'Catalog, storefront, support and every change measured.',
    title: 'Hanzo for retail',
    lede: 'Write the catalog, run the storefront, answer customers and measure every change — with agents doing the repetitive part and one platform under all of it.',
    work: [
      {
        title: 'A catalog that writes itself',
        body: 'Generate product copy and imagery from the specs and a few photos, in your voice and your look, and review it before it goes live.',
      },
      {
        title: 'Search that understands shoppers',
        body: 'Shoppers type what they mean. Keyword and vector search run in one request, so the exact item and the near misses come back together.',
      },
      {
        title: 'Commerce behind any front end',
        body: 'A headless API for the catalog, cart, checkout and orders, with payments routed across processors. Already on Shopify, WooCommerce or Square? Workflows connect to them.',
      },
      {
        title: 'Support that knows the order',
        body: 'A support agent answers order questions from your order data and hands off to a person with the history attached. Zendesk, Intercom and Freshdesk connect through workflows.',
      },
      {
        title: 'Test every change',
        body: 'Roll a change out to a share of shoppers behind a flag, attach a metric, and keep it or kill it on the result.',
      },
    ],
    products: ['commerce', 'payments', 'search', 'studio', 'insights', 'auto'],
  },
  {
    slug: 'government',
    kind: 'industry',
    name: phrase('Government'),
    hint: 'Inside your boundary, on software you can inspect.',
    title: 'Hanzo for government',
    lede: 'Run the whole platform inside your own boundary — on-premises or air-gapped, on open-source software your team can read — and put agents to work on casework, records and requests.',
    work: [
      {
        title: 'Casework, drafted',
        body: 'An agent gathers the file, summarizes the history and drafts the response for a caseworker to review and send.',
      },
      {
        title: 'Records you can search',
        body: 'Push the archive once and search it by phrase or by meaning, with every result pointing to its document.',
      },
      {
        title: 'Requests routed, not queued',
        body: 'Workflows read incoming requests, sort them and route each to the right office, with every step on the record.',
      },
      {
        title: 'Automation without an API',
        body: 'An agent drives legacy systems that have only a screen, by screenshot, mouse and keyboard, so modernization does not wait on a rewrite.',
      },
    ],
    products: ['enterprise', 'search', 'auto', 'computer', 'iam', 'zen'],
    trust: [
      {
        title: 'Inside your boundary',
        body: 'The platform is open source and deploys on your own hardware or cloud, air-gapped if required, so it runs under your controls rather than as a service reached over the internet.',
      },
      {
        title: 'Identity from your directory',
        body: 'Staff sign in through your identity provider over OIDC, and SCIM creates and removes their accounts from your directory.',
      },
      TRAIL,
      {
        title: 'Keys and signatures',
        body: 'Secrets are held per organization in KMS. Tokens verify against a closed list of algorithms that includes the post-quantum ML-DSA-65.',
      },
    ],
  },
  {
    slug: 'education',
    kind: 'industry',
    name: phrase('Education'),
    hint: 'Tutors, teaching tools and research compute.',
    title: 'Hanzo for education',
    lede: 'Give students a tutor that explains instead of answering, give teachers their evenings back, and give researchers compute billed by the second.',
    work: [
      {
        title: 'A tutor that teaches',
        body: 'Write the instructions once — explain, ask, never hand over the answer — and every student gets the same patient tutor, starting on Hanzo’s free models.',
      },
      {
        title: 'Course material, searchable',
        body: 'Put the syllabus, the readings and past questions in one index. Students ask in their own words and get the passage that answers them.',
      },
      {
        title: 'The class app, from a sentence',
        body: 'A teacher describes the quiz, the sign-up sheet or the lab tracker, and Hanzo App ships it with sign-in and a database.',
      },
      {
        title: 'Research compute that sleeps',
        body: 'Sandboxes and machines metered by the second, and nothing billed while they are paused — so a lab pays for the experiment, not the idle weekend.',
      },
      {
        title: 'Open models to study',
        body: 'Zen weights are open. Download them, run them on university hardware, and take them apart.',
      },
    ],
    products: ['app', 'search', 'zen', 'machines', 'team', 'models'],
    trust: [
      {
        title: 'Student records by agreement',
        body: 'Student education records go through Hanzo’s service only under separate written terms. Or run the platform on your own campus infrastructure.',
      },
      UNTRAINED,
    ],
  },

  /* ── Use cases ─────────────────────────────────────────────────────────── */
  {
    slug: 'content-creation',
    kind: 'usecase',
    name: phrase('Content creation'),
    hint: 'Words, images, video and voice from one account.',
    title: 'Hanzo for content creation',
    lede: 'Write, illustrate, narrate and publish from one account — and pay for a render once it finishes, at what it actually cost. A job that fails is not billed.',
    work: [
      {
        title: 'Writing with the right model',
        body: 'Enso picks the model for each request — a fast one for variants, a strong one for the long piece — or you name the one you want.',
      },
      {
        title: 'Images, video and 3D in a graph',
        body: 'Studio wires generation models into a node graph. Keep the graph, and the tenth asset matches the first.',
      },
      {
        title: 'Voice both ways',
        body: 'Text to speech for narration and speech to text for transcripts, on the same key as everything else.',
      },
      {
        title: 'Sources you can check',
        body: 'Read reference pages as clean text and keep them searchable, so every claim in the draft traces back to something.',
      },
      {
        title: 'Publish where the audience is',
        body: 'Workflows post to the social channels and email tools you already use, on your schedule.',
      },
    ],
    products: ['studio', 'enso', 'models', 'crawl', 'auto', 'connectors'],
  },
  {
    slug: 'research',
    kind: 'usecase',
    name: phrase('Research'),
    hint: 'Read everything, cite everything, remember what was true.',
    title: 'Hanzo for research',
    lede: 'Agents that search the web and your own corpus, read the sources in full, and write answers that cite them — on a memory that knows what was true and when.',
    work: [
      {
        title: 'Search, then read',
        body: 'Web search and page fetch are tools an agent calls step by step, billed per call. A fetch the domain policy refuses is stopped before the request and costs nothing.',
      },
      {
        title: 'Your corpus and the web together',
        body: 'Push your papers, notes and datasets once. Hybrid search finds the exact phrase and the related idea in one request.',
      },
      {
        title: 'Answers that cite',
        body: 'The memory graph answers from the assertions it holds and cites each one — and can answer as of any date, so a past conclusion can be reproduced exactly.',
      },
      {
        title: 'Run the analysis',
        body: 'Lease a sandbox or a GPU machine for the experiment, run it, and keep the output beside the question it answers.',
      },
      {
        title: 'Measure the method',
        body: 'Evals, datasets and experiments live in the same account, so a new prompt or a new model is a scored comparison, not a feeling.',
      },
    ],
    products: ['search', 'crawl', 'memory', 'machines', 'evals', 'models'],
  },
  {
    slug: 'agents',
    kind: 'usecase',
    name: phrase('Agents'),
    hint: 'Workers you define once, budget, and audit.',
    title: 'Hanzo for AI agents',
    lede: 'Define an agent once — model, instructions, tools and a budget — run it by name from anywhere, and read back every step it took.',
    work: [
      {
        title: 'Define once, run by name',
        body: 'An agent lives in the organization, not in a script. Call it from the API, the CLI, a workflow or chat; each run is recorded with its input, output, model and duration.',
      },
      {
        title: 'A budget it cannot pass',
        body: 'Every session carries a cap in micro-dollars. Raise it, lower it or remove it, and read what each agent has spent.',
      },
      {
        title: 'Every operation is a tool',
        body: 'Each subsystem’s operations are exposed over MCP, so an agent reaches the same surface a person does — under the grants its credential carries, and no more.',
      },
      {
        title: 'A computer when it needs one',
        body: 'The agent leases a sandbox, runs commands, drives a desktop or your signed-in browser, and gives the machine back.',
      },
      {
        title: 'Started by events',
        body: 'Fire a run from a webhook, a schedule or a message, and let a durable workflow carry it through restarts.',
      },
    ],
    products: ['agents', 'bot', 'mcp', 'sdk', 'auto', 'computer'],
    trust: [
      {
        title: 'Credentials narrowed to the job',
        body: 'Access is a grant at a path — organization, workspace, project — and a credential handed to an agent can be narrowed to exactly what it needs.',
      },
      TRAIL,
    ],
  },

  /* ── Reserved tier ─────────────────────────────────────────────────────── */
  {
    slug: 'reserved',
    kind: 'reserved',
    name: phrase('Reserved tier'),
    hint: 'Dedicated capacity, sized to your load.',
    title: 'Hanzo Reserved tier',
    lede: 'Capacity set aside for your organization — dedicated compute and inference for production traffic, or the whole stack on hardware you own — on an agreement sized to your load.',
    work: [
      {
        title: 'A dedicated compute cluster',
        body: 'GPU and CPU capacity held for your organization rather than drawn from the shared pool, so your traffic does not queue behind anyone else’s.',
      },
      {
        title: 'Your models, hosted',
        body: 'Train and serve your own models on that capacity, beside the catalog, through the same API and the same key.',
      },
      {
        title: 'Pay less for what can wait',
        body: 'A request can say how soon it needs its answer, and one that can wait is billed at a lower tariff. Reserved capacity carries the traffic that cannot.',
      },
      {
        title: 'On your own hardware',
        body: 'Run the same open-source stack on-premises or air-gapped, with Zen weights served by Hanzo Engine. Moving between our cloud and yours is a deployment decision, not a migration.',
      },
      {
        title: 'A custom SLA and people to call',
        body: 'The agreement carries a custom SLA, white-glove onboarding and 24/7 access to the engineers who run the platform.',
      },
    ],
    products: ['gpus', 'machines', 'engine', 'enso', 'zen', 'enterprise'],
    rates: true,
  },
]

/** The solution at a slug. */
export const solution = (slug: string): Solution | undefined => SOLUTIONS.find((s) => s.slug === slug)

/** Its address. */
export const href = (s: Solution) => `${INDEX}/${s.slug}`

/** The solutions of one kind, in order. */
export const ofKind = (kind: Kind): Solution[] => SOLUTIONS.filter((s) => s.kind === kind)