ChatGPT workflow placement

Map AI workflow layers to ChatGPT Projects, project files, Project Sources, Project Memory, Custom GPTs, GPT Knowledge, capabilities, apps, actions, Skills, Custom Instructions, Library, Agent mode, and runtime chat prompts.

ChatGPT configuration map

Start with the workflow layer, then choose the ChatGPT surface

Use this reference to decide whether a workflow belongs in Project Instructions, project files, Project Sources, Custom GPT instructions, GPT Knowledge, Skills, Custom Instructions, Library, apps/actions, agent mode, or the runtime chat prompt.

ChatGPT setup decision

Choose the right ChatGPT surface first

Start by choosing the surface that matches the workflow scope. Each card links to the relevant placement section. Stable rules, reusable source material, reusable assistants, packaged workflows, tool access, and one-off task input belong in different ChatGPT surfaces.

Use a Project for long-running work

Use Projects when the workflow needs project-scoped instructions, related chats, reference files, project sources, project memory, shared project context, or repeated work over time.

Go to Projects →

Use a Custom GPT for a reusable assistant

Use a Custom GPT when the workflow should become a reusable assistant with its own instructions, knowledge, conversation starters, capabilities, apps or actions, preview testing, sharing controls, and version history.

Go to Custom GPTs →

Use a Skill for a packaged workflow

Use a Skill when the workflow should be reusable and packaged with instructions, supporting resources, examples, code, or a repeatable step sequence that ChatGPT can automatically use when helpful.

Go to Skills →

Use ChatGPT agent for delegated multi-step tasks

Use agent mode when the task requires multi-step online work, browsing, file work, connected apps, supported terminal activity, spreadsheet edits, confirmations, or scheduled follow-up.

Go to tools and agent mode →

Use Custom Instructions only for user-wide defaults

Use Custom Instructions only for preferences or behavior rules that should apply broadly across chats. Do not use them for one project, one client, one artifact, one repository, or one temporary workflow.

Go to placement rules →

Use the API for product or backend integration

Use the OpenAI API instead of ChatGPT UI surfaces when the workflow must run inside a website, application, backend service, internal agent system, CI pipeline, or controlled production workflow.

Open API mapping →

Primary surfaces

ChatGPT surfaces you can configure

These are the main ChatGPT surfaces relevant to workflow placement. Availability can vary by plan, workspace permissions, workspace admin settings, region, and rollout state.

