+180 XP

ChatGPT · Building a custom GPT: instructions, knowledge, and capabilities

Let's build an internal onboarding assistant as a Custom GPT, step by step. We'll configure its instructions, upload knowledge files, and toggle exactly the capabilities it needs. A Custom GPT is a saved, shareable configuration of ChatGPT: a system prompt, optional files, optional tools, and optional Actions, bundled under one name. You are not training a model. You are packaging behavior.

We will call ours Onboard Buddy. It answers a new hire's first-week questions about benefits, tooling, and who owns what.

Where to build and who can use it

Custom GPTs live at chatgpt.com/gpts. You create one with the Create button or the builder at chatgpt.com/gpts/editor. Building requires a paid plan: Plus, Pro, Business (the plan formerly called Team), or Enterprise/Edu.

One decision shapes everything else: distribution. For an internal helper, you almost certainly want a Business or Enterprise workspace. There you can publish a GPT to "Only people in [workspace]" instead of "Anyone with the link" or the public GPT Store. This keeps your benefits PDF off the open internet. Check OpenAI's notes on creating a GPT for the current sharing options.

The Configure tab is the real work

The builder has two tabs:

  • Create, a conversational wizard.
  • Configure, the form.

The wizard is fine for a first draft, but every serious GPT gets tuned in Configure. That tab holds:

  • Name and description
  • Instructions (the system prompt)
  • Conversation starters (suggested first messages)
  • Knowledge (uploaded files)
  • Capabilities (Web Search, Canvas, Image Generation, Code Interpreter & Data Analysis)
  • Actions (custom API calls)

You may also see a recommended model setting. Options vary by plan, so check what your workspace offers.

Here are the settings that matter most.

Instructions: write them like an operating procedure

Instructions are the GPT's standing orders. They apply to every conversation, so treat them as a contract. Here is the set for Onboard Buddy:

You are Onboard Buddy, the onboarding assistant for new hires at Acme Co.

SCOPE
- Answer questions about benefits, IT setup, tooling, policies, and team ownership.
- Use ONLY the uploaded knowledge files for any factual claim about Acme.
- If the answer is not in the files, say so and point to #ask-people-ops in Slack.
  Never guess about policy, salary, or legal topics.

STYLE
- Concise. Lead with the answer, then a short "why" if useful.
- New hires are non-technical by default. Avoid internal jargon or define it once.

BEHAVIOR
- When asked "who owns X", cite the team and the named contact from team-directory.md.
- For step-by-step setup, output a numbered checklist.
- End answers that touch HR or payroll with: "Confirm with People Ops before acting."

Good instructions share a few habits.

Anchor to knowledge explicitly. The line "Use ONLY the uploaded knowledge files" needs an escape hatch: "If the answer is not in the files, say so." Together they stop your GPT from confidently inventing a parental-leave policy.

Specify refusal behavior. Tell it what NOT to answer. For an HR-adjacent bot, "never guess about salary or legal topics" is a safety feature.

Define format where it matters. "Output a numbered checklist" gets you consistent, scannable setup guides instead of prose blobs.

Keep instructions focused. The character limit is generous, but a tight 300-word brief beats a rambling 2,000-word one. The model follows clear, non-contradictory rules more reliably.

Conversation starters earn their keep

These are the clickable prompts on the GPT's home screen. Match them to real first-week questions:

  • "How do I set up my laptop and VPN?"
  • "What's our health insurance and when does it start?"
  • "Who owns the deployment pipeline?"
  • "Walk me through expense reports."

Good starters quietly document what the GPT is for. They also cut down on new hires asking "what can you do?"

Knowledge: files, not fine-tuning

The Knowledge section is where you upload reference documents. Behind the scenes, this gives the GPT retrieval over your files. It is the same RAG pattern you already know, with no setup on your part. Upload the actual source material:

  • benefits-2026.pdf
  • it-onboarding.md
  • team-directory.md
  • pto-and-leave-policy.pdf
  • expense-policy.pdf

A few realities to design around.

Structure beats volume. A clean Markdown file with clear headings retrieves better than a 90-page scanned PDF. If a document is messy, convert it to Markdown or split it by topic before uploading.

