const { useEffect, useRef, useState } = React; // ---------- Tiny icon set (inline SVG, hairline, matches type weight) ---------- const I = { arrow: (p) => ( ), spark: (p) => ( ), channels: (p) => ( ), plug: (p) => ( ), gauge: (p) => ( ), pilot: (p) => ( ), check: (p) => ( ), alert: (p) => ( ), cycle: (p) => ( ), doc: (p) => ( ), shield: (p) => ( ), search: (p) => ( ), }; // ---------- Reveal-on-scroll wrapper ---------- function Reveal({ children, className = "", delay = 0 }) { return
{children}
; } // ---------- Top nav ---------- function Nav() { return (
GPTFrame v0 · PILOT Discuss a pilot
); } function Logo() { // Minimal "frame" mark: square bracket framing a node return ( ); } // ---------- Hero ---------- function Hero() { return (
Assistant infrastructure / Multi-channel · Model-agnostic · Eval-first

You focus on the assistant.
We handle the deployment layer .

GPTFrame helps teams deploy custom AI assistants into the channels their audiences already use — with model flexibility, operational support, and evaluation loops that show what works, what fails, and what to improve next.

{[ ["WhatsApp · Telegram · Web · Slack", "Channels"], ["OpenAI · Claude · Gemini · OpenRouter", "Models"], ["Review · Detect · Iterate · Audit", "Evaluation"], ["One assistant · One audience · One channel", "Pilot"], ].map(([v, k]) => (
{k}
{v}
))}
); } // ---------- Architecture diagram ---------- function Architecture() { // Three-column diagram: ASSISTANT -> GPTFRAME -> CHANNELS, with animated wires. const channels = [ { name: "WhatsApp", note: "1:1 + groups" }, { name: "Telegram", note: "1:1 + groups" }, { name: "Web chat", note: "embedded" }, { name: "Slack", note: "workspace" }, { name: "Custom", note: "via API" }, ]; const sources = [ { name: "System prompt", note: "behavior, tone" }, { name: "Knowledge files", note: "RAG inputs" }, { name: "Model setup", note: "your provider or agreed pilot usage" }, { name: "Guardrails", note: "safe limits" }, ]; return (
The system

Assistant → GPTFrame → wherever your users are.

GPTFrame sits between your assistant and the real world: channels, model providers, hosting, routing, operations, and evaluation.

Diagram · simplified
); } function DiagramFrame({ sources, channels }) { return (
{/* Mono caption bar */}
msg.flow / inbound + outbound
TLS · QUEUE · ROUTER · EVAL
{/* ASSISTANT column */} {sources.map((s) => ( ))} {/* CENTER: GPTFrame node */}
{/* CHANNELS column */} {channels.map((c) => ( ))}
{/* Bottom indicator strip */}
{[ ["Inbound", "encrypt → queue → route"], ["Model call", "chosen provider setup"], ["Outbound", "channel-specific render"], ["Usage signals", "reviewed for improvement"], ].map(([k, v]) => (
{k}
{v}
))}
); } function DiagColumn({ title, subtitle, align = "left", children }) { return (
{title}
{subtitle}
{children}
); } function DiagItem({ label, note, side }) { return (
{label}
{note}
); } function CenterNode() { return (
GPTFRAME · CORE
Routing, hosting,
operations & evaluation
{[0,1,2].map(i => ( ))}
); } function Wires({ direction }) { // Animated dashed wires fanning from center node toward column. const isLeft = direction === 'left'; const offsets = [-60, -30, 0, 30, 60]; return ( {offsets.map((o, i) => { // All flow left → right on screen, regardless of side. // Left side: y spreads on the column (left), converges at center (right) // Right side: y is centered at the center (left), spreads at channels (right) const x1 = 0, x2 = 60; const y1 = isLeft ? 100 + o * 1.4 : 100; const y2 = isLeft ? 100 : 100 + o * 1.4; return ( ); })} ); } // ---------- Wedge / "you focus / we handle" ---------- function Wedge() { const yours = ["Assistant logic", "Knowledge & data", "Brand voice & policy"]; const ours = [ "Channel integration", "Model & API routing", "Hosting & operation", "Evaluation & iteration", "Guardrail audit", ]; return (
The wedge

The hard part is not imagining the assistant. It is getting it used.

Most teams can describe the assistant they want. The friction begins when that assistant needs to run in a real channel, with real users, real constraints, and a way to know whether it is actually helping.

GPTFrame handles that deployment and evaluation layer — so the team can focus on the assistant's value, not the plumbing.

); } function Stack({ title, items, accent }) { return (
{title}
    {items.map((i) => (
  • {i}
    • ))}
); } // ---------- Pillars ---------- function Pillars() { const items = [ { icon: I.channels, kicker: "01", title: "Multi-channel deployment", body: "Deploy one assistant across the channels your audience already uses — WhatsApp, Telegram, web chat, Slack, or a custom interface — without re-implementing each integration.", bullet: ["1:1 + group conversations", "Channel-aware rendering", "Add channels as the pilot proves out"], }, { icon: I.plug, kicker: "02", title: "Model-agnostic backend", body: "Bring the model and API account that fits the use case. Optimize for quality, cost, privacy, or latency without rebuilding the assistant.", bullet: ["OpenAI · Claude · Gemini · OpenRouter", "Use your own provider account, or agree pilot usage billing", "Swap models without rewiring"], }, { icon: I.gauge, kicker: "03", title: "Evaluation-first operation", body: "Every assistant should be measured, reviewed, and improved. Launch is the start of the loop, not the end.", bullet: ["Conversation review", "Failure pattern detection", "Prompt & version iteration"], }, { icon: I.pilot, kicker: "04", title: "Pilot-first validation", body: "Start with one assistant, one audience, one channel, and explicit success criteria. The goal is not to launch big — it is to learn fast.", bullet: ["~1 week to first live setup", "Defined exit criteria", "No long-term lock-in"], }, ]; return (
Four pillars

