Your “Hi” Is Not the Whole Prompt: What AI Apps Actually Send to the Model

You open ChatGPT and type:

hi

It looks like you sent almost nothing.

Maybe one token. Maybe a tiny handful, depending on the tokenizer.

But the model is not necessarily processing only what you typed.

Before your hi reaches the model, the application may provide additional context such as:

System instructions
+ product rules
+ current date and environment
+ custom instructions
+ user preferences
+ memories
+ conversation history
+ available tools
+ tool definitions
+ files
+ retrieved context
+ your message: "hi"

So the interesting question is not:

How many tokens are in “hi”?

It is:

How many tokens does the entire application send to the model in order to answer “hi”?

This applies to ordinary AI chat products such as ChatGPT and Claude, not just coding agents such as Codex and Claude Code.

And once tools, skills, MCP servers, project instructions and memories are added, the difference between the visible prompt and the actual model context can become enormous.

ChatGPT Is More Than the Text You Type

ChatGPT is an application built around an underlying model.

The OpenAI Model Spec explicitly describes an instruction hierarchy that includes system, developer and user instructions. System-level instructions have higher authority than the user's message. (OpenAI Model Spec^[1])

Conceptually, therefore, a ChatGPT interaction is not simply:

USER:
hi

It is closer to:

OPENAI / SYSTEM INSTRUCTIONS:
[hidden application and behavioral instructions]

PERSONALIZATION:
[custom instructions]
[memories]
[relevant user context]

CONVERSATION:
[previous messages, where applicable]

USER:
hi

The exact implementation changes over time, and OpenAI does not publish a fixed token count for ChatGPT's complete production context. So claims such as “ChatGPT always uses 8,000 hidden tokens” should not be presented as fact.

But we know from OpenAI's own documentation that additional context exists.

For example, ChatGPT's Custom Instructions are applied to chats, and OpenAI explicitly compares their function with system messages in the API. Current paid ChatGPT plans can store up to 5,000 characters of custom instructions. (OpenAI: ChatGPT Custom Instructions^[2])

Memory can add another layer. OpenAI says saved memories are part of the context ChatGPT uses to generate a response, while the newer memory system can synthesize useful context from past chats, files and connected apps. (OpenAI: Memory FAQ^[3])

So even a new message saying:

hi

may be interpreted in an environment containing substantially more information than those two letters.

Claude's Website Makes This Even Easier to See

Anthropic is unusually transparent about this.

Its official documentation explicitly says that Claude's web interface and mobile apps use a system prompt at the start of every conversation.

Anthropic even publishes versions of these system prompts and explains that they provide information such as the current date and encourage particular behaviours. (Anthropic: Claude System Prompts^[7])

So when somebody types:

hi

into Claude.ai, the conceptual request is already:

Claude system prompt
+ application context
+ user settings/context
+ conversation
+ "hi"

before considering more sophisticated features.

This isn't a strange implementation detail.

It is how modern AI applications work.

Then Coding Agents Take This Much Further

Now move from a general chat interface to an AI agent such as Codex or Claude Code.

The agent has to know far more.

It may need instructions describing how to:

read files
write files
edit code
run shell commands
use Git
search files
call MCP tools
browse the web
delegate to subagents
manage permissions
follow project instructions
apply skills
handle errors

All of that capability has to be made understandable to the model somehow.

And that consumes context.

Anthropic's Claude Code documentation states explicitly that before you type anything, things such as CLAUDE.md, auto-memory, MCP tool names and skill descriptions can already be loaded into the context window.

This is why coding-agent startup overhead can be dramatically higher than a simple chat application.

A One-Word Codex Prompt Has Been Measured at ~7K–24K Input Tokens

A particularly useful real-world experiment was reported in the official OpenAI Codex GitHub repository in April 2026.^[6]

The tester:

1. Started a brand-new Codex Desktop thread.
2. Used a fresh empty project.
3. Typed one word: test.
4. Checked Codex's local token logs.
5. Repeated the experiment while disabling capabilities.

With:

Plugins: 0
Skills: 0
Apps: off

the first real response used approximately:

6,942 input tokens
6,954 input tokens

in two runs.

With more normal capabilities enabled, the same one-word test reached approximately:

10.9K
21.3K
24.2K–24.4K

