The ChatGPT Apps SDK made it possible to pair conversational tools with interactive experiences inside ChatGPT. A user can ask for information, inspect a result, and interact with a useful interface without treating every step as a separate website visit.
There is an important distinction for developers: exposing tools, building a visual interface, and operating an existing AI teammate are different jobs. This guide explains the first two, then shows where eesel CLI fits when your coding agent needs to work with a support teammate.
As checked on September 8, 2026, OpenAI’s current MCP and UI quickstart presents this pattern through plugins. It uses an MCP server for tools and an optional web component for ChatGPT. ChatGPT implements the open MCP Apps UI standard; a custom interface is not required for a tools-only experience.
What is the ChatGPT Apps SDK?
The Apps SDK connects application capabilities to a conversation. The model can call tools your server exposes, and the result can include an interactive component such as a list or form. That component is rendered in an iframe inside ChatGPT.
For example, a product-search tool could return matching items as structured data. An optional UI could display those items as selectable cards. The server still needs to retrieve accurate product data, validate requests, and enforce the user’s access. A conversational interface does not replace those responsibilities.
Current OpenAI documentation also distinguishes plugins that provide server-backed tools from plugins that only supply instructions and resources through skills. The server-backed pattern is the focus here because it is the part most relevant to business-system access.
The components: Protocol, server, and optional UI
MCP defines how the client accesses tools
The Model Context Protocol defines how an AI client discovers and calls external capabilities. Tools have names, descriptions, and input schemas. The model chooses a tool and supplies arguments; the server validates the request, performs the operation, and returns a result.
A protocol is not a security policy. If a tool retrieves private customer data or changes an order, the server must enforce authorization for that operation. Do not rely on a friendly description such as “only use this for the current customer” as the access control.
The server performs the work
The MCP server is the implementation behind those tools, not a separate third system alongside “MCP.” It may query a database, call an existing API, or operate a service. Its outputs should remain useful as text or structured content even when no custom UI is displayed.
For production servers, OpenAI’s documentation recommends a stable HTTPS endpoint using streamable HTTP. You own the business logic, hosting, and maintenance for a server you build. Existing service providers may instead supply their own endpoint.
This is also why an OpenAI API SDK and an MCP server SDK are not interchangeable. One wraps model API calls; the other helps implement the protocol your client uses to discover and invoke tools.
The UI helps the user act on results
An optional web component uses HTML, CSS, and JavaScript to present results inside ChatGPT. It can make a list easier to compare or a form easier to complete. OpenAI’s quickstart explicitly allows you to skip the component when tools alone are sufficient.
Choose the UI based on the user’s task. If the answer is a short status summary, structured tool output may be enough. If the user needs to compare options and make a selection, a visual component can earn its place.
Do not build a visual component merely because the SDK supports one. It introduces state, loading, error, and accessibility behavior that also needs testing.
Business uses and development responsibilities
A customer-facing app can help people discover products or interact with a service through ChatGPT. An internal tool can retrieve approved company information or support a repeatable work task. In both cases, define the expected result before choosing components.
For support, separate “give a customer an interface in ChatGPT” from “help a support teammate answer tickets in an existing helpdesk.” The former may justify an Apps SDK project. The latter can be served by a support-focused product, with developer access through its CLI or API.
Budget for hosting, authentication, testing, and ongoing maintenance. Check the relevant ChatGPT account and workspace requirements for your intended deployment rather than assuming every user needs a particular paid plan.
Commerce is a separate decision
OpenAI’s checkout documentation currently recommends external checkout for eligible physical goods. Embedded checkout with the ChatGPT payment sheet is available to select marketplace partners. The SDK alone does not establish that a particular product, payment flow, or revenue model will be approved.
That matters when evaluating a shopping app. A working product carousel is not a completed purchase flow: payment, fulfillment, refunds, and the applicable platform requirements still need an implementation.
Use eesel CLI to operate the teammate behind support
If your goal is to give a coding agent access to support operations, you may not need to build a new ChatGPT interface. eesel CLI lets a person, script, or coding agent operate an eesel teammate directly.
The CLI and dashboard work with the same agent and workspace. A developer can inspect connections from the terminal while a support manager reviews that same teammate in the dashboard. Commands produce JSON, so Claude Code, Cursor, or Codex can read results and use them to decide the next step.
For an existing workspace, start with login and identity checks. These examples require Node.js 18.17 or newer:
npx @eesel/cli login
npx @eesel/cli whoami
npx @eesel/cli agents
Select the intended teammate and replace AGENT_ID below with its ID:
npx @eesel/cli status --agent AGENT_ID
npx @eesel/cli integrations --agent AGENT_ID
npx @eesel/cli instructions --agent AGENT_ID
This makes a useful first task for a coding agent: inspect which sources are connected, whether their content has downloaded, and what instructions the teammate follows. Ask it to report findings before making changes. That request is a limit you give the coding agent, not an automatic CLI approval gate.
To add an approved support document, use files upload. To connect a source, inspect the appropriate integrations connect command with --help; some connections require browser authorization. Uploading knowledge does not itself change the teammate’s standing rules.
The CLI also exposes activity, automations, and held-action approvals. These let you inspect what the teammate has done and what it is configured to do. A successful connection check is not proof of answer quality, so test representative support questions with suitable action restrictions.
Connect an MCP client without building a new server
eesel also supplies a workspace MCP endpoint. You can get its connection details through the CLI:
npx @eesel/cli mcp token --agent AGENT_ID
The command prints the server URL, a 30-day workspace token, required headers, and a ready-to-paste Claude Code setup command. Printing the details does not connect the client. Run the generated command in Claude Code’s environment, then restart Claude Code and check:
claude mcp get eesel
For another compatible MCP client, configure the returned URL and headers using that client’s setup process. The eesel MCP guide explains the details. The agent header selects which teammate the client acts as; the workspace token carries the role you had when it was minted. Mint a fresh token and update the client when the token expires or your role changes.
Keep the token out of source control and frontend code. Anyone holding it can act in the workspace within its permissions. Chat can invoke actions, and the teammate’s action-approval rules still apply.
This connection exposes the existing teammate’s tools. It does not create an Apps SDK UI, publish an app to ChatGPT, or establish that a particular ChatGPT authorization flow accepts these headers. A custom ChatGPT experience still needs its own integration and verification.
Choose the interface your users actually need
| Intended result | Relevant path |
|---|---|
| An interactive experience inside ChatGPT | MCP tools plus optional Apps UI, client integration, and deployment testing |
| Terminal or scripted access to an eesel support teammate | eesel CLI with explicit workspace and agent scope |
| Access to that teammate from an MCP client | eesel’s existing endpoint, client configuration, and connection verification |
The shared idea is giving an agent access to useful work. The implementation depends on where that work should happen. Build a ChatGPT interface when that is where your users need to interact; use eesel CLI when the job is operating an existing support teammate.
Try eesel. Once your workspace and teammate are set up, give your coding agent one concrete task: inspect the support teammate’s connected knowledge and instructions, report what is missing, and ask before changing anything.