Projects
Smart workspaces for long-running efforts. Projects group chats, uploaded or pasted reference files, project instructions, project sources, memory, tools, connected apps, and repeated work in one context.
Project Instructions
Project-scoped instruction surface. Use it for rules, tone, scope, output contracts, verification requirements, and workflow behavior that should apply only inside one Project.
Project files / reference material
Project-scoped reference material. Use it for PDFs, spreadsheets, docs, images, pasted text, requirements, source material, research files, policy files, or examples that should inform project responses.
Project sources
Reusable project context. Supported app links, saved responses, pasted text, and uploaded files can function as project sources where the workspace supports them. Treat project sources as reference material, not behavior rules.
Project Memory / project-only memory
Project memory helps ChatGPT remember chats and files inside the project. Use it for continuity, not as a control layer. When available, project-only memory keeps the project context isolated from saved memories outside the project.
Project sharing and access roles
Projects can be shared. Access can include chat-only or edit capabilities depending on plan and workspace. Edit access can allow updates to instructions, files, and invited members.
Custom GPTs
No-code assistants configured for a specific purpose. GPTs can include instructions, knowledge, conversation starters, selected capabilities, apps, actions, sharing controls, and version history.
GPT Instructions
Assistant-scoped behavior rules. Use for the GPT’s role, workflow, tone, boundaries, output format, examples, allowed behavior, and failure behavior.
GPT Knowledge
Uploaded files the GPT can use as reference material. Use knowledge for documentation, guides, handbooks, examples, internal content, or other source material. Do not use knowledge files as the primary behavior layer.
GPT conversation starters
User-facing example prompts shown when opening a GPT. Use them to communicate the GPT’s intended use cases and help users start with high-value tasks.
GPT recommended model
The recommended model suggests the best default model for the GPT’s task when more than one model is available. Users may still switch models when their plan and GPT configuration allow it.
GPT capabilities
Built-in tools that can extend a GPT, including web search, image generation, Canvas, Code Interpreter & Data Analysis, and apps where available.
GPT apps
User-connected tools and services that a GPT can use where apps are enabled. Apps and custom actions are mutually exclusive inside a GPT.
GPT actions
External API connections defined by the GPT builder. Actions require API details, authentication configuration, and an OpenAPI schema. Use actions only when the GPT needs to retrieve data or trigger operations in external systems.
GPT action authentication
GPT actions can use no authentication, API key authentication, or OAuth depending on the external API. OAuth is appropriate when the action requires user-account access.
GPT action schema
Actions require an OpenAPI schema in JSON or YAML. The schema defines servers, endpoints, parameters, and operation IDs. Invalid schemas should be fixed before publishing or sharing the GPT.
GPT preview, testing, and version history
Use Preview to test the GPT before sharing. Use version history to review or restore previous versions. After restoring older versions that use actions, authentication may need reconfiguration.
GPT sharing and publishing
GPTs can be private, shared directly, shared within a workspace, shared by link, or published publicly where the account and workspace settings allow it.
Skills
Reusable, shareable workflows. Skills can include instructions, supporting resources, examples, code, and structured steps. ChatGPT can automatically use one or more installed Skills when helpful.
Skills editor / upload / workspace sharing
Skills can be created in conversation, built in the Skills editor, uploaded from a computer, installed when shared with you, and shared with a workspace where supported.
Custom Instructions
User-wide customization applied across chats. Use only for broad behavior preferences. Updates apply to future behavior, and this is not equivalent to API system/developer messages.
Memory
Account-level personalization and continuity. Memory can use saved memories, past chats, custom instructions, files, and connected app data where available. Treat memory as personalization, not as deterministic workflow control.
Memory Sources
A visibility surface that can show which saved memories, past chats, custom instructions, files, or connected app data contributed to a response, depending on plan and availability.
Temporary Chat
Use when you need a conversation that does not rely on or update memory/history. It is useful for isolated runs, but it does not replace explicit project instructions or verification.
Library
Storage and reuse surface for files uploaded to or created in ChatGPT. Files can be added later to a chat from Library. Use Library for reusable files, but classify each file before use: source material, run-specific input, draft artifact, or output artifact.
Apps
Connected tools and data sources. Apps can provide interactive UI, search and reference external information, take actions, run deep research across sources with citations, or sync external data in advance.
ChatGPT agent
Agent mode can reason, research, browse websites, work with files, use apps, run supported terminal commands, edit spreadsheets, ask for clarification or confirmation, and support recurring scheduled tasks where available.
Built-in tools and modes
ChatGPT may support web search, deep research, image input and generation, file uploads, data analysis, Canvas, voice mode, study mode, and other tools depending on plan and settings.

Projects

Use Projects for ongoing work with shared context

A Project is the correct ChatGPT surface when the work has persistent context, source material, repeated tasks, multiple chats, or a team/shared workflow.

Where to configure this in the ChatGPT UI

