Tl;dr Understand what ChatKit is and where it fits in your tech stack. Learn why its frontend-only design limits scalability, and how C1 is the missing link connecting model reasoning directly to dynamic, interactive interfaces.

Set of chat-layer features ChatKit manages: prompts, input box, avatars, streaming messages, loading states, and memory

Building chat interfaces has always been the most dull and drab part of building AI apps. Managing message streams, system prompts, user avatars, and loading states feels repetitive, yet every team has had to reinvent that wheel. So when OpenAI launched ChatKit, it solved this very problem.

ChatKit gives developers a clean, front-end-first SDK that handles all those pieces out of the box. You can spin up a polished, professional looking chat interface that behaves predictably in minutes. Thus, making it ideal for testing models, building quick demos, or creating conversational tools where most interactions are just text going back and forth.

But that is also the limitation of ChatKit; it’s front-end only! It doesn’t manage state, handle backends, or coordinate tool calls. Once you step beyond text, you’re on your own again.

ChatKit’s frontend-only limitation and backend complexity

At best, ChatKit is the presentation layer, not the brain. It can render messages and stream responses, but can’t determine what those responses should be, how they connect to data, or what happens after a user submits input.

Need API data? Build your own backend. Want to call functions? Set up a server. Want charts or visualizations? Create custom components.

For small projects it’s a reasonable trade off. You get ease of use and flexibility, but as use cases grow, friction builds. When structured data is required or interfaces need real-time updates, complexity increases.

This is where ChatKit starts to feel like an incomplete solution. It handles the front end, not the full workflow leaving you to build the rest: backend context, API integration, state management, and UI adaptation.

How C1 Goes Beyond ChatKit

This is where C1 by Thesys comes in.

C1 is a Generative UI API that goes beyond text only interfaces and chatbots.

C1 lets your model respond with interactive UI components: charts, forms, cards, tables, sliders, and more. For example, when a model produces an analysis, C1 renders it as a live, live interactive interface instead of static text. When it suggests a form or workflow, users can act on it instantly. This transforms AI outputs from passive text-heavy responses into actionable interfaces.

And the best part? It doesn’t require a complex backend setup. C1 sits between your model and frontend, interpreting model output and turning it into interactive components on the fly. The result is an AI interface that adapts to each conversation without you writing any extra UI logic.

C1’s Integrated Approach to UI Generation

How C1 works with ChatKit to add model reasoning, integration layers, real-time UI updates, live components, & unified state

The traditional ChatKit setup involves three moving parts:

The frontend for display (ChatKit)
The backend for orchestration (custom server)
The model for reasoning (OpenAI API or others)

C1 merges those layers into one flow. The model sends structured output, and C1 automatically generates the corresponding UI. No middleware.

Because it implements the Generative UI principles, C1 understands both context and intent. It interprets model output as live components, not just formatted text. You can still integrate your existing chat interface, including ChatKit, but instead of rendering text bubbles, C1 renders real, interactive surfaces.

How ChatKit stacks up against C1

Here’s a quick side-by-side comparison to see how C1 goes one step further:

Feature	ChatKit	C1 by Thesys
Primary Purpose	Frontend SDK for chat UIs	Generative UI API for AI apps
Scope	UI only (no backend logic)	Full interaction layer between model and frontend
Model Output Handling	Displays plain text	Renders text and interactive UIs
Integration Needs	Requires custom backend for complex workflows	No backend setup needed — works directly with models
Example Output	Message bubbles	Charts, forms, tables, reports, live surfaces

Choosing Between ChatKit and C1

If your goal is to test models quickly or embed a simple chat experience into a web app, ChatKit is a great place to start. It’s fast, lightweight, and handles all the visual boilerplate for you.

But if you’re building something users can actually interact with, dashboards that update live, assistants that produce slides or reports, or AI tools that connect to your data, you’ll need C1. It eliminates the gap between model reasoning and user interaction.

ChatKit simplifies how developers build conversations.C1 by Thesys redefines what those conversations can do.

By letting your AI respond with interactive UI instead of text alone, it helps you build apps that feel more alive, contextual, and ready for real users.

C1 by Thesys integrates seamlessly with your AI stack, from popular LLMs like OpenAI, Anthropic, etc. to frameworks like Vercel AI SDK, CopilotKit, Mastra, LangChain, LangGraph, CrewAI, Autogen, and Streamlit, helping you build Generative UI experiences that work everywhere.

Explore how C1 by Thesys brings Generative UI to your AI apps, transforming static chat into adaptive, interactive experiences.

To make things easier, here are some quick answers to questions developers frequently ask about OpenAI ChatKit.

1. What is OpenAI ChatKit?
OpenAI ChatKit is a developer toolkit that simplifies building chat interfaces for AI apps. It manages conversation threads, messages, and chat UI elements, helping developers embed AI chat experiences without building them from scratch.

2. How is ChatKit different from the regular OpenAI API?
The OpenAI API handles model reasoning and responses, while ChatKit focuses on the frontend experience. ChatKit provides built-in tools for message display, conversation memory, and thread handling, making it easier to design chat interfaces around the API.

3. Can I use my own OpenAI API key with ChatKit?
Yes, ChatKit works with your own OpenAI API key. You can connect your model endpoint directly, manage authentication, and control API usage from your backend or app environment.

4. Is ChatKit free to use?
Yes, ChatKit is free and open source, but requests made through it still incur OpenAI API costs. Pricing depends on the model you connect, such as GPT-4 or GPT-4o.

5. What are the limitations of ChatKit?
ChatKit is a frontend-only SDK. It doesn’t handle backend logic, state management, or complex tool integrations. Developers need separate infrastructure for data workflows or interactive components.

Try C1 here

Related articles

May 2026 Security Incident

Why We're Open Sourcing OpenUI

AI Copilots: A Complete Guide to Intelligent Assistance

What Are AI Agents: Types, Capabilities, and Real-World Use

PowerPoint Automation Reimagined with C1 Artifacts API

The Future of AI Interfaces is Generative

MCP UI: Making AI Apps Interactive

What Is AG-UI and Why It Matters for AI-Native User Interfaces

How to design AI-Native Conversational Interfaces : From Templates to Generative UI

GPT 5 vs. GPT 4.1

How to Build Generative UI Applications

Implementing Generative Analytics with Thesys and MCP

Evolution of Analytics: From Static Dashboards to Generative UI

Why Generating Code for Generative UI is a bad idea

Building the First Generative UI API: Technical Architecture and Design Decisions Behind C1

How we evaluate LLMs for Generative UI

Generative UI vs Prompt to UI vs Prompt to Design

Generative UI: What It Is and Why It Matters