Modern AI systems are getting remarkably good at context.
We retrieve relevant documents. We preserve conversation history. We summarize long interactions. We give models access to tools, databases, memories, user preferences, system instructions, and increasingly large context windows.
This emerging discipline is often called context engineering.
And it matters.
An intelligent system cannot make good decisions if it does not have the information necessary to understand what is happening.
But there is a deeper problem.
Having the right information is not the same as understanding the situation.
Context tells an AI what it can know.
A situation tells it what that knowledge means right now, what matters, and what the moment calls for.
That distinction may be fundamental to building more intelligent systems.
Context Is Necessary
Consider an AI assistant helping manage a business.
A customer hasn't responded to an email for seven days.
To respond intelligently, the AI might need to know:
- who the customer is,
- what previous conversations occurred,
- whether there is an open proposal,
- when the last communication happened,
- what commitments were made,
- the customer's history with the company,
- and perhaps what the salesperson normally does in cases like this.
Without this information, the AI is operating blindly.
Context engineering attempts to solve exactly this problem.
It asks:
What information should the model have available in order to perform this task?
Retrieval, memory, prompt construction, tool selection, conversation history, summarization and personalization can all contribute to that context.
These capabilities are essential.
But now suppose the system has all of that information.
There is still another question:
What is actually happening?
Information Does Not Tell Us What Matters
Take a simple event:
The customer hasn't responded for seven days.
That fact alone does not determine what should happen next.
For a salesperson, it might mean:
A promising prospect is going cold.
For customer support, it might mean:
The customer probably considers the issue resolved.
For accounts receivable, it might mean:
An unpaid account may be becoming a collection risk.
The observable event can be identical.
The underlying data can be identical.
And yet the situations are different.
Why?
Because a situation does not exist solely inside the event.
It arises from the relationship between what is happening and the agent experiencing it—its goals, responsibilities, expectations, capabilities, history and possible consequences.
That makes a situation inherently relational.
Event, State, Intent, Context and Situation Are Not the Same Thing
These concepts are often blended together, but they describe different things.
An event tells us that something happened.
A payment failed.
A state describes a current condition.
The order remains unpaid.
An intent describes something an agent wants to accomplish.
The customer wants to complete the purchase.
Context provides information that may help interpret what is happening.
This is a long-term customer, the card worked yesterday, two previous attempts have failed, and the bank is reporting intermittent payment-processing problems.
A situation interprets these observations relative to an agent and its goals.
A valuable customer is attempting to purchase but is being blocked by what may be a temporary payment failure.
That interpretation changes what an intelligent system should do.
The system might preserve the order, avoid repeatedly charging the card, offer another payment method, inform the customer that the problem may be temporary, or wait and retry.
The situation organizes the response.
State Machines Are Not Situation Machines
Computing has spent decades representing states.
A state machine might say:
Payment Pending → Payment Attempted → Payment Failed
An event causes a transition from one state to another.
This is enormously useful. Much of modern software depends upon it.
But knowing the state does not necessarily tell us the situation.
Imagine two customers whose payments fail.
Both transactions can occupy exactly the same software state:
PAYMENT_FAILED
Yet one may be an ordinary card decline.
Another may involve a high-value customer whose recurring payment suddenly failed after years of successful transactions.
Another may occur during a widespread payment processor outage.
Another may show patterns consistent with attempted fraud.
Same state.
Very different situations.
A situation therefore cannot simply be another label for state.
State describes condition. Situation interprets significance.
Intent Is Not Situation Either
Intent recognition has also become an important part of AI systems.
A user says:
“Can you move my appointment?”
The system recognizes the intent:
Reschedule appointment.
Useful.
But imagine the appointment is surgery tomorrow morning.
Or a routine haircut next month.
Or an immigration interview that cannot simply be rescheduled through the same process.
The linguistic intent may be identical.
The situation is not.
Intent tells us something about what someone wants.
Situation tells us what is happening around that intent and what consequences follow from it.
The Missing Question
Much of today's AI architecture begins with something like:
What context should we give the model?
Situational AI proposes that an intelligent system must continuously ask another question:
What situation am I in?
That question changes the architecture.
Instead of merely assembling information and asking a model to reason over it, the system attempts to recognize the situation that is emerging.
That situation can then determine:
- which context matters,
- which memories should be retrieved,
- which knowledge is relevant,
- which tools or capabilities should become available,
- which goals take priority,
- which policies and constraints apply,
- whether the system should act, ask, wait or escalate,
- and what successful resolution looks like.
The relationship therefore becomes:
Situation → Relevant Context → Reasoning → Response
rather than treating context itself as the organizing principle.
Context Engineering Becomes Part of Situational Intelligence
This does not make context engineering obsolete.
Quite the opposite.
Context engineering is necessary for intelligent systems.
But situation recognition can provide the reason for assembling particular context in the first place.
If an AI recognizes:
Customer may be at risk of leaving
then customer history, unresolved support tickets, recent complaints, account value and previous retention attempts suddenly become highly relevant.
If instead it recognizes:
Customer is requesting routine account information
most of that information may be unnecessary.
The world contains vastly more information than any intelligent system can consider at once.
Intelligence therefore cannot simply mean having context.
It must include determining which context matters now.
Situations Change
Situations are also not static.
Consider a business negotiation.
The initial situation may be:
Prospect evaluating proposal.
A competitor enters.
The situation becomes:
Competitive evaluation underway.
The customer stops responding.
Now:
Decision process may be stalled.
The customer asks for revised pricing.
Now:
Commercial negotiation active.
Nothing about intelligence says these situations must have predetermined names.
What matters is that the system recognizes meaningful changes in what is happening and adjusts its behavior accordingly.
This suggests a continuous cognitive loop:
Sense → Recognize Situation → Reason → Act → Observe → Recognize Again
The world changes.
The situation changes.
Intelligence must change with it.
Intelligence Also Anticipates
Recognizing the current situation may not be enough.
Humans constantly project situations forward.
A driver does not merely recognize:
The vehicle ahead is braking.
The driver anticipates:
If it continues braking, I may need to stop.
A business owner sees:
Our largest customer has reduced orders for three consecutive months.
The important intelligence may be:
This relationship could be deteriorating.
Situational intelligence therefore includes another capability:
What situation might this become?
That creates a relationship between situations across time:
Current Situation → Possible Future Situations
An intelligent system can then act not only in response to what has happened, but in anticipation of what may happen next.
Situations as Computational Objects
Today, large language models often infer situations implicitly.
Give a capable model enough information and it may correctly understand what is happening.
But Situational AI asks a different architectural question:
What happens if situations become explicit computational objects?
A situation could carry information such as:
- what is happening,
- who or what is affected,
- relevant goals,
- evidence supporting the interpretation,
- uncertainty,
- risks,
- expected responses,
- available capabilities,
- related past situations,
- possible future situations,
- and criteria for resolution.
The system could detect situations, compare them, retrieve analogous situations, reason about them, observe their evolution and learn from their outcomes.
The situation would no longer disappear when an individual inference ends.
It could persist.
And that persistence matters.
Because the real world does not reset after every prompt.
From Prompt-Driven AI to Situation-Driven AI
Most interactions with AI today begin because someone prompts the system.
A human asks.
The AI responds.
But many important situations do not begin with a question.
A customer stops responding.
A shipment becomes late.
A machine begins behaving abnormally.
A project gradually falls behind.
A patient measurement changes.
A financial pattern becomes unusual.
Nobody necessarily asks the AI anything.
Something simply changes.
An intelligent system operating in the world must be capable of recognizing that the change matters.
That is the transition from purely prompt-driven intelligence toward situation-driven intelligence.
The system is not merely waiting to be told what to think about.
It is continuously determining what deserves attention.
What Matters Now?
Artificial intelligence has made extraordinary progress in answering questions, generating content, retrieving knowledge and reasoning over information.
Context engineering will make these systems considerably better.
But intelligence requires something more fundamental than access to information.
It requires recognizing significance.
What is happening?
Who does it matter to?
Why does it matter?
What might happen next?
What does this situation call for?
That leads to a broader proposition:
Intelligence isn't only knowing what is true. Intelligence is recognizing what matters now and what that calls for.
Context gives intelligence its information.
Situation gives information its meaning.