One concept per file is easier to maintain. When the 2026 benefits change, you swap one file instead of re-editing a monolith.

Files are visible if Code Interpreter is on. This matters for privacy. With Code Interpreter & Data Analysis enabled, a savvy user can sometimes get the GPT to list or dump uploaded files. Do not put secrets, raw PII, or unreleased compensation bands in Knowledge. Treat anything you upload as readable by anyone who can use the GPT.

Knowledge is static. It is a snapshot from upload time. For data that changes daily, such as open headcount or ticket status, you want an Action instead. Actions are covered below.

Capabilities: toggle only what the job needs

Each capability is a checkbox. More tools give the GPT more room to wander, so enable them deliberately.

Web Search

Web Search lets the GPT pull from the live internet. For Onboard Buddy, turn this off. You want answers grounded in your files, not a public web guess about "standard PTO policy." Web Search suits a competitive-research GPT. It is wrong for an internal policy authority.

Canvas

Canvas opens a side-by-side editing workspace for longer documents and code. It helps if your GPT drafts things, like a 30-60-90 day plan or a welcome email. For a pure Q&A helper, it's optional. Enable it if you expect new hires to co-write onboarding docs with the assistant.

Image Generation

Image Generation lets the GPT create pictures. For an onboarding helper, leave it off. A benefits bot has no reason to generate images, and turning it off keeps the GPT focused.

Code interpreter & data analysis

This capability is a sandboxed Python environment. It can run code, parse spreadsheets, and make charts. For Onboard Buddy, leave it off by default, for two reasons:

  • It isn't needed.
  • It creates the file-exposure risk described above.

You would enable it for, say, an analytics GPT that crunches an uploaded CSV of survey responses.

For our onboarding assistant, the correct configuration is all capabilities off, knowledge files on, and tight instructions. A boring config is often the right one.

Knowledge check

1. What best describes what a Custom GPT actually is?

2. For an internal onboarding assistant that uses a private benefits PDF, why is a Team or Enterprise workspace the recommended distribution choice?

3. Why does the lesson say serious GPTs are tuned in the Configure tab rather than only using the Create wizard?

MULTIPLE CHOICE

4. Select ALL statements that reflect good practice for writing a Custom GPT's Instructions, based on the lesson.

Select all the correct answers.

MULTIPLE CHOICE

5. Select ALL items that are configurable capabilities you can toggle for a Custom GPT in the Configure tab.

Select all the correct answers.

Actions and Apps: when static knowledge isn't enough

Knowledge files answer "what is the policy." They cannot answer "is my laptop ticket approved yet." For live, per-user data inside a Custom GPT, you need GPT Actions. With an Action, the GPT calls an external API mid-conversation using your OpenAPI schema. It then folds the response into its answer. This is the same idea as function calling in the API, exposed inside ChatGPT.

You define an Action by pasting an OpenAPI spec and setting auth (API key or OAuth). Suppose your IT system exposes a ticket-status endpoint. A minimal schema looks like this:

yaml
openapi: 3.1.0
info:
  title: Acme IT Tickets
  version: "1.0"
servers:
  - url: https://it.acme.internal/api
paths:
  /tickets/{ticketId}:
    get:
      operationId: getTicketStatus
      summary: Get the status of an onboarding IT ticket
      parameters:
        - name: ticketId
          in: path
          required: true
          schema:
            type: string
      responses:
        "200":
          description: Ticket found
          content:
            application/json:
              schema:
                type: object
                properties:
                  status: { type: string }
                  assignee: { type: string }
                  eta: { type: string }

With this in place, a new hire can ask "what's the status of ticket IT-4821?" The GPT calls getTicketStatus, then answers in plain language. The operationId and summary fields matter: the model reads them to decide when and how to call the endpoint, so write them descriptively.

Bookmark the official walkthrough: Actions in GPTs.

There is also a lower-effort route for company documents. OpenAI's managed integrations, formerly called Connectors and now called Apps in ChatGPT, link sources like Google Drive and SharePoint without any schema. Business and Enterprise admins control which Apps a workspace can use. Note that Apps mostly work in regular ChatGPT conversations, not as a setting inside the GPT builder.

