hanzo.ai/app/(marketing)/agents/view.tsx

'use client'

import type { ReactNode } from 'react'
import {
  Bot,
  Cloud,
  Code2,
  Workflow,
  Plug,
  BrainCircuit,
  LineChart,
  ShieldCheck,
  Boxes,
  Network,
  Rocket,
} from 'lucide-react'
import { ProductLanding } from '@/components/product/ProductLanding'
import { ProductFooter } from '@/components/products/ProductFooter'
import { Spare } from '@/components/type'
import { useI18n } from '@hanzo/i18n/react'

const DOCS = 'https://docs.hanzo.ai/docs/openapi/agents/'
const GITHUB = 'https://github.com/hanzoai'
const CONSOLE = 'https://platform.hanzo.ai'

export default function AgentsPage({ source }: { source: ReactNode }) {
  const { t } = useI18n()
  return (
    <>
      <ProductLanding
        badge="Hanzo Agents · Python SDK"
        badgeIcon={Bot}
        title={t('A Python SDK for agents that work together')}
        lede={<>{t('An agent is a model, a set of instructions, and the tools it may call.')}<Spare>{' '}{t('A network is several of them behind a router that decides which one gets the turn. Both are a few lines.')}</Spare></>}
        ctas={[
          { label: t('Read the docs'), href: DOCS, icon: Rocket },
          { label: t('View on GitHub'), href: GITHUB },
        ]}
        note={{ icon: Cloud, text: t('Open source, MIT. {install}. Works against any endpoint that speaks the Chat Completions format, so it runs on Hanzo or on your own serving stack.', { install: 'pip install hanzo-agent' }) }}
        surface="agents"
        availableThrough={['Python', t('MCP tools'), 'Hanzo Cloud']}
        what={{
          eyebrow: t('What is Hanzo Agents'),
          title: t('One agent, or several with a router between them'),
          sub: t('The hard part of multi-agent work is not the prompting. It is deciding who answers, keeping what they learn where the next one can read it, and being able to see afterwards what actually ran.'),
          pillars: [
            {
              icon: Code2,
              title: t('Agents'),
              body: t('{agent} and {run}. The result carries {output} plus every step it took to get there.', { agent: 'Agent(name, instructions, tools=[...])', run: 'Runner.run_sync(agent, "…")', output: 'final_output' }),
            },
            {
              icon: Workflow,
              title: t('Networks'),
              body: t('{network} puts specialists behind one call. Route on meaning, on rules you write, or by load — and swap the router without touching the agents.', { network: 'create_network(agents=[researcher, writer], router=SemanticRouter())' }),
            },
            {
              icon: Plug,
              title: t('Tools'),
              body: t('A tool is a Python function with a signature. Every Hanzo MCP tool is one too, so an agent gets a shell, a filesystem, a code index and HTTP without you writing wrappers for them.'),
            },
          ],
        }}
        code={{
          head: { eyebrow: t('Get started'), title: t('Two agents and a router') },
          lang: 'python',
          source,
          ctas: [
            { label: t('Read the docs'), href: DOCS, icon: Rocket },
            { label: t('View on GitHub'), href: GITHUB },
          ],
        }}
        features={{
          eyebrow: t('What comes with it'),
          title: t('The parts you would otherwise write yourself'),
          items: [
            { icon: Network, title: t('Routing you can choose'), body: t('{router} reads the request and picks. Rule-based routing does what you say. Load-balanced routing spreads turns across equals. Same network object either way.', { router: 'SemanticRouter' }) },
            { icon: Workflow, title: t('Workflows, not just chat'), body: t('Steps that run in parallel, branch on a condition, or loop until something holds — for the work where the order matters and a prompt cannot express it.') },
            { icon: Plug, title: t('Shared state'), body: t('Agents in a network read and write one state object, so the writer sees what the researcher found without you pasting it into the next prompt.') },
            { icon: BrainCircuit, title: t('Memory with retrieval'), body: t('A store, a retriever, and vector search over both, so an agent recalls the relevant part of a long history instead of replaying all of it.') },
            { icon: LineChart, title: t('Tracing'), body: t('Spans and traces around every model call, tool call and handoff, through a processor interface you can point at your own collector.') },
            { icon: ShieldCheck, title: t('Extras you opt into'), body: t('{tee} adds attestation for confidential runs. {web3} adds wallets and on-chain identity. {cli} adds the command line. Nothing you skip is loaded.', { tee: 'pip install "hanzo-agent[tee]"', web3: '[web3]', cli: '[cli]' }) },
          ],
        }}
        finalCta={{
          icon: Boxes,
          title: t('Write the first one'),
          sub: t('{install}, give it instructions and a tool, and run it.', { install: 'pip install hanzo-agent' }),
          buttons: [
            { label: t('Deploy on Hanzo Cloud'), href: CONSOLE },
            { label: 'GitHub', href: GITHUB },
          ],
        }}
      />
      <ProductFooter slug="agents" name="Agents" />
    </>
  )
}