OpenAI’s latest drop made one thing clear: the platform era is here. The ChatGPT Apps SDK (preview) lets you build apps that run inside ChatGPT, while AgentKit gives teams a stack for designing, evaluating, and deploying production-grade agents. Add GPT‑5 Pro in the API for heavy reasoning and Sora 2 for video (consumer app now, API later), and you’ve got a roadmap most software orgs can execute on starting this quarter.
Here’s the thing: this isn’t just “AI toys.” With 800M+ weekly ChatGPT users and a growing enterprise surface, these launches change distribution, onboarding, and customer support economics. If you’re a product leader or CTO, your job is to pick the right first app or agent, lock in governance, and ship something that creates compounding advantage—fast.
What shipped—and why it matters
On October 6, 2025, OpenAI announced four pillars that developers can actually act on:
1) ChatGPT Apps SDK (preview). Build app logic and interactive UIs that run directly in ChatGPT. Apps are invoked contextually by name or suggestion, and the SDK rides on the Model Context Protocol (MCP), an open standard for connecting tools and data.
2) AgentKit. A toolkit that includes Agent Builder (visual workflow canvas), ChatKit (embeddable chat UI components), updated Evals (datasets, trace grading, automated prompt optimization, third‑party model support), reinforcement fine‑tuning (RFT) options, and an admin-facing Connector Registry rolling out in beta.
3) GPT‑5 Pro in the API. Positioned for high‑accuracy, multi‑step reasoning. Pricing is steep versus mid‑tier models, so you’ll want usage caps, prompt caching, and batch jobs for cost control.
4) Sora 2. Live now as a consumer iOS app and on the web with staged rollout; API access is planned. It generates video with synchronized audio, improved physics and control—promising for creative tooling and marketing workflows once the API lands.
Two more context points leaders care about: OpenAI reports 4M+ developers building with their stack and API throughput measured in billions of tokens per minute. Translation: if your use case works, scale and distribution are unlikely to be your blockers—focus on UX, governance, and margins.
How the ChatGPT Apps SDK works (and where it fits)
Think of the ChatGPT Apps SDK as an in-chat runtime plus UI layer. You ship a small app definition that connects to your backend via MCP-defined tools, then expose an interactive surface right in ChatGPT. The user triggers your app—by name, by suggestion, or via ChatGPT’s guidance—stays in the chat, and completes tasks without context switching.
For product teams, the win is distribution and speed to value. “Install” friction drops to a consent screen; data permissions are front-and-center; zero-device fragmentation. The tradeoff: you live inside ChatGPT’s guardrails, review processes, and evolving policies.
Reference architecture: your first ChatGPT app
Here’s a pattern we’ve shipped successfully for clients building chat-native surfaces:
• Frontend surface: ChatGPT app UI built with the Apps SDK (forms, paginated lists, tappable cards) to execute key jobs-to-be-done: quote builder, project scoper, catalog browse-and-configure, or course recommender.
• App logic: MCP tools that call your APIs. Keep tools single-purpose: “create_quote,” “get_inventory,” “apply_coupon,” “book_time.” Tool design is your product contract—version it.
• Identity & consent: When the app first runs, ask the user to connect their account with granular scopes (order history read, write quote, schedule read). Log scopes and a signed policy snapshot to your audit store.
• Backend: Next.js, FastAPI, or Node/Express behind a thin gateway. Emit structured traces for each tool call with input/output JSON and latency metrics to your observability stack.
• Data layer: One connector per system of record (CRM, billing, inventory). Cache read-mostly endpoints aggressively; move bulk sync to background jobs.
• Evals loop: Curate 50–200 gold tasks that mirror your top flows. Run evals nightly against your latest prompts/tools and flag regressions before they reach users.
Want to see how we package chat UIs for product embeds, not just ChatGPT? Our engineering breakdown on building sales-grade chat in Next.js with ChatKit shows the frontend decisions that keep conversations converting.
OpenAI AgentKit in practice: shipping agents that behave
If the Apps SDK solves distribution, AgentKit solves reliability. Most “agents” fail in production because plans drift, tools misfire, and evals are ad hoc. AgentKit tackles those problems with versioned workflows, explicit connectors, and first‑class measurement.
Agent Builder. A visual canvas to compose multi-step logic: plan, retrieve, call tools, reflect, and report. You can start no‑code for speed, then export to code-first when flows stabilize.
ChatKit. Embeddable, brandable chat components to bring agent experiences into your product (web or mobile) without weeks of UI work.
Evals. Datasets, trace grading, and automatic prompt optimization. Treat this like unit tests for reasoning. Ship with a baseline eval set; expand it with real conversations weekly.
Reinforcement fine‑tuning (RFT). When you’ve plateaued on prompts, RFT teaches the model your definition of “good.” Start small—one task, clear rewards, strict guardrails—then expand.
The production checklist we use with clients
Use this to get from proof‑of‑concept to something you can trust at scale:
1) Define one job your agent must complete end‑to‑end (e.g., “qualify an inbound lead and schedule a demo”).
2) List tools the agent may call. Keep each tool atomic with crisp inputs/outputs and explicit timeouts.
3) Draft a plan schema (JSON) with steps, success criteria, and rollback. Persist every plan with a version and timestamps.
4) Cold evals first. Create 50 gold scenarios with expected outcomes. Lock them in a repo. Your CI should fail if eval accuracy dips.
5) Human-in-the-loop. Route high‑risk actions (refunds, contract changes) through approvals, with clear SLAs.
6) Guardrails. Enforce PII redaction, tool call budgets, and domain‑specific filters. Log every denied action and reason.
7) Observability. Trace every message, tool call, and state change. Build dashboards for success rate, replan rate, and cost per successful task.
8) Model budget. Cap max tokens per task, enable prompt caching where available, and offload bulk work to batch APIs overnight.
9) RFT last, not first. Only when prompts+evals stabilize and you know what “good” means.
10) Rollback ready. Keep last-known-good flows hot. If success rate drops, auto‑revert workflows and prompts.
11) Privacy reviews. Document data sources, retention, and scopes in a one‑pager any auditor can read.
12) Drills. Run weekly failure drills: kill a connector, inject a bad tool output, or simulate a rate-limit day.
Costs and capacity: a quick reality check
GPT‑5 Pro is priced for depth, not chatty banter. For planning, budget by jobs completed rather than conversations. A typical “qualify a lead + schedule” task might run 15–40K tokens round‑trip when you include context, tool responses, and summaries. At $15 per million input tokens and $120 per million output tokens, that task might cost a few cents to tens of cents depending on verbosity and retries. Use batch processing (often ~50% cheaper) for overnight enrichment or backfills. For lighter tasks, route to smaller models and reserve GPT‑5 Pro for the hard hops—planning, reconciliation, and disputes.
For the Apps SDK, costs sit mostly in your backend work (tool calls, DB hits) plus model traffic from ChatGPT to your tools. Build with paging, defer heavy work to background jobs, and measure cost per successful outcome (e.g., per quote generated) rather than cost per message.
What about Sora 2 for product teams?
Sora 2 is rolling out to consumers first—iOS and web—with an API on the roadmap. That means you can start planning creative and marketing workflows now, then flip over to API integration when it lands.
• Short‑form creative ideation. Generate first‑draft clips for campaigns, then hand off to editors. Track time saved, not just outputs.
• Programmatic product video. For marketplaces, prototype “SKU to 10s clip” flows. Add brand rules to prompts and keep a human sign‑off step.
• Support content. Snippets that demonstrate features or fixes, generated from docs plus product telemetry. Govern with strict safeguards around likeness and brand usage.
Once the API is available, you’ll want prompt templates, brand guardrails, and a review queue ready to go on day one.
People also ask
Is the ChatGPT Apps SDK a walled garden?
No. It’s built on MCP, an open standard for connecting tools and data. Your app logic lives in your code and your APIs. Distribution happens inside ChatGPT, but the underlying integrations are portable—and you can still ship your own web or mobile frontend alongside it.
Should we rebuild our existing chatbot on AgentKit?
Not automatically. If your bot does one narrow task well, keep it. Use AgentKit where you need planning, tool orchestration, measurement, and versioned workflows. A great pattern is: keep your current chat for FAQs; introduce an AgentKit flow for one revenue‑critical job (upsell, onboarding, dispute resolution) and expand from there.
How do we handle governance and privacy?
Use fine‑grained scopes at connection time, log a policy snapshot, and route sensitive actions through approval steps. Lean on the Connector Registry as it rolls out for centralized control of who can connect which data sources. Build evals for privacy too—flag accidental PII echoes and block tool calls that exceed scopes.
Let’s get practical: your 30‑60‑90 plan
Days 1–30
• Pick one job-to-be-done and write the acceptance test: “User can X in under Y minutes without leaving chat.”
• Build a minimal ChatGPT app: one list view, one detail view, one confirmation step.
• Add two tools only. Add consent scopes. Log everything.
• Create 50 eval tasks. Wire them into CI. Ship to a private internal cohort.
Days 31–60
• Add AgentKit for the complex path: planning + two tool calls + a fallback path.
• Introduce human approvals for risky actions and a rollback switch for prompts/workflows.
• Instrument cost and success metrics. Set budgets and alerts. Start RFT experiments only if evals plateau.
Days 61–90
• Expand tool coverage to your second system of record (e.g., billing).
• Mature your evals set to 200+ tasks with real user transcripts.
• Run weekly failure drills and harden your prompts with adversarial cases.
• Prep go‑to‑market: docs, in‑chat onboarding, and a crisp consent flow.
Where teams stumble (and how to avoid it)
• Too many tools. Ten tools means ten ways to derail. Start with two. Merge or delete ruthlessly.
• No versioning. Treat prompts, tools, and workflows like code. Version them and map regressions to specific changes.
• Eval theater. Bad evals create fake confidence. Your dataset must mirror production tasks and include negative cases.
• Token drift. Costs creep when you over‑stuff context. Trim inputs, summarize aggressively, and cap output length.
• UX ambiguity. Users need obvious next actions. In-chat UI should be opinionated: primary CTA, secondary exit, breadcrumbs.
Build vs. buy: when to call in help
If you’re missing either (a) eval expertise or (b) secure connector design, bring in a partner for a few sprints. You’ll save months of “unknown-unknowns” and avoid shipping something brittle. If you want a sense of our approach, browse our client case studies and our services for AI product delivery. We’ve also written about frontend speedups that pair well with agents, like Next.js caching strategies that cut deploy time.
What to do next
• Choose one high‑leverage workflow (support deflection, sales qualification, onboarding).
• Prototype a ChatGPT app with two tools and a minimal UI.
• Wrap it in AgentKit for planning + evals + guardrails.
• Instrument costs and success from day one. Batch the offline tasks.
• Plan for Sora 2 by drafting prompt templates and review workflows so you’re API‑ready.
• Ship to a narrow audience, measure, then widen.
We’re past the novelty phase. Apps bring users to your data and actions where they already live; agents close the loop with reliable execution. Pick one job, ship it well, and let the compound interest of faster cycles and better evals do the rest. If you want a sparring partner on architecture or go‑to‑market, reach out via our contact page—we’ll help you move from slideware to shipped.