input tokens depending on configuration. (Codex GitHub issue #18498^[6])

This is a user-reported measurement, not an official OpenAI benchmark, and Codex continues to change.

But it illustrates the architecture perfectly.

The human wrote:

test

The model processed thousands of tokens describing the environment in which that test existed.

Claude Code Shows the Same Effect

Claude Code's official documentation describes its context window as containing:^[8]

• system instructions,
• conversation history,
• CLAUDE.md,
• memory,
• loaded skills,
• files,
• command output,
• tool-related context.

Anthropic even recommends running /context to see what is consuming the active context window.

Exact startup overhead varies by version and configuration. Anthropic’s official context guide is the durable evidence: project instructions, memory, MCP tool names and skill descriptions can load before the first user message. (Anthropic: Claude Code Context Window^[8])

The correct conclusion is:

The fixed context surrounding a tiny user prompt can be orders of magnitude larger than the prompt itself.

So What Does “Hi” Actually Cost?

There are two different answers.

1. ChatGPT Website: What You Pay

When you use the normal ChatGPT website, you generally aren't billed separately for every input token.

ChatGPT consumer plans are sold as free access or subscriptions rather than as an API token invoice. (ChatGPT Pricing^[4])

Therefore, if you are already paying for ChatGPT and type:

hi

your marginal credit-card charge isn't:

$0.04721

There isn't a separate per-message invoice like that.

The interaction instead consumes whatever usage allowance applies to your plan.

And importantly, OpenAI's internal infrastructure cost for that individual ChatGPT message is not publicly disclosed.

So we should not pretend that we know the exact production cost of a ChatGPT hi.

But We Can Calculate an API-Equivalent Cost

This is where things become interesting.

OpenAI's current API price for GPT-5.6 Sol is:^[5]

Input:  $5 / 1 million tokens
Output: $30 / 1 million tokens

while GPT-5.6 Terra is $2 per million input tokens and GPT-5.6 Luna is $0.20 per million. (OpenAI Models & Pricing^[5])

So if we hypothetically priced hidden context at GPT-5.6 Sol's standard API input rate, the economics would look like this:

• Total input context: 1,000 tokens · Input cost at $5/M: $0.005
• Total input context: 5,000 tokens · Input cost at $5/M: $0.025
• Total input context: 10,000 tokens · Input cost at $5/M: $0.05
• Total input context: 20,000 tokens · Input cost at $5/M: $0.10
• Total input context: 30,000 tokens · Input cost at $5/M: $0.15
• Total input context: 50,000 tokens · Input cost at $5/M: $0.25

These are not claims about ChatGPT's actual internal cost.

They are a way of understanding the economic magnitude.

Suppose your visible message is:

hi

but the complete application context happened to be 10,000 tokens.

At $5 per million input tokens:

10,000 / 1,000,000 × $5

= $0.05

The text you typed might represent essentially none of that cost.

Apply the Same Calculation to the Codex Measurement

Take the measured stripped-down Codex example:

~6,942 input tokens

At GPT-5.6 Sol API pricing:

6,942 × $5 / 1,000,000
≈ $0.0347

Approximately 3.5 cents of notional input cost.

Now take the heavier measured configuration:

24,400 input tokens

The same calculation gives:

24,400 × $5 / 1,000,000
≈ $0.122

Approximately 12.2 cents.

Again, this is an API-equivalent calculation, not a statement that OpenAI literally invoices a Codex subscriber 12.2 cents when they type one word.

And it doesn't include output tokens, reasoning, tool calls or additional passes.

Claude Has Similar Economics

As of August 2026, Claude Sonnet 5's standard API pricing is:^[9]

Input:      $2 / million tokens
Cache hit:  $0.20 / million tokens
Output:     $10 / million tokens

(Anthropic API Pricing^[9])

At normal uncached input pricing:

• Context: 5K · Claude Sonnet 5 input cost: $0.01
• Context: 10K · Claude Sonnet 5 input cost: $0.02
• Context: 20K · Claude Sonnet 5 input cost: $0.04
• Context: 30K · Claude Sonnet 5 input cost: $0.06
• Context: 50K · Claude Sonnet 5 input cost: $0.10

A 20K-token environment therefore represents about four cents of standard Sonnet 5 API input before output.

But if those 20K tokens are a cache hit:

20,000 × $0.20 / 1,000,000
= $0.004

Less than half a cent.

And that brings us to one of the most important parts of modern AI economics.

The First “Hi” and the Tenth “Hi” May Not Cost the Same

A large system prompt does not automatically mean the provider recomputes everything from scratch at full price every turn.

Modern model platforms use prompt caching.^[9]

Stable prefixes such as:

system instructions
tool definitions
agent rules

can potentially be reused rather than fully processed again at normal input rates.

This is why a large static system context can be much less expensive on subsequent requests than it appears from raw token counts alone.

But caching doesn't eliminate the architectural issue.

If you constantly create:

new session
new session
new session
new session

or continually change the beginning of the prompt, you can lose much of that reuse.

This matters enormously when building AI-agent systems.

Conversation History Is Another Hidden Cost

There is another difference between:

New chat → hi

and:

A 100-message conversation → hi

The second hi may need to be interpreted using relevant conversation history.

So the real request may conceptually look like:

system instructions
+ customization
+ memory
+ tool definitions
+ conversation message 1
+ conversation message 2
+ ...
+ conversation message 100
+ "hi"

The visible prompt is still tiny.

The context isn't.

This is why long conversations eventually need techniques such as:

compaction
summarization
retrieval
memory
context pruning

Claude Code, for example, automatically compacts long sessions and explicitly warns that old conversation content continues consuming context until managed.

Tools Make the Problem Even More Interesting

Imagine an ordinary chatbot with no tools.

Its context might conceptually be:

system prompt
+ memory
+ conversation
+ user prompt

Now give it:

web search
browser
Python
email
calendar
GitHub
Slack
database
file system
terminal
image generation
CRM
30 MCP servers

The model needs enough information to understand:

• which tools exist,
• what each tool does,
• what arguments they accept,
• when to use them,
• what permissions apply.

That information itself can consume tokens.

Anthropic's API pricing documentation, for example, explicitly documents extra input-token overhead associated with tool definitions.

So:

A tool can cost tokens even when the model never actually calls it.

That is one reason modern agent platforms increasingly care about selective tool exposure and on-demand loading.

“Hi” Reveals the Real Economics of AI Applications

People often estimate LLM costs like this:

User prompt tokens
+
AI response tokens
=
cost

For a modern AI application, a better model is:

System instructions
+ product instructions
+ personalization
+ memory
+ relevant history
+ retrieved context
+ tool definitions
+ skills
+ project instructions
+ files
+ user prompt
+ reasoning
+ tool results
+ output
=
actual model workload

In a sophisticated application, the sentence written by the user can be one of the smallest pieces.

This Is Not Necessarily Waste

There is an important qualification.

If ChatGPT uses additional context to remember how you like answers written, that context creates value.

If Claude Code spends 20K tokens understanding its tools and then completes two hours of engineering work, the startup overhead may be trivial compared with the value produced.

The problem appears when we use a heavyweight context for a lightweight problem.

Imagine loading a 25K-token agent environment to answer:

Is this number positive?

or:

Classify this email as sales or support.

or:

Rename this file.

At sufficient scale, the fixed overhead can exceed the useful work by orders of magnitude.

This Changes How We Should Build AI-Native Software

Instead of thinking:

Every task → strongest agent

a more economical architecture may look like:

Simple request
      ↓
Lightweight model / small context
      ↓
Need more capability?
      ↓
Load relevant tools or skills
      ↓
Still difficult?
      ↓
Escalate to a full agent

The objective is not simply to minimize tokens.

It is to maximize:

useful intelligence per token of context.

That can mean:

• keeping system instructions concise,
• loading tools only when relevant,
• retrieving memories selectively,
• separating unrelated tasks,
• using prompt caching,
• maintaining persistent sessions where appropriate,
• using smaller workers for simple operations,
• delegating large side tasks to isolated contexts,
• escalating to expensive agents only when necessary.

The Bigger Lesson: You Are Paying for Context, Not Just Words

The most important takeaway is not that:

“Hi costs 20,000 tokens.”

That statement would be too simplistic.

A clean ChatGPT conversation, a heavily personalized ChatGPT account, Claude.ai, Codex with twenty tools, and Claude Code inside a large repository can all have very different context footprints.

The real lesson is:

The text visible in the input box is not the complete prompt experienced by the model.

When you type:

hi

you see two letters.

Behind those two letters may be a complete application environment containing instructions, memory, history, tools and other context.

For ChatGPT, OpenAI does not publicly disclose a fixed hidden-token count, so we shouldn't invent one.

For coding agents, measurements show that the difference can reach tens of thousands of tokens.

And as AI software becomes increasingly agentic, this distinction becomes increasingly important.

The next generation of AI optimization will therefore not just be:

How do we write shorter prompts?

It will increasingly be:

How do we give the model exactly the context it needs—and nothing it doesn't?

Sometimes the most expensive part of:

hi

is everything you never typed.