From a GPT‑4 Invitation Email to the Age of Agents

While sorting through old email today, I came across a message dated March 18, 2023.

Its subject was direct:

You’re invited to use the OpenAI GPT-4 API.

The body told me I could now use GPT‑4 with an 8K context window through the API.

GPT‑4 had been released only days earlier. Developers had to apply, wait, and receive access as OpenAI gradually expanded availability. The launch material described a standard context length of 8,192 tokens, with a 32,768-token version available on a limited basis. At the time, API access itself felt like a small door that had just opened.

More than three years later, that message reads less like a product notification and more like a time capsule.

Bigger numbers are only the most visible change

Early developers became familiar with context windows measured in 4K or 8K. While writing prompts, we counted the remaining space, trimmed source material, split long documents into smaller pieces, and devised ways for one request to carry the result of the previous one.

By 2026, million-token context windows had entered the mainstream of frontier models. OpenAI's current model catalog lists the GPT‑5.6 family with a context window of roughly 1.05 million tokens. Google's long-context documentation likewise describes multiple Gemini models that support one million tokens or more.

This is not simply a matter of fitting in more text. Code, images, audio, video, and large document sets can now form the background of a single task. Material that once had to be fragmented, indexed, and summarized has a better chance of sharing one working context.

But a longer context window is not perfect memory, and it does not guarantee that a model will notice what matters. More material can also introduce more noise, cost, latency, and false associations. The important skill remains deciding what information to provide, in what order, and how to verify that the model understood the critical constraints.

The real change is the unit of interaction

Three years ago, my usual pattern was “question and answer”:

1. Write a prompt.
2. Wait for the model to generate a response.
3. Copy the result.
4. Complete the remaining work myself.

Today, more tasks look like “goal, context, action, and verification”:

1. State the desired outcome and the definition of done.
2. Provide the repository, documents, and current state.
3. Allow the model to use search, files, a terminal, or other tools.
4. Let it execute a sequence of dependent steps.
5. Confirm the result through tests, builds, diffs, or human review.

OpenAI's current model and Responses API documentation lists function calling, web search, file search, and computer use among the available tools. Models no longer only tell us how something might be done. Within the authority they are given, they can participate in the work itself.

That is the most important difference I see between a chat model and an agent: the first delivers a piece of content; the second advances a task whose state changes over time.

Programming has not disappeared; attention has moved to both ends

When a model can read code, edit files, run commands, and inspect results, programmers do not suddenly become irrelevant. Instead, our attention moves toward both ends of the task.

Before action, the problem must be defined more clearly:

• What is the goal, and what is out of scope?
• Which sources are authoritative, and which are only references?
• Which permissions can be granted, and which actions require confirmation?
• Should the system stop, retry, or roll back when something fails?

After action, the result must be verified more rigorously:

• Do the code and build pass?
• Does the page truly match the requirement, rather than merely having been generated?
• Has the external state actually changed?
• Can the outcome be explained, reproduced, and audited?

Three years ago, we were learning how to write a better prompt. Today, we must also learn how to design context, tools, permissions, checkpoints, and acceptance criteria.

Capability can be delegated; responsibility cannot

As agents gain the ability to perform real actions, boundaries become more important.

Asking a model to summarize an article is not the same authorization as asking it to modify a production database. Asking it to draft an email is not the same risk as allowing it to send that email directly to a customer. A mature agent system should not only pursue what it can do. It should make explicit:

• whether access is read-only or writable by default;
• which actions require human approval before execution;
• how targets, directories, accounts, and data scopes are constrained;
• how the necessary operation history is retained;
• how the system stops and recovers when something goes wrong.

Models can take on more action, but judgment and accountability do not disappear. Someone must still answer: Why are we doing this? What evidence supports the decision? Who carries the risk? Is the result acceptable?

How will we see today three years from now?

That old email now feels like a ticket I happened to keep.

In 2023, I applied for a chance to access a model. By 2026, we were learning how to help models understand long-term goals, use tools, move through multiple steps, and complete work under human supervision.

What strikes me is not how many times a parameter increased. It is how compressed the timeline became. Capabilities that once belonged to the distant future did not arrive gradually over decades; they quietly became ordinary between a handful of version updates.

Perhaps, three years from now, the million-token context windows and agents that impress us today will look like this email: an old object left behind at the moment the future had only just begun.

Source notes

• OpenAI: GPT‑4 research — GPT‑4 launched in March 2023 with a standard 8,192-token context and limited access to a 32,768-token version.
• OpenAI: model catalog — At publication, the frontier GPT‑5.6 family lists a context window of roughly 1.05 million tokens and support for multiple tool categories.
• Google AI: Long context — An overview of the capabilities, uses, and limits of Gemini models with contexts of one million tokens or more.