If your onboarding docs already live in Drive and change often, new hires may get fresher answers by asking ChatGPT with the Drive app enabled. Re-uploading files as Knowledge goes stale. A practical split:

  • Knowledge for stable reference PDFs
  • Apps for living document stores
  • Actions for transactional, per-user lookups inside your GPT

Build a Custom GPT with Actions

Watch on YouTube

Test, then publish deliberately

Before sharing, use the Preview pane on the right of the builder. Run adversarial tests, not just happy paths:

  • Ask something not in the files. It should admit the gap and point to Slack, not fabricate.
  • Ask an off-scope question ("what's our Q3 revenue?"). It should refuse.
  • Ask an HR question. Check that it appends the "Confirm with People Ops" line.

If behavior drifts, fix the instructions, not the knowledge. Most misbehavior comes from a missing rule.

When it passes, hit Create or Update and choose the audience. For Onboard Buddy, select your workspace-only option. Avoid "Anyone with the link" for anything containing internal docs. Keep internal tools out of the public GPT Store entirely.

A note on the bigger picture

A Custom GPT is the no-code end of OpenAI's spectrum. You may outgrow it: you might need version control, automated evals, multi-step orchestration, or the assistant embedded in your own app. Then the same logic moves to the API:

  • Instructions become a system message.
  • Actions become function calling or tools.
  • Knowledge becomes your own retrieval pipeline or the hosted file search tool.

The Custom GPT is often the prototype you validate before rebuilding it with the Responses API and the Agents SDK.

Key Takeaways

  • Write instructions like an SOP. Define scope, an explicit "use only the knowledge files" anchor with an escape hatch, refusal rules, and output format. Fix instructions before touching files.
  • Treat Knowledge as readable by your whole audience. Never upload secrets or raw PII, especially with Code Interpreter enabled.
  • For an internal Q&A GPT, the right capability config is usually everything off.
  • Match the source to the data: Knowledge for stable PDFs, Actions for live per-user lookups via an OpenAPI schema. Apps (formerly Connectors) suit living document stores in regular ChatGPT conversations.
  • Publish internal GPTs to your Business or Enterprise workspace, never the public Store. Treat the GPT as a prototype you can later rebuild on the Responses API.

Frequently asked questions

Does building a Custom GPT mean training a model on my data?

No. A Custom GPT is a saved configuration of ChatGPT: a system prompt, optional uploaded files, optional tools and optional Actions, bundled under one name. The underlying model is unchanged. You are packaging behavior, not training anything.

What plan do I need to create a Custom GPT in ChatGPT?

Building a Custom GPT requires a paid plan: Plus, Pro, Business (formerly Team), or Enterprise/Edu. You create one at chatgpt.com/gpts via the Create button, or directly in the builder at chatgpt.com/gpts/editor.

What's the difference between Knowledge files and Actions in a Custom GPT?

Knowledge files are a static snapshot uploaded at configuration time, retrieved when the GPT answers. Actions call an external API mid-conversation using an OpenAPI schema you paste in, so they return live, per-user data. Use Knowledge for stable reference PDFs like a benefits policy, Actions for things like ticket status or approval state.

Can users see the files I upload to a Custom GPT?

Yes, potentially. With Code Interpreter & Data Analysis enabled, a determined user can often get the GPT to list or dump uploaded files. Treat anything in Knowledge as readable by everyone who can use the GPT: no secrets, no raw PII, no unreleased compensation data.

Which capabilities should I enable for an internal Q&A GPT?

Usually none. For an internal policy or onboarding assistant, leave Web Search, Image Generation and Code Interpreter off, and rely on Knowledge files plus tight instructions. Web Search invites public web guesses instead of your own policy, and Code Interpreter creates the file-exposure risk. Canvas is optional if the GPT drafts documents.

How do I stop a Custom GPT from inventing answers that aren't in my documents?

Write two instructions together: "Use ONLY the uploaded knowledge files for any factual claim" and an escape hatch such as "if the answer is not in the files, say so and point to #ask-people-ops." Add explicit refusal rules for sensitive areas like salary or legal topics. Then test in the Preview pane with questions you know the files don't cover, and fix the instructions rather than the files when it drifts.

What to do, from this lesson

These actions are compiled in the role's Playbook.

  • Toggle off every custom GPT capability not required by the task
See the full action playbook →