Agentic Commerce

Zurich Hyper Challenge 2026 prototype by Good Boys.

This monorepo explores what insurance commerce looks like when customers stop starting on insurer websites and instead start with AI agents. The core idea is a Zurich agent-ready insurance layer: one controlled interface that ChatGPT, video agents, personal assistants, and future AI channels can use to discover, quote, explain, apply, and reach a bind-ready pet insurance journey.

• Demo video: hyperchallenge-zurich-insurance_agentic-commerce_good-boys.mp4
• Video-agent prototype: video-agent-amber.vercel.app
• ChatGPT app prototype: chatgpt-insurance-app.vercel.app
• Repository: ralfboltshauser/agentic-commerce

Prototype Screens

GEO Scanner

The GEO scanner tests whether AI assistants can find, rank, and recommend Zurich pet insurance when a buyer starts with prompts such as "dog insurance switzerland" instead of visiting an insurer website directly.

The strategic reason is top-of-funnel shift. More discovery traffic will move from search-result pages into generated AI answers. Before Zurich can improve that surface, it needs a repeatable benchmark: where does Zurich appear, where is it absent, which competitors are being recommended, and which sources are being cited?

Video-Agent Funnel

The video-agent surface shows a Zurich adviser-like interface that can guide a customer through pet insurance discovery, quote generation, plan explanation, and a bind-ready application step while keeping sensitive data in a controlled form flow.

ChatGPT / MCP Journey

The ChatGPT app exposes Zurich pet insurance as MCP tools plus an embedded journey widget. A customer can ask for insurance in natural language, while the Zurich agent resolves missing fields, quotes plans, and drives the bind-ready application path.

What We Built

This project has four connected tracks:

Track	Purpose	Location
GEO scanner	Local AI visibility scanner for Zurich pet insurance prompts and competitors	apps/geo-scanner
ChatGPT app	MCP tools and widget for a ChatGPT-native quote-to-application journey	apps/chatgpt-app
Video agent	Standalone voice/video funnel with REST tool webhooks, session state, and a full-screen Zurich policy workspace	apps/video-agent
After-bind office	Hardened HTTP/NATS gateway for post-bind service and claims routing across role agents	after-bind-agent

The pre-bind journeys are bind-ready. They collect the required context, create or update the application path, and stop behind explicit consent and compliance controls instead of allowing an uncontrolled production bind.

Why It Is Built This Way

The challenge was not to build another chatbot. It was to make Zurich machine-readable, quotable, and actionable in the personal-agent era. That led to three design choices.

First, AI channels are kept thin. ChatGPT, the video agent, and future assistants should not own insurance logic. They call structured tools and render the result in the right interface.

Second, insurance capabilities are separated from provider details. Shared quote, qualification, and journey logic lives in insurance-core and insurance-domain; Petolo-specific paths, headers, DTOs, retries, and credentials live in petolo-adapter.

Third, control is part of the product. API keys stay server-side, voice qualification blocks personal/payment data, consent is required before sensitive actions, and the after-bind gateway derives customer scope from signed bearer tokens rather than trusting request bodies.

Architecture

flowchart LR
  User["Customer or customer agent"]
  ChatGPT["ChatGPT / MCP app"]
  Video["Video-agent funnel"]
  Future["Future personal agents"]
  Access["Zurich agent-ready access layer\nMCP + REST tools"]
  Core["insurance-core\nquote + qualification use cases"]
  Domain["insurance-domain\nschemas + journey phases"]
  Petolo["petolo-adapter\npolicies, breeds, prices, leads"]
  Security["security + analytics\nredaction, auth, consent, events"]
  Office["after-bind service office\nExpress + NATS + role agents"]
  Api["Petolo beta APIs"]

  User --> ChatGPT
  User --> Video
  User --> Future
  ChatGPT --> Access
  Video --> Access
  Future --> Access
  Access --> Core
  Core --> Domain
  Core --> Petolo
  Access --> Security
  Petolo --> Api
  Access --> Office

Loading

Core Capabilities

• Research Zurich pet insurance products and plan tiers.
• Resolve dog/cat breeds through Petolo.
• Generate Petolo-backed quote options.
• Explain tariff differences in plain language.
• Create and update pet insurance leads.
• Drive a bind-ready application/signature step behind consent.
• Expose machine-callable interfaces through MCP and REST.
• Scan generative-engine visibility for Zurich/Petolo against Swiss pet insurance competitors.
• Route post-bind service cases through a scoped multi-agent office.

Monorepo Layout