A small, opinionated stack — built around the things that actually break.

{items.map((p, idx) => (
PILLAR · {p.kicker}

{p.title}

{p.body}

    {p.bullet.map((b) => (
  • {b}
    • ))}
))}
); } // ---------- Channels & Models ---------- function ChannelsModels() { const channels = ["WhatsApp", "Telegram", "Web chat", "Slack", "Custom channels"]; const models = ["OpenAI", "Claude", "Gemini", "OpenRouter", "Client-owned APIs"]; return (
Supported channels

Start with one. Expand when the assistant proves value.

{channels.map((c) => {c})}

Some channels rely on third-party platforms whose policies, rate-limits, and availability can change. We flag those before deployment.

Model flexibility

Avoid locking the assistant to a single vendor.

{models.map((m) => {m})}

Use your own provider account, or agree pilot usage billing. We don't proxy keys we don't need.

); } // ---------- Evaluation loop ---------- function EvaluationLoop() { const nodes = [ { icon: I.search, label: "Observe", note: "Review real conversations" }, { icon: I.gauge, label: "Detect", note: "Find failure patterns" }, { icon: I.doc, label: "Iterate", note: "Revise prompt / version" }, { icon: I.shield, label: "Audit", note: "Re-check guardrails" }, ]; return (
Evaluation loop

Launch isn't the finish line.
It's where the work starts paying back.

We treat every deployed assistant as a learning system. Real conversations reveal whether users are getting value, where the assistant breaks down, which questions repeat, and what needs to change in the prompt, knowledge base, model, or guardrails.

{/* Center diagram */}
{/* Left column: two nodes */}
{/* Center "cycle" graphic */}
{/* Right column: two nodes */}
{/* Footer line */}
); } function LoopNode({ icon: Icon, label, note, step, right }) { return (
STEP · {step}
{label}
{note}
); } function LoopGraphic() { return (
Eval loop
continuous
); } function KV({ k, v }) { return (
{k}
{v}
); } // ---------- Pilot workflow ---------- function Pilot() { const steps = [ { n: "01", title: "Define the assistant", body: "Prompt, knowledge, model & API choice, channel, success criteria. We help shape the brief but the assistant is yours.", meta: "~2-3 working days", }, { n: "02", title: "Deploy to real users", body: "A live setup in the channel your audience already uses, with the model account you provide. 1:1 or group.", meta: "~1 week to live", }, { n: "03", title: "Evaluate & decide", body: "Review real conversations, surface failure patterns, tighten prompts, and decide what to expand, change, or shut down.", meta: "ongoing cadence", }, ]; return (
Pilot workflow

Start small enough to learn cheaply.
Expand only what's earned it.

{/* connector line */}
{steps.map((s, i) => (
{s.n}
{s.title}

{s.body}

{s.meta}
))}
); } // ---------- Responsible deployment ---------- function Responsible() { const items = [ { t: "Clients own the assistant", b: "Content, policy, and user-facing outcomes remain the client's responsibility. We can audit, but we don't underwrite.", }, { t: "Channels have limits we don't control", b: "Some channels rely on third-party platforms whose policies and availability change. We flag those constraints before deployment.", }, { t: "No magic, no oversold uptime", b: "We won't promise enterprise compliance, official platform partnerships, or guarantees we can't keep at this stage.", }, ]; return (
Responsible deployment

We'd rather be transparent than impressive.

{items.map((i) => (
{i.t}
{i.b}
))}
); } // ---------- CTA ---------- function CTA() { return (
Pilot enquiries

If you can build the assistant —
We make it run where your audience already is.

Tell us what assistant you want to deploy, who it is for, which channel matters first, and what would make the pilot worth continuing.

); } // ---------- Footer ---------- function Footer() { return (
GPTFrame © 2026 · Operated by Uri Grodzinski & Gal Efrati
multi-channel · model-agnostic · evaluation-first
); } // ---------- Fit Check ---------- function FitCheck() { const yes = [ "You already have a defined assistant use case", "Your audience already lives in a specific channel", "You want to test usage with real people", "You care about improving the assistant after launch", "You prefer a pilot before a big build", ]; const no = [ "You only have a vague AI idea", "You need a full product team replacement", "You need enterprise-grade SLA or formal compliance guarantees", "You want to avoid responsibility for assistant outputs", "You are not ready to define success criteria", ]; return (
Is this a fit?