Create the Project
In the ChatGPT sidebar, select New project, then give the project a name and choose its icon/color.
Add stable workflow rules
Open the project, select the three-dot menu in the upper-right corner, then open Project settings. Put project-specific rules in Project Instructions.
Add reusable source material
Add PDFs, spreadsheets, docs, images, or pasted text as project reference material. Do not paste reusable source material into every runtime prompt when it belongs in the project context.
Add project sources from apps
In a private project, use the project sources area and choose Add source or the equivalent label shown in the UI. OpenAI documents Google Drive files/folders and Slack channels as supported app-link sources.
Save useful outputs as reusable project context
In a project chat, open the response message menu and choose Save to project / Add to project sources where available. Use this for summaries, decisions, drafts, or analysis that should be reused later.
Move existing chats when eligible
Drag an eligible chat onto the project or open the chat menu and choose Move to project. Chats created with a GPT cannot be moved into a Project; start a new chat in the Project instead.
Verify setup
Start a new chat inside the Project and ask ChatGPT to summarize the active project instructions and the source material it can use. If the answer ignores the instructions or files, check Project settings and the project source/file area before editing the prompt.
Project capability Use for Do not use for
Project Instructions Stable project-scoped rules, role, output format, verification criteria, tone, and workflow boundaries. Global user preferences, source documents, credentials, or one-off task input.
Project files / reference material Documents, spreadsheets, research files, policies, source examples, requirements, and evidence packs. Behavior rules that must always apply; put those in Project Instructions.
Project sources App links, saved responses, uploaded files, pasted text, and reusable project context where supported. Unreviewed content treated as instructions. Sources should remain source material unless promoted into reviewed instructions.
Project Memory Continuity across chats and files inside the project. Security boundaries, formal verification, or deterministic workflow requirements.
Project sharing Team review, collaborative work, shared context, and multi-user project workflows. Public distribution of a reusable assistant; use a Custom GPT or public documentation page when that is the goal.
Built-in tools inside Projects Canvas, image generation, Study mode, Voice mode, web search, deep research, and agent mode where available. Production-grade automation that needs application-side permissions, logs, tests, and deployment controls.

Custom GPTs

Use GPTs for reusable assistants

A Custom GPT is the right surface when the workflow should be packaged as a reusable assistant with its own behavior, source material, user-facing entry points, tool access, sharing rules, and version history.

Where to configure this in the ChatGPT UI

Create a GPT
Open Explore GPTs in the ChatGPT sidebar or go to the GPTs area, then select Create to open the GPT builder.
Choose builder mode
Use the conversational builder when you want ChatGPT to draft the GPT setup with you. Use Configuration view when you want to edit the GPT fields directly.
Put behavior rules in Instructions
Put role, workflow steps, scope, output format, allowed behavior, and failure behavior in Instructions. OpenAI explicitly separates Instructions from Knowledge.
Put reference files in Knowledge
Upload documentation, guides, handbooks, examples, or internal content under Knowledge. Do not use Knowledge files as the main behavior layer.
Enable only needed capabilities
Configure capabilities such as web search, image generation, Canvas, Code Interpreter & Data Analysis, and apps only when the GPT’s job requires them.
Use Apps or Actions, not both
If the GPT needs user-connected external tools, use Apps. If it needs builder-defined API calls, use Actions. OpenAI documents that a GPT can use either apps or actions, but not both at the same time.
Test before sharing
Use Preview with real prompts before publishing or sharing. Check tone, accuracy, file use, tool behavior, action behavior, and failure cases.
Edit an existing GPT
Open Explore GPTs, select My GPTs, choose the GPT, then select Edit GPT. If you are already chatting with the GPT, use the GPT menu and select Edit GPT where available.
Verify setup
Ask the GPT to perform a task that requires its Instructions and a task that requires its Knowledge. If it behaves correctly but ignores files, check Knowledge. If it uses files but ignores rules, check Instructions.
GPT configuration Use for Placement rule
Name User-facing assistant title. Make it specific enough that users immediately understand the GPT’s purpose.
Description Short explanation of purpose, audience, and task coverage. Use for discovery, preview, and share surfaces. Do not make it generic marketing copy.
Conversation starters Realistic starting prompts that show the intended workflow. Use high-value examples, not vague prompts like “Help me get started.”
Instructions Behavior, scope, workflow steps, output format, allowed actions, and failure behavior. Put rules here, not in Knowledge files.
Knowledge Reference files such as documentation, guides, handbooks, examples, and source material. Use Knowledge for source material. If the GPT must cite files, specify citation behavior in Instructions.
Recommended model Suggested default model for the GPT’s task. Use when the workflow benefits from steering users toward a specific model type.
Capabilities Web search, image generation, Canvas, Code Interpreter & Data Analysis, and apps where available. Enable only capabilities required by the GPT’s job.
Apps User-connected tools and services. Use apps when user-connected external data is needed. A GPT can use apps or actions, not both at the same time.
Actions External APIs defined by the GPT builder. Use only when API access is required. Configure auth and OpenAPI schema, then test in Preview.
Preview Testing behavior before sharing or publishing. Test real prompts, tone, accuracy, tool calls, action behavior, and failure cases.
Version history Reviewing and restoring previous GPT versions. Use before major edits and after regressions. Recheck action authentication after restoring older versions.
Sharing / publishing Private, direct, workspace, link, or public GPT Store distribution depending on eligibility. Match visibility to intended audience, data sensitivity, and workspace policy.