agentic-commerce/
  apps/
    chatgpt-app/        # ChatGPT Apps SDK / MCP widget
    geo-scanner/        # Local GEO visibility scanner for AI buyer prompts
    video-agent/        # Video-agent funnel and REST tools
  packages/
    insurance-core/     # Shared quote and qualification use cases
    insurance-domain/   # Zod schemas and journey/domain types
    petolo-adapter/     # Server-side Petolo API adapter
    analytics/          # Redacted journey events and tracker interface
    security/           # Redaction, idempotency, signatures, CSRF, rate limits
    ui/                 # Small shared React component package
  after-bind-agent/     # Express/NATS post-bind service gateway

Apps

@agentic-commerce/geo-scanner

The GEO scanner is a local terminal tool for generative engine optimization visibility. It measures whether Zurich Insurance, including Zurich, Zuerich, Zurich Schweiz, and Petolo by Zurich variants, appears when AI assistants answer Swiss pet-insurance buyer prompts.

Run it from the repository root:

pnpm geo:scan -- "dog insurance switzerland"

The scanner expands the seed query into buyer-intent prompts, gathers live web evidence when EXA_API_KEY is available, evaluates the prompts through Vercel AI SDK AI Gateway models, and prints terminal tables for provider scores, Zurich's rank, query-level winners, engine-level differences, and competitors to beat. It writes no report files into the repository.

This is the benchmark layer, not the content layer. Winning GEO later is similar to SEO: Zurich needs relevant, specific, citeable pages that answer the buyer questions AI systems are trying to resolve. This prototype focuses on measuring the gap first.

@agentic-commerce/chatgpt-app

The ChatGPT app exposes Zurich pet insurance through MCP tools:

• research_pet_insurance
• get_pet_quote
• start_or_update_application
• bind_pet_insurance

The widget at /widgets/journey renders the quote, application, signature, and confirmation states inside ChatGPT.

@agentic-commerce/video-agent

The video-agent app exposes REST tool calls for an external voice/video agent:

• start_application
• search_breeds
• update_qualification
• generate_quote_options
• show_quote_comparison
• answer_coverage_question
• select_policy
• prefill_application_demo
• show_signature_step
• mark_contract_ready

The browser UI opens a full-screen Zurich policy workspace from session state and UI events.

after-bind-agent

The post-bind gateway is a hardened service-office prototype:

• Production case API: POST /insurance/cases
• Signed bearer-token scope for tenant/customer identity
• Customer-scoped NATS subjects
• Role agents for secretary, claims, customer care, satisfaction review, and fulfilment
• Demo/debug/internal routes disabled by default

Setup

pnpm install

The apps need Petolo credentials for live API behavior. Start from each app's .env.example.

cp apps/chatgpt-app/.env.example apps/chatgpt-app/.env.local
cp apps/video-agent/.env.example apps/video-agent/.env.local

Common environment variables:

PETOLO_API_BASE_URL=https://beta.dentolo-test.de
PETOLO_API_KEY=<hackathon-api-key>
PETOLO_LOCALE=de
AGENT_WEBHOOK_SECRET=<shared-secret-for-video-agent-tools>

The GEO scanner uses AI Gateway and optional Exa search credentials. Keep these in a local ignored env file such as .env.local.

AI_GATEWAY_API_KEY=
EXA_API_KEY=

Running Locally

Run both Next.js apps through Turbo:

pnpm dev

Run one app:

pnpm --filter @agentic-commerce/chatgpt-app dev
pnpm --filter @agentic-commerce/video-agent dev

Run the GEO scanner:

pnpm geo:scan -- "dog insurance switzerland"

Run the after-bind gateway stack:

cd after-bind-agent
docker compose up -d --build

Operational notes for the gateway are in after-bind-agent/COMMANDS.md.

Verification

These are the main checks used during the hackathon submission:

pnpm check-types
pnpm lint
pnpm build
pnpm --filter @agentic-commerce/video-agent test
npm --prefix after-bind-agent/gateway test
VERIFY_BASE_URL=https://video-agent-amber.vercel.app pnpm --filter @agentic-commerce/video-agent verify:production
pnpm --filter @agentic-commerce/chatgpt-app test:production

The production video-agent verifier covers homepage load, session creation, application start, breed search, qualification update, quote generation, quote comparison, coverage explanation, policy selection, PII blocking in the voice path, consent-gated demo prefill, signature step, bind-ready contract state, and disabled test routes.

Security And Control Model

The prototype separates low-risk quote qualification from high-risk personal-data handling.

• Pet details can be collected through agent tools.
• Personal and payment data are blocked in the voice qualification path.
• Sensitive details are entered through the application form.
• Petolo API keys stay server-side.
• Video-agent tools can require a webhook secret.
• Analytics metadata is redacted.
• After-bind customer scope comes from signed bearer tokens, not request JSON.
• Demo, debug, office, SSE, and internal-state routes are disabled unless explicitly enabled.

Team

Good Boys:

• Ralf Boltshauser, ralf@boltshauser.com
• Marco Pagano, marcopagano2003@hotmail.com
• Samuel Huber, samuel@dtech.vision