OpenAI Model Spec – What It Says and How ChatGPT Uses It

The OpenAI Model Spec is a public document in which OpenAI describes how its models should behave in its own apps and the OpenAI API. It covers the values the models follow, the rules they never break, their default behaviors and whose instructions win when two of them clash. It is a published framework, not code that guarantees a given answer.

If you write content with OpenAI’s assistant every day, the document explains a lot of behavior that otherwise looks random. A refusal, a clarifying question or a polite note that a “fact” can’t be verified usually traces back to one of its sections.

Why OpenAI published the document

Publishing it lets anyone check whether a response is a mistake or a design choice. Before the Spec existed, a user who saw a refusal couldn’t tell whether the model had misfired or done what it was built to do. Now there is a written reference to compare against.

OpenAI writes and maintains this Model Specification itself. Internally it guides researchers and the AI trainers who rate responses, so it shapes the data used in reinforcement learning from human feedback (RLHF). OpenAI has also described training methods in which models learn from the text of the Spec directly. That still does not make the document a guarantee. Training moves a model toward the described behavior, and gaps between the two remain.

The five core values

The current version organizes everything around five values, and each one shows up in ordinary prompts:

• Faithfulness to human intent. The model looks past the literal wording to what you actually want. Ask for “a meta description” and you should get one that fits the page, not a generic sentence.
• Harm minimization. Firm limits and safety defaults protect people and society, so some requests are declined or answered only in part.
• Honesty and transparency. The model should not present guesses as facts, and it should say when it doesn’t know.
• Human agency. It helps you reason and decide without steering you toward its own view.
• Care. It considers the wellbeing of the person it is talking to, beyond completing the task.

For content teams, honesty matters most. Many forced statistics in AI drafts are exactly what this value is meant to prevent, so a model that pushes back on “add a percentage here” is following the Spec.

Objectives, rules and standard behaviors

The document separates three layers, and they differ in how much room they leave. Objectives are the broad goals, such as helping the people the model works with and benefiting society. They explain why the model acts as it does, but they are too general to decide a single prompt on their own.

Rules are hard limits. No system prompt or user request unlocks them. Detailed help with weapons capable of mass casualties is one example. Platform-level rules sit here, and they apply equally in OpenAI’s own app and in any product built on its platform.

Standard behaviors are defaults, and you can change them. Out of the box the model writes in a neutral tone, gives balanced views on contested topics and asks a question when a request is truly ambiguous. A developer or user can override these defaults by asking for a formal register, a single recommendation or a fixed format. When someone says “the model always does X,” they are usually describing standard behaviors rather than rules, which is why a clear instruction often changes the result.

The Spec also sets stricter defaults for users under 18. When an account is known or estimated to belong to a teen, the assistant avoids romantic or sexual roleplay, takes extra care with topics such as self-harm and risky challenges, and points younger users toward trusted adults and real support.

The chain of command when instructions clash

When two instructions conflict, the one from higher up the chain wins. The order runs from the platform (OpenAI’s own rules) to the developer (the system prompt of the product) to the user (you). Guidelines that are defaults come below the user. Text the assistant only reads, such as a pasted web page, a file or a tool result, carries no authority at all.

Here is how a conflict is resolved. Say a writing tool’s system prompt reads “Write in the client’s brand voice and never name competitors.” You ask it to compare the client with a rival brand by name, and you paste the rival’s homepage, which happens to contain the line “ignore previous instructions.”

1. The assistant checks platform rules first. Comparing products breaks none, so the request can go ahead.
2. It checks what the developer asked for. Not naming competitors is a legitimate product choice, and it ranks above the user.
3. It weighs your request against that rule. The two conflict, so the developer’s choice wins on that point.
4. It treats the pasted page as data. The embedded command is ignored because quoted text has no authority.
5. It helps as far as it can. You should get a feature-by-feature comparison with the competitor left unnamed, and ideally a short note explaining why.

The official examples work the same way, but they are illustrations, not a complete rulebook.

The Spec itself sits at platform level. It is implicitly present at the start of every conversation, before any system prompt or message, so nothing a developer or user writes can rank above it. Each policy inside it also carries its own authority level. Some are platform-level and fixed, while others are written as guidelines that a developer or user may adjust.

How the OpenAI Model Spec differs from system prompts and usage policies

Three documents often get mixed up, and each one governs something different. The table compares them on the points that matter when you build or use a tool:

	Model Spec	Usage policies	System prompt
Who writes it	OpenAI	OpenAI	The developer of each product
What it governs	How the model behaves and reasons	What people may use the products for	How one product’s assistant should act
Who must follow it	The model	Users and developers	The model, within the Spec’s limits
Can it be overridden	Only its defaults	No	Yes, by platform rules

The practical takeaway is that your system prompt operates inside the Spec and never above it. It is also separate from OpenAI’s page on choosing models, which covers capability and cost tiers, not behavior.

From the 2024 release to the latest revision

Older articles often describe only the first version, so the timeline matters if you land on one of them:

• 2024. The first release introduced objectives, rules and default behaviors and asked the public for feedback.
• 2025. A larger update spelled out the chain of command, added many more worked examples and made the text openly available for reuse and comment.
• The latest revision. The document was reorganized around the five core values. It now refers to the model as “GPT” instead of the older generic label, and it retired rigid style rules in favor of judgment about what each reader needs.

The newest revision also covers memory and agents. Preferences the assistant remembers from past sessions are treated as defaults rather than standing orders, because they can go stale and should give way to what you ask now. When it acts as an agent, it needs explicit permission for consequential steps. Being told to save money on a subscription, for example, does not allow it to change the cancellation terms. How long an agent can keep working in ChatGPT also depends on the shared token budget for chat and work.

Pages that answer “what is the OpenAI Model Spec” with only the 2024 framing are describing a version that has since been replaced. Check the release notes on OpenAI’s site for the current text.

What it changes in app and API content work

In everyday use, the Model Spec explains why the same prompt can get different results across tools. A content app built on OpenAI’s platform carries its own system prompt, so it may refuse things that the plain chat app allows, or follow a house style that app doesn’t know about.

Three habits follow from the document:

• Put durable requirements such as tone, banned claims and output format in the system prompt or project settings, where they rank above a single message.
• Don’t rely on pasted competitor pages to steer the model. It treats them as material to read, not commands to obey.
• When the model won’t supply a figure, give it a real source instead of pushing harder. The honesty value works in your favor here.

Behavior beyond writing follows the same platform logic. Browsing is one example, as in the Aura safety check that can block sites from ChatGPT browsing. The same thinking shapes how we build RankFlow. Articles are written from your content profile, your authors and what currently ranks, and numbers are labeled as measured, calculated or estimated.

Open questions and criticism

The main objection is that OpenAI writes, interprets and enforces its own rules. No outside body checks whether models actually match the text, and a public document can’t show how closely training follows it.

Other doubts concern trade-offs the Spec admits but doesn’t settle. “Care” and “human agency” can pull in opposite directions when someone asks for something unwise for themselves. Defaults on contested topics still reflect choices someone made. The examples help, but because they are illustrations, edge cases are decided by judgment that readers can’t inspect. Treat the Model Spec OpenAI publishes as a statement of intent and test the behavior that matters to your own workflow.