Skills

Use Skills for packaged reusable workflows

Skills are the best ChatGPT surface when the workflow should be reusable, shareable, and packaged with instructions, resources, examples, code, or a repeatable step sequence.

Where to configure this in the ChatGPT UI

Open Skills
Click your profile icon in ChatGPT, then select Skills.
Create a Skill in conversation
Ask ChatGPT to create or modify a Skill directly in a chat. ChatGPT uses the skill-creator skill to help generate, update, or troubleshoot the Skill, then prompts you to install it.
Create a Skill with the editor
On the Skills page, select New skill, then choose Create with editor.
Upload an existing Skill
On the Skills page, select New skill, then choose Upload from your computer.
Install a shared Skill
On the Skills page, open Shared with you, hover over the Skill, select the three-dot menu, then choose Install.
Share a Skill with a workspace
On the Skills page, hover over the Skill, select the three-dot menu, then choose Share. Availability and permission controls depend on workspace settings.
Verify setup
Run a task that should trigger the Skill. If ChatGPT does not apply it automatically, check whether the Skill is installed, whether Skills are enabled for the workspace, and whether the Skill instructions are specific enough for the task.
Use Skills when
The workflow is repeated often, has a stable procedure, benefits from examples/resources/code, and should produce consistent output without rebuilding the setup in every chat.
Skill contents
A Skill can include instructions, supporting resources, examples, code, and structured steps. Use this for repeatable workflows such as review gates, content checks, QA flows, analysis procedures, formatting routines, or artifact-generation procedures.
Auto-use behavior
Once installed, ChatGPT can automatically use a Skill, or multiple Skills, when helpful. Because of this, Skill instructions must be scoped and specific enough to avoid accidental over-application.
Creation and management
Skills can be created in conversation, built in the Skills editor, uploaded from a computer, installed from workspace shares, and shared with a workspace where supported.
Availability note
Skills availability depends on plan and product surface. Do not imply universal availability on every ChatGPT plan.

Tools, apps, and agent mode

Use tools only when the workflow requires external capability

Tools are not a substitute for instructions or reference material. Use tools when the workflow requires live information, external data, computation, visual work, file processing, connected systems, or delegated multi-step execution.

Where to configure this in the ChatGPT UI

Connect an app
Open Settings > Apps, or open the app directory from the sidebar. Select the app, choose Connect where available, then complete OAuth and sync setup if required.
Use an app in chat
After the app is connected, invoke it with an @ mention in your prompt, or use the composer + menu and choose More to select the app.
Use apps inside Projects
In a Project chat, use the tools menu + button to select the app, or reference the app by name. ChatGPT may ask for confirmation before searching outside the Project.
Start agent mode
Select agent mode from the tools menu, or type /agent in the composer. Describe the task and monitor clarification or confirmation requests.
Manage recurring agent tasks
After an agent task finishes, use the Clock icon to schedule daily, weekly, or monthly recurrence. Review recurring tasks from the schedules page where available.
Verify setup
For apps, ask ChatGPT which app it is using and what data source it is referencing. For agent mode, confirm the task plan before allowing sensitive or external actions. Disable unnecessary apps before high-risk tasks.
Surface Use for Control requirement
Web search Recent or real-time information with source-backed answers. Require source review for claims that affect public content, client work, or decisions.
Deep research Multi-step research tasks that need structured outputs and citations. Use for research workflows; still verify source quality and claim alignment.
File uploads Summarizing, extracting, analyzing, or answering questions from uploaded documents. Classify whether the file is reusable reference or run-specific input.
Data Analysis / Code Interpreter Calculations, structured data analysis, CSV/spreadsheet work, charts, and code-backed analysis. Validate outputs, formulas, assumptions, and generated files before relying on them.
Canvas Drafting, editing, debugging, or revising long-form documents and code in a shared workspace. Use when iterative editing is needed; do not treat Canvas state as a formal source of truth by itself.
Image input / generation Interpreting screenshots, diagrams, charts, and creating or editing visual assets. Verify visual claims and do not use image output as factual evidence without source support.
Apps External data sources, workspace data, app actions, synced knowledge, and deep research across connected sources. Use only trusted apps; check workspace/admin restrictions and data access boundaries.
GPT actions Builder-defined API access for a Custom GPT. Require auth design, valid OpenAPI schema, privacy policy for public GPTs with actions, and user approval where applicable.
Agent mode Delegated multi-step tasks involving websites, files, apps, terminal commands, spreadsheets, and recurring task schedules. Use for guided task execution; require confirmation/approval for sensitive or irreversible operations.

