ChatGPT · Ecosystem Integrations
ChatGPT lives in far more places than the browser tab. It sits in your menu bar, inside VS Code, in your Slack workspace, in its own web browser, and behind hundreds of third-party apps that quietly call the OpenAI APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition →. This lesson maps those surfaces, shows a concrete setup, and gives you a rule for when reaching past the web app actually pays off.
The four surfaces
Think of the ecosystem as four places ChatGPT shows up, each with different powers:
- First-party apps: the macOS and Windows desktop apps, mobile, and the ChatGPT Atlas browser. Same account, same Projects and memory, plus extra OS-level or browser-level abilities.
- Developer tooling: the Codex CLI and IDE extension, where ChatGPT reads and edits your actual repository.
- Apps inside ChatGPT: integrations with Google Drive, GitHub, Slack and partner services, where ChatGPT reads your data with permission or shows interactive tools in the chat.
- Third-party products on the API: software that embeds OpenAI models through the API, often without the ChatGPT brand showing at all.
The web app is the lowest common denominator. Integrations matter because they remove the copy-paste tax: the model gets direct access to the file, repo, message, or document instead of waiting for you to ferry text in and out.
First-party apps: the desktop and browser edge
The desktop app is more than the website in a window. On macOS, Work with Apps lets ChatGPT read the content of an app you have open (a terminal, an IDE, a doc), so you can ask about it without pasting. A global hotkey opens a launcher-style prompt over whatever you are doing.
Atlas, OpenAI's browser, puts ChatGPT next to every page. You can ask about the article you are reading, and you can optionally turn on browser memories. In agent mode it clicks through sites for you.
All of these carry your account features: Projects (workspaces that bundle files, custom instructions, and chat history), memory, data analysis (a sandbox where the model writes and runs Python on your uploads), and Canvas (a side-by-side editor for long documents and code).
When it beats the web app: any task where context lives on your machine or in the page in front of you. Examples include debugging a stack trace in your terminal, asking about a spreadsheet you have open, or comparing three product pages without copying them into chat.
Developer tooling: Codex in your repo
The biggest leap for technical readers is Codex, OpenAI's coding agent. Codex works on your repository instead of on pasted snippets. It can plan, edit multiple files, run tests, and open a pull request. It runs in the cloud, in a CLI, and as an IDE extension.
Install the CLI and point it at a project:
npm install -g @openai/codex
cd my-project
codex "add input validation to the signup form and write tests"Codex reads the repo, proposes a diff, runs your test suite, and shows you the result before anything lands. Think of it as delegation rather than autocomplete. You describe an outcome, it does the multi-step work, and you review.
When it beats the web app: real codebase work. The web ChatGPT does not know your file structure, your linting rules, or whether your tests pass. Codex knows all three, because it executes inside your environment.
Apps inside ChatGPT
What ChatGPT used to call Connectors are now apps. You add them from the app directory in settings. Some apps retrieve data: once Google Drive, GitHub, or SharePoint is connected, you can ask ChatGPT to pull a spec from Drive or summarize a repo's recent issues, and it fetches the relevant content at query time. This is RAGRAGA method that lets an AI model answer using your own documents, retrieving relevant passages before generating a response instead of relying only on training data.View full definition → you do not have to build.
Other apps are interactive. Partners build them with the Apps SDK, which sits on the Model Context ProtocolModel Context ProtocolAn open standard that lets AI assistants connect to your company's tools and data in a consistent, governed way, instead of one custom integration at a time.View full definition → (the open standard for connecting models to tools and data). You call a partner app such as Canva or Zillow by name, and its interface appears in the conversation.
For teams, the Slack app brings ChatGPT into channels and DMs, so you can summarize a thread or draft a reply where the conversation already is.
When it beats the web app: when the source of truth is scattered across SaaS tools and you do not want to be the human glue moving content between them.
Scheduled tasks and the agent
Two features turn ChatGPT from reactive to proactive.
Scheduled tasks run a prompt on a recurring schedule. For example: "every weekday at 8am, check these three RSS feeds and send me a digest." You set it once in natural language and it fires on its own.
The ChatGPT agent takes multi-step actions on your behalf. It browses, clicks, and uses a virtual computer to finish a task end to end, such as comparing options across sites and assembling a summary. It pauses for confirmation before consequential steps.
When they beat the web app: anything you would otherwise do by hand on a cadence, or any task that spans many steps and tools where you want to hand off the whole loop.
OpenAI Codex Walkthrough
A concrete setup: triage incoming bug reports
This example wires several surfaces together for one workflow. The goal is to summarize new GitHub issues every morning and flag the urgent ones.
- Connect the GitHub app so ChatGPT can read your issues.
- Create a Project called "Triage" with custom instructions describing your severity labels and what "urgent" means for your product.
- Add a scheduled task inside that Project: "Every weekday at 8am, list issues opened in the last 24 hours, group by severity, and surface anything mentioning data loss or auth."
- When something needs a fix, hand it to Codex to draft a patch and open a PR.
So far this is all configuration and no code. The product surfaces cover a surprising amount before you touch the API.
Knowledge check
1. According to the lesson, what is the core reason ecosystem integrations matter compared to the web app?
2. What best distinguishes how Codex works from simply pasting code snippets into a chat?
3. In which scenario does the lesson say the desktop app clearly beats the web app?
4. Select ALL statements that correctly describe the four surfaces where ChatGPT appears.
Select all the correct answers.
5. Select ALL capabilities the lesson ties to the first-party desktop app experience.
Select all the correct answers.
Third-party products and the API: when you outgrow ChatGPT
Everything above is ChatGPT the product. The other half of the ecosystem is the OpenAI API, where developers build their own apps on the same models. You reachreachThe number of unique people exposed to your message in a given period. Unlike impressions, reach counts each person once, no matter how often they see it.View full definition → for it when you need the model inside your software, your own UI, or a backend job, rather than inside OpenAI's chat interface.
There are two API styles. The Responses API is the newer, agent-oriented interface. It has built-in tools (web search, file search, code interpreter) and handles conversation state cleanly. The older Chat Completions API is still widely supported. For new work, prefer Responses.
Two features make the API reliable in production. With function calling, the model decides to call a function you defined and returns the arguments. With structured outputs, you supply a JSON schemaschemaA schema is the formal blueprint that defines how data is structured, named, typed, and related within a database, file, or message.View full definition → and the model is guaranteed to return JSON that matches it. Structured outputs turn a chatty model into a dependable component you can pipepipeAll active sales opportunities across the stages of the sales process, together with their combined potential value and probability of closing.View full definition → into a database.
Here is the triage logic from earlier, rebuilt as a backend job that emits machine-readable output:
from openai import OpenAI
client = OpenAI()
schema = {
"type": "object",
"properties": {
"summary": {"type": "string"},
"severity": {"type": "string", "enum": ["low", "medium", "high", "critical"]},
"needs_human": {"type": "boolean"},
},
"required": ["summary", "severity", "needs_human"],
"additionalProperties": False,
}
issue = "Login fails for all SSO users after the deploy; some report being logged out mid-session."
response = client.responses.create(
model="gpt-5",
input=f"Triage this bug report:\n\n{issue}",
text={"format": {"type": "json_schema", "name": "triage", "schema": schema, "strict": True}},
)
print(response.output_text)Because the schema is strict, you get back JSON you can parse and route without defensive cleanup. For deeper coverage, see the structured outputs guide.
When you need orchestration: AgentKit and the Agents SDK
Once a workflow has multiple steps, tools, and handoffs, do not hand-roll the control loop. The Agents SDK is OpenAI's code framework for agents. It manages tool calls, conversation state, handoffs between specialized agents, and guardrailsguardrailsRules and controls that keep an AI system inside safe, legal and on-brand boundaries, blocking outputs and actions that cross the line.View full definition →. AgentKit adds Agent Builder, a visual canvas for wiring the same kind of workflow without writing the loop yourself, and ChatKit for embeddingembeddingAn embedding is a numerical vector that represents data (text, images, or items) in a way that captures meaning, so similar items sit close together in space.View full definition → the resulting chat UI in your product.
The choice comes down to ownership. The ChatGPT agent is a finished product for your personal tasks. AgentKit and the Agents SDK are for shipping an agent to other people inside your own app.
Custom GPTs vs. API apps: choosing the surface
People often ask when to build a Custom GPT (configured in ChatGPT, optionally published to the GPT Store) and when to build an app on the API.
Build a Custom GPT when:
- Your users already live in ChatGPT.
- You want zero hosting and zero code for the core logic.
- GPT Actions (which let a Custom GPT call external APIs via an OpenAPI spec) cover your integration needs.
If you want a richer interactive experience inside ChatGPT, consider an Apps SDK app instead.
Build on the API when:
- You need your own UI, branding, or login.
- You require structured outputs feeding downstream systems.
- You need control over cost, latency, logging, and data handling.
- The app runs without a human watching, on a schedule or in response to events.
A useful tell: if the answer to "where does this run?" is "in a conversation," a Custom GPT or ChatGPT app fits. If it is "in my product or my backend," use the API.
The decision rule
To decide whether an integration beats the web app, ask one question: where do the context and the action live?
- Context on your machine or in a web page: the desktop app, Atlas, or Codex.
- Context in SaaS tools: apps inside ChatGPT.
- Action on a cadence or across many steps: scheduled tasks or the agent.
- Logic inside your own software, with output feeding other systems: the API, plus AgentKit for multi-step flows.
The web app wins only when the task is self-contained and one-off. Everything recurring, embedded, or programmatic belongs on a different surface.
Key Takeaways
- Match the surface to where context and action live. The web app is for self-contained tasks. Reach for desktop, Atlas, Codex, apps, or the API when the work touches your machine, your tools, or your software.
- Use Codex for real codebase work, not pasted snippets. It executes inside your repo, runs your tests, and opens PRs.
- Connectors are now called apps. The same directory holds data sources like Drive and GitHub and interactive partner apps built on the Apps SDK.
- Configuration beats code more often than you expect. Projects, apps, and scheduled tasks can stand up a recurring workflow with no API call at all.
- Reach for the API when output must be machine-readable or embedded. Combine the Responses API with structured outputs for reliable JSON, and use AgentKit or the Agents SDK when the workflow spans multiple steps and tools.
- Custom GPT vs. API comes down to "where does it run?" In a conversation means Custom GPT. In your product or backend means the API.