Computer science students are taught to admire pretraining. Today I want to show you its limit.
Pretraining is one of the great technical achievements of our time. A large language model can absorb enormous amounts of historical human output — books, articles, code, arguments, transcripts, documentation, images, labels, examples — and compress that history into a prediction machine. Once trained, it can produce sentences, code, summaries, plans, explanations, classifications, and designs that feel intelligent because the underlying prediction is so good.
But we need to be precise.
The LLM does not summarize because summarizing is its essence.
It does not write because writing is its essence.
It does not classify because classification is its essence.
It predicts.
Everything else is an action-space built around prediction.
When the model writes an email, it is predicting the next token in a form we call an email. When it summarizes a document, it is predicting the compressed shape of that document. When it writes code, it is predicting the next symbolic move in a programming language. When it plans, it is predicting a sequence of plausible future steps. These are impressive actions, but underneath them is the same core operation: prediction.
That is the first distinction I want you to keep today.
AI, at its current center, is production-grade prediction.
Agents are something else. An agent is a prediction machine given hands. It can call tools, update databases, move files, send emails, create tickets, write summaries, alter a calendar, trigger workflows, and change symbolic states in the world. That matters. But the agentic layer is built on top of prediction. If we confuse the prediction machine with the agent, we misunderstand where the real limitation lives.
The real limitation is not the denominator.
The real limitation is the numerator.
Let me introduce the equation we will use throughout this lecture series:
R = A / E
Reality is the quotient of the ratio between Actual and Expectation.
Expectation is the denominator. This is where the prediction machine lives. In a human being, Expectation is produced by the organism’s prediction machinery: memory, pattern recognition, anticipation, interpretation, habit, imagination, and orientation toward ideas. In an AI system, Expectation is produced synthetically by the model. The LLM generates a guess.
Actual is the numerator. Actual is what arrives. Actual is not guessed. Actual is not negotiated. Actual is not a probability cloud. Actual is the given correction from Reality. It is what happened, indexed to the observable the entity is trying to predict.
If I reach for a cup and it is heavier than I expected, the heaviness is Actual.
If I enter a room and the room is colder than I expected, the cold is Actual.
If I send a proposal and the client says no, the no is Actual.
If I believe someone is happy and then hear the tremor in their voice, that tremor is Actual.
Expectation is the guess.
Actual is the arrival.
Reality is the quotient between the two.
Now this is where GPT becomes philosophically interesting. GPT is pretrained. That word matters. Pretraining means the model has been shaped by historical Actuals. It has absorbed the traces of human history into weights. But once deployed, the model is not in the same relationship to Actual that you and I are.
Humans are not merely pretrained.
Humans are live-trained.
A human being is continuously corrected by Actual. We receive a dense numerator for free. We do not have to request Reality. We do not have to call a tool to learn that we are hungry, that the light changed, that a room grew tense, that a person hesitated, that the road is slick, that a child is too quiet, that the pan is burning, that the dog is nervous, that the audience is bored, that the joke failed, that someone is lying, or that something important has shifted.
Actual arrives continuously.
It arrives through the body.
It arrives through the senses.
It arrives through consequence.
And it arrives indexed to us.
This matters enormously. The Actual that arrives to me is not simply the universal state of the world. It is the projection of the world onto the observable that matters to me in that moment. The hawk’s shadow is Actual for the bird. It may not be Actual for the rock beside it. The same event can arrive differently depending on what the entity is structured to predict.
The human numerator is dense, indexed, and live.
The AI numerator is thin, mediated, and externally supplied.
That is the numerator problem.
When we give an AI system a prompt, that prompt is a tiny slice of Actual. When we give it a PDF, that PDF is a tiny slice of Actual. When we let it retrieve a passage from a vector database, that retrieved passage is a tiny slice of Actual. When we let it browse the web, use an API, inspect a screenshot, query a CRM, or call a tool, we are improving its numerator-interface.
But we should not confuse that with the human relationship to Actual.
Retrieval is not experience.
A context window is not a life.
A checkpoint is not a childhood.
A log file is not memory.
A database field is not Reality.
These are representations. Some are useful. Some are accurate. Some are authoritative. But they are not the same as dense, continuous, embodied Actual.
Now, let me be careful with one word: episodic.
It is tempting to say that the AI numerator is episodic. But that gives AI too much credit. Human episodic memory is rich. It is long. It is layered. It is versioned. We do not simply overwrite yesterday when today arrives. We carry prior versions of Reality forward. We remember childhood. We remember last week. We remember what someone used to mean to us and what they mean now. We remember promises, betrayals, successes, injuries, lessons, warnings, embarrassment, triumph, regret, tone, place, atmosphere.
Human memory preserves versions.
AI does not have that kind of native continuity.
When an AI model is trained, it becomes a checkpoint. When its weights are updated, the internal model changes. Engineers can preserve old checkpoints externally, but the model itself is not remembering its former world the way a human remembers a former self. It does not carry Reality forward as lived versioning. It has pretrained compression, current context, maybe external memory, maybe tool access, maybe retrieval. But the continuity is not native in the human sense.
That is why current agents can look brilliant and still behave strangely.
They are strong in the denominator.
They are weak in the numerator.
They can act inside simulated Reality. They can draft the memo, summarize the meeting, classify the support ticket, write the code, update the CRM, move the file, generate the invoice, or send the email. These are real actions, but they are actions in symbolic environments. They happen where the world has already been reduced to tokens, records, fields, instructions, permissions, statuses, and workflows.
This is why bureaucracy is the first great habitat of AI agency.
Bureaucracy is not the jungle. Bureaucracy is not embodied Reality. Bureaucracy is the artificial world humans built out of words, forms, ledgers, laws, credentials, titles, approvals, claims, and records. It is the machinery by which strangers trust each other at scale. A bank account is a record of trust. A contract is a record of obligation. A diploma is a record of institutional recognition. A passport is a record of political identity. A calendar invite is a record of expected coordination. A CRM is a record of expected commercial relationship.
AI thrives there because bureaucracy has already thinned Reality into machine-readable form.
This is the key.
AI is not becoming powerful because it has mastered Reality.
AI is becoming powerful where humans have already replaced Reality with records.
That is why AI appears agentic first in law, finance, education, healthcare administration, insurance, customer service, HR, software development, compliance, marketing, sales operations, government, and internal corporate workflows. These are symbolic habitats. They are already made of language and structured records. They are not easy, but they are pre-reduced.
For a model, a legal brief, a support ticket, a loan application, a transcript, a purchase order, a Slack thread, and a medical chart are all closer to its native environment than a crying child, a dangerous intersection, a failing marriage, a factory floor, a surgery, or a tense negotiation.
That does not mean AI cannot help in those domains. It can. It already does. But the help becomes reliable only when Actual is captured with enough fidelity, and when the system has a way to know whether its action changed the actual thing or merely changed the record of the thing.
A CRM entry is not the customer.
A medical chart is not the patient.
A loan application is not the borrower.
A legal filing is not justice.
A dashboard is not the business.
A calendar invite is not the meeting.
A sensor reading is not the factory.
A support ticket is not the frustrated person.
An AI agent can manipulate the representation. The harder question is whether it knows when the representation is false, stale, incomplete, misleading, or irrelevant.
That is the real engineering frontier.
Not prediction alone.
Prediction is already powerful.
The frontier is Actual-coupling.
So what would better Actual-coupling require?
First, it requires reliable observables. You cannot build a serious agent if you do not know what counts as Actual. “Make the customer happy” is not an observable. “Reduce refund requests by 20% over 60 days without lowering reorder rate” is closer. “Update the CRM” is not the same as “advance the customer relationship.” The system needs to know what it is predicting and what Actual will count as correction.
Second, it requires sensing. In software environments, sensing may mean APIs, logs, database states, event streams, telemetry, version control, payments, user behavior, and error reports. In physical environments, sensing may mean cameras, microphones, thermal readings, location, motion, pressure, inventory scans, biometric data, or human confirmation. Without sensing, the agent acts blind.
Third, it requires verification. The system must distinguish between “the record says X” and “X is true.” This is harder than it sounds. A shipping system may say the package arrived. The customer may say it did not. The agent must know that these are competing Actual projections, not merely conflicting strings.
Fourth, it requires versioned memory. The system must preserve the sequence of Reality corrections. What did we believe before? What arrived? What changed? What did the agent do? What was the consequence? What did the human approve? What failed? What pattern repeated? Without versioning, the system cannot become less brittle over time.
Fifth, it requires consequence feedback. An agent becomes more real when its predictions are corrected by outcomes. Did the customer respond? Did the invoice get paid? Did the patient improve? Did the code compile? Did the campaign work? Did the meeting happen? Did the part arrive? Did the action reduce uncertainty or create more of it?
Sixth, it requires boundaries. Agents need permissions, audit trails, rollback, human escalation, and scope control. A powerful denominator connected to a thin numerator and broad permissions is dangerous. It can confidently act on representations that are wrong.
This is why serious AI implementation is not just prompt engineering. It is Reality engineering.
The organization has to define observables, clean up systems of record, build feedback loops, preserve history, instrument workflows, and decide where a machine may act without human review. The hard work is not merely “put an agent on it.” The hard work is making sure the agent can receive enough Actual to be corrected by Reality.
Let me give a simple example.
Suppose a company wants an AI sales agent.
The easy version reads emails, writes follow-ups, updates the CRM, drafts proposals, and schedules meetings. That is useful. But mostly it is acting inside symbolic Reality.
The harder version knows whether the customer is actually moving closer to purchase. It knows whether silence means disinterest, delay, confusion, politics, budget trouble, technical concern, or internal conflict. It knows that a cheerful email can still be a no. It knows that a postponed meeting is not just a calendar change but a shift in probability. It knows that one stakeholder’s approval may not matter if another stakeholder has veto power.
A human salesperson receives all kinds of Actual that never enter the CRM: tone, timing, hesitation, status, urgency, mood, friction, trust, embarrassment, enthusiasm, avoidance. The AI agent does not get those for free. Someone has to build the numerator-interface.
Now consider healthcare.
A model can summarize a chart beautifully. It can explain a diagnosis. It can compare symptoms. It can suggest next steps. But the chart is not the patient. The patient’s Actual includes pain, pallor, gait, smell, anxiety, family context, medication behavior, silence, fear, financial pressure, and the strange detail that does not fit the chart. The clinician receives a dense numerator. The AI receives whatever has been captured and supplied.
This does not make AI useless. It tells us where to place it.
AI is extremely useful where the relevant Actual has already been captured with high fidelity.
AI is risky where the representation is mistaken for the thing.
Now, as computer science students, you may ask: is this just a temporary limitation? Won’t multimodal models, robots, wearables, sensors, memory systems, and continuous learning eventually solve this?
They may improve it dramatically.
But improvement is not the same as identity.
A robot with cameras still does not automatically have a human numerator. A multimodal model with video still does not automatically have lived memory. A model with a memory store still does not automatically have versioned personal history. A system with sensors still needs to know which observables matter. A system with logs still needs to know what counts as consequence.
The question is not whether we can add data.
The question is whether the machine is continuously corrected by Actual in a way that is dense, indexed, versioned, and action-coupled.
That is a much higher bar.
This is also where the Reality Equation becomes useful as an engineering model.
R = A / E
If E improves but A remains thin, the system becomes more fluent without becoming more grounded.
If E becomes powerful and A is stale, the system becomes persuasive about the past.
If E becomes powerful and A is wrong, the system becomes confidently misaligned with Reality.
If E becomes powerful and A is narrow, the system becomes superhuman in a narrow bureaucratic corridor.
But if E is powerful and A is dense, indexed, verified, versioned, and consequence-bearing, then we are approaching real agency.
That is the path from chatbot to agent to real agent.
And it is not just a model-size problem.
It is a Reality-interface problem.
This is why “pretrained” is such a revealing word. Pretraining gives the model a synthetic past. It gives the model compressed history. But it does not give the model continuous life. It does not give the model a body. It does not give the model native consequence. It does not give the model a childhood. It does not give the model the long versioned memory of being corrected by Actual every second of every day.
GPT is pretrained.
Humans are live-trained.
The machine’s past is compressed into weights.
The human’s past is carried as memory, habit, body, expectation, fear, hope, skill, trauma, taste, judgment, and attention.
That difference is not sentimental. It is architectural.
So let me close with the main lesson.
When you look at an AI system, do not ask only, “How smart is the model?”
Ask, “What Actual can reach it?”
Ask, “What observable is it predicting?”
Ask, “How does Reality correct it?”
Ask, “Does it preserve the sequence of corrections?”
Ask, “Can it tell the difference between the representation and the thing?”
Ask, “What happens when the record is wrong?”
Ask, “Where is the numerator?”
Because the future of AI agency will not be decided by prediction alone. Prediction is already powerful. The next frontier is Actual: how machines receive it, verify it, remember its versions, and allow it to correct their guesses.
Until then, AI agents will remain brilliant synthetic predictors operating inside managed simulations.
They will do enormous work there.
They will change bureaucracy.
They will change finance.
They will change law.
They will change education.
They will change medicine.
They will change the symbolic machinery of civilization.
But human-like agency requires more than prediction with hands.
It requires Reality with fidelity.