GPTFrame works best when the use case is focused.
A short honesty check before you write to us.

Good fit
YES /
    {yes.map((t) => (
  • {t}
    • ))}
Probably not yet
/ NO
    {no.map((t) => (
  • {t}
    • ))}
); } // ---------- Pilot Enquiry Form ---------- const FORMSPREE_ENDPOINT = "https://formspree.io/f/xrejjvgr"; function PilotForm() { const [state, setState] = useState({ name: "", email: "", org: "", role: "", assistant: "", audience: "", repeated: "", today: "", painful: "", satisfied: "", urgent: "", channel: "", whyChannel: "", stage: "", help: [], modelConnect: "", modelHelp: [], pilotWorth: "", review: [], timeline: "", sensitive: "", pilotModel: [], }); const [sent, setSent] = useState(false); const [error, setError] = useState(null); const [submitting, setSubmitting] = useState(false); const set = (k, v) => setState((s) => ({ ...s, [k]: v })); const toggle = (k, v) => setState((s) => ({ ...s, [k]: s[k].includes(v) ? s[k].filter(x => x !== v) : [...s[k], v] })); const onSubmit = async (e) => { e.preventDefault(); // Honeypot — bots fill hidden _honey field; silently drop and pretend success. if (e.currentTarget.elements._honey && e.currentTarget.elements._honey.value) { setSent(true); return; } setError(null); setSubmitting(true); try { const payload = { ...state, // Flatten array fields for readable email help: state.help.join(", "), modelHelp: state.modelHelp.join(", "), review: state.review.join(", "), pilotModel: state.pilotModel.join(", "), // Tracking source: "site_v1", page: "gptframe_home", version: "v1", // Formspree subject line _subject: `GPTFrame pilot enquiry — ${state.name || state.email || "(unknown)"}`, }; const res = await fetch(FORMSPREE_ENDPOINT, { method: "POST", headers: { "Content-Type": "application/json", Accept: "application/json", }, body: JSON.stringify(payload), }); if (!res.ok) { const data = await res.json().catch(() => ({})); throw new Error(data?.error || "Bad response"); } setSent(true); } catch (err) { setError("Something went wrong. Please try again, or email us directly."); } finally { setSubmitting(false); } }; const channelOpts = ["WhatsApp","Telegram","Web chat","Slack","Other / not sure"]; const painfulOpts = [ "Mild annoyance", "Costs noticeable time every week", "Blocks users from getting help", "Creates operational / reputational risk", "Not sure yet", ]; const satisfiedOpts = [ "Works well", "Good enough for now", "Frustrating but usable", "Not working well", "There is no current solution", "Not sure yet", ]; const urgentOpts = ["Painful now", "Useful soon", "Exploring", "Just curious"]; const stageOpts = [ "We already have a working assistant / prompt", "We have a clear use case but need help shaping the assistant", "We only have an early idea", "We are evaluating options", ]; const helpOpts = [ "Deployment only — we already have the assistant logic", "Help shaping the assistant — prompt, files, guardrails", "Evaluation support — review real usage and improve the assistant", "Full package — from idea to deployed assistant", "Not sure yet", ]; const modelConnectOpts = [ "Our organization will provide and pay for its own API key", "We prefer GPTFrame to provide access during the pilot and bill us for usage", "Not sure yet", ]; const modelHelpOpts = [ "Yes, help us choose between OpenAI / Claude / Gemini / OpenRouter / other providers", "Yes, help us compare quality, cost, latency, or privacy tradeoffs", "No, we already know what we want to use", "Not sure yet", ]; const reviewOpts = [ "Whether users get useful answers", "Repeated unanswered questions", "Failure patterns", "Prompt / knowledge base improvements", "Guardrail or safety issues", "User drop-off or low engagement", "Not sure yet", ]; const timelineOpts = ["As soon as possible", "This month", "Next 1–2 months", "Exploring only"]; const pilotModelOpts = [ "Free exploratory call first", "One-time setup fee", "Monthly operation fee", "Usage-based pricing", "Paid evaluation / improvement reviews", "Custom build project", "Not ready to discuss budget yet", "Not sure yet", ]; return (
Pilot enquiry

Tell us enough to understand the assistant, the audience, and the deployment problem.

We are especially interested in focused pilots where there is already a real audience, a repeated question or workflow, and a channel where users already communicate.

Please do not include passwords, API keys, or confidential datasets in this form.
· manually reviewed
· not a service agreement
· typical reply within ~3 business days
{/* Honeypot — hidden from real users; bots fill it and get silently dropped */} {/* Hidden tracking inputs (mirrored in JSON payload as well) */} {sent ? (
Thanks — we'll be in touch.
We review pilot requests manually. A real human will reply.
) : (
set("name", e.target.value)}/> set("email", e.target.value)}/>
set("org", e.target.value)}/> set("role", e.target.value)}/>