Memory and Library

Separate personalization from source material

Memory and Library are useful surfaces, but they are not the same thing as instructions, source governance, or verification.

Where to configure this in the ChatGPT UI

Manage Memory
Open your profile menu, go to Settings > Personalization, then manage Reference saved memories and Reference chat history where available.
Manage Custom Instructions
On Web/Desktop, open Settings > Personalization, make sure Enable customization is on, then enter instructions in the Custom Instructions field.
Use Temporary Chat
Open a new chat and select the pill-shaped Temporary button in the top-right corner of the page. Temporary Chat does not access or create memories for personalization, but it still follows enabled Custom Instructions.
Open Library
Open Library from the left-hand sidebar to browse uploaded and generated files. Use Library for file reuse, not as a substitute for project instructions or GPT instructions.
Add a Library file to a chat
Open the composer attachment/add menu, choose Add from library, then select the file.
Delete Library files
Open Library, select the file, then click Delete or the trash icon. Deleting a chat does not delete files saved to Library.
Verify setup
For Memory, ask ChatGPT what it remembers and check Settings > Personalization. For Library, add a file from Library into a new chat and confirm ChatGPT can use the selected file.
Saved memories
Use for personalization and continuity. Do not rely on memory to enforce workflow rules, source requirements, security boundaries, or output contracts.
Reference chat history
Can help ChatGPT use prior conversations where available. Do not treat prior chat history as authoritative evidence unless it is independently verified or attached as explicit source material.
Memory Sources
Use Memory Sources to inspect what influenced personalization where available. Memory Sources may not show every factor that shaped a response.
Temporary Chat
Use for isolated work when you do not want the conversation to rely on or update memory/history. Still provide explicit instructions and source material for the task.
Library
Use Library to find and reuse uploaded or generated files. Files in Library should still be classified before reuse: source material, working draft, run-specific input, generated artifact, or output artifact.
Library limits and retention
Library storage, file size, file type support, and retention behavior vary by plan and policy. Do not design a workflow that assumes unlimited storage or permanent retention unless verified for the user’s plan.

Layer placement map

Where each workflow layer belongs in ChatGPT

Use this table after classifying the workflow layer. The goal is correct placement, not feature listing.

Workflow layer What belongs here Best ChatGPT placement Do not use for
Instruction layer Stable rules, role, boundaries, tone, output contract, workflow steps, verification requirements. Project Instructions, GPT Instructions, Skill instructions. Use Custom Instructions only for user-wide defaults. Source documents, credentials, private tokens, mutable business state, or one-off task input.
Reference / source material layer Policies, examples, research sources, product docs, repository notes, approved references. Project files, Project Sources, GPT Knowledge, Skill resources, Library files, or Apps where external source material lives. Behavior rules that must always run; those belong in the instruction layer.
Reusable workflow layer Repeatable procedures, reusable assistants, review workflows, standard output formats, team playbooks. Project for ongoing context, Custom GPT for a reusable assistant, Skill for a packaged workflow. One-off prompts that must be manually reconstructed every time.
Runtime prompt layer The current task, current document, current code snippet, current question, current constraints. The current chat message inside the relevant Project, GPT, Skill workflow, or agent run. Permanent policies, long-lived reference files, reusable instructions, or global preferences.
Tool / action layer External APIs, connected apps, web search, data analysis, file processing, visual work, browsing, terminal commands. GPT actions, GPT apps, ChatGPT apps, built-in tools, or agent mode. Use API/internal systems for production control. Unvalidated writes, privileged operations, sensitive actions, or production side effects without approval and external validation.
Memory / continuity layer Personalization, prior chat context, project continuity, remembered preferences. Project Memory, project-only memory, saved memories, reference chat history, Memory Sources. Formal evidence, permissions, deterministic controls, or required source material.
Verification layer Source alignment, checklist review, schema check, citation check, policy check, output acceptance criteria. Explicit verification step in Project/GPT/Skill instructions plus final checklist before use. Use deep research citations where relevant. Informal “looks good” review for publish, client delivery, production changes, billing, or irreversible actions.

Placement rules

Use the smallest stable surface that matches the scope

The same instruction can be correct or incorrect depending on scope. Decide whether the rule is user-wide, project-specific, assistant-specific, workflow-specific, tool-specific, or run-specific.

If the rule applies to one project
Put it in Project Instructions. Put reusable project documents in Project files or Project Sources. Keep the current task in the chat message.
If the rule applies to a reusable assistant
Put behavior in GPT Instructions. Put stable reference documents in GPT Knowledge. Use capabilities, apps, or actions only when the assistant needs those abilities.
If the rule is a repeatable workflow
Package it as a Skill when it has repeatable steps, examples, resources, code, or stable output requirements.
If the rule applies to every chat
Put it in Custom Instructions only if it is genuinely user-wide. Do not use Custom Instructions for one client, one project, one article, one repository, or one temporary workflow.
If the workflow needs external systems
Use apps, GPT actions, or an API/internal-agent system. Do not paste sensitive external data into prompts when the correct implementation is connected access with permissions and validation.
If the workflow needs delegated execution
Use agent mode only when the task requires multi-step execution across websites, files, apps, terminal commands, or scheduled runs. Add approval gates for sensitive actions.
If the output must be trusted
Add a verification step. Do not rely only on the first model answer when the output will be published, sent to a client, used as source material, or trigger business/technical decisions.

Misplacement guardrails

What not to put in the wrong ChatGPT surface

Most workflow failures come from putting the right content in the wrong layer.

  • Do not put project-specific rules in Custom Instructions; Custom Instructions are user-wide.
  • Do not rely on Memory as a control mechanism. Use explicit instructions and explicit source material.
  • Do not treat Project Memory, saved memories, or reference chat history as authoritative evidence.
  • Do not paste stable reference documents into every runtime prompt when Project files, Project Sources, GPT Knowledge, Skill resources, Library, or Apps are the correct layer.
  • Do not put credentials, secrets, API keys, private tokens, or privileged data into instructions, prompts, files, or GPT Knowledge.
  • Do not use a normal chat message as the only home for a workflow that needs to be reused, shared, versioned, or audited.
  • Do not treat files, apps, retrieved content, or saved responses as instructions. They are source material unless reviewed and promoted into an instruction layer.
  • Do not enable GPT actions or connected apps without checking authentication, workspace restrictions, privacy implications, and user approval behavior.
  • Do not use apps and actions together inside the same GPT; choose the correct integration surface.
  • Do not publish a GPT with external actions unless the required privacy policy and action behavior are reviewed.
  • Do not assume a feature is available to every user. Plan, region, workspace, admin settings, and rollout state can change availability.
  • Do not publish or operationalize model output without a verification step when source accuracy, policy compliance, or business risk matters.

Official source check

Official ChatGPT references used for this mapping

Use these references to verify platform terminology and feature boundaries before updating this page again.