In any intelligent system, especially those that adapt, respond, or reason, context is everything. It shapes what a system knows, how it interprets input, what decisions it makes, and how it interacts with users. But “context” is one of those overloaded words we all use without always unpacking what we mean.
In a previous article, we defined context as the surrounding circumstances or information that give meaning to a piece of data. It’s the “who, what, when, where, and why” that gives clarity to the “what.”
Today, we’ll discuss context across two key dimensions: source and type. Together, they help us understand not just what context is, but how it enters a system and how that shapes user experience.
Context by Source: Where It Comes From
We find it helpful to start with a simple question: Where did this context come from?
Internal context
These are the things the system already “knows” based on its own state or data. This includes everything the system can access without reaching beyond its current environment, but encompasses more than just backend state.
- System-internal context might include session state, application settings, logs, or cached computations.
- User-provided context includes things like uploaded documents, account data, preferences, saved searches, and in-progress work. It’s internal in the sense that it’s accessible within the product not fetched from an external API, but it originates from the user.
External context
This is information pulled in from third-party sources. That could be public datasets, real-time APIs (like weather or stock prices), or integrations with enterprise tools.
Derived or created context
These are signals that didn’t exist until the system generated or inferred them. Think: vector embeddings, clusters, scores, summaries, or any result of transformation or ML inference.
Thinking of context through the source lens helps us think about how a system puts the pieces together. Some context is already there, sitting inside the app or uploaded by the user. Some has to be pulled in from outside sources. And some doesn’t exist until it’s inferred or constructed on the fly. Understanding where each piece comes from helps us design systems that can reason across partial, messy, or fragmented inputs and still build a useful picture of what’s going on.
Context by Type: What Form It Takes
Even once you know where context came from, it helps to ask: What kind of thing is this?
Some common types:
- Structured and unstructured data (e.g., transaction records, support tickets)
- APIs or tools the system can call to extend its knowledge or capability
- ML models that add inference or prediction
- User behavior (e.g. what the user just did or tends to do)
- User profile (e.g. traits or preferences about the individual or org)
- User input (e.g. feedback or direct statements/requests/directions)
- Task context of what the user is trying to do, or what the system thinks the task is
- Temporal context (e.g. time of day, recency, frequency)
- Social or collaborative signals (e.g. what peers or teams are doing that shapes experience)
Some of these are stable. Some shift moment-to-moment. Some are explicit; others are inferred. All of them shape how a system interprets and responds.
Why Context Matters: Use Cases and Implications
Understanding context is foundational to how systems deliver value. It determines what’s relevant to a particular query or task, shapes how well the system interprets user intent, and guides what information is highlighted or summarized in the moment. Context also drives personalization, helping the system tailor responses to what’s most useful for each individual user right now.
Ultimately, context influences decision-making by providing additional signals that models or agents can consider. By being explicit about the context in play, we’re better equipped to debug, improve, and align systems with real user needs. It also builds trust, because when users can see what the system is using to make decisions, they feel more confident guiding and collaborating with the technology.
At Bordo, we recognize that context is central to how decisions get made and how users experience those decisions and not a “behind-the-scenes detail”. That’s why we prioritize transparency around the context our systems use. We make sure users can see what data, signals, or inferred information are informing recommendations or actions, presented in a way that’s clear and accessible. This approach helps users understand and trust the system, gives them the ability to provide feedback or correct misunderstandings, and ultimately creates a collaborative relationship between human+AI.
