What is agentic context?
Agentic context is the structured picture of the current situation that an AI agent reads before it acts. It is how the agent knows what is going on beyond the words of the prompt.
Beyond the prompt
An agent’s prompt says what to do. Agentic context says what is true. It is the structured state the agent reads to ground its decision: who the user is, what they have done, where they are in a flow, what the tools returned. Without it, the agent reasons in a vacuum and guesses.
What goes in it
Good context is current and relevant. For a customer-facing agent that means the live session: pages viewed, the last action and how long ago, items in the basket, a search that failed. Delivered as JSON for a tool call or as a short narrative in the prompt, it is the difference between an agent that knows and one that asks.
The parts usually fall into four groups:
- The task. What the agent was asked to do, and the steps and tool results so far.
- The user. Who they are, where that is known, and facts that last: their plan, their past orders, preferences they have stated.
- What the user is doing now. The recent behavior in this visit, in order, with how long ago each step happened.
- The rules. What the agent may and may not do for this user: offers they qualify for, actions that need a person.
The third group is the one most agents lack. The conversation tells the agent what the user said. Behavior tells it what they did, which they often do not think to mention.
Examples
These are illustrations of the same idea in different places.
Example: a support assistant
A customer opens the chat and types “this isn’t working”. Without context the assistant has to ask what “this” is. With the session in its context, it can see the customer has tried to apply the same discount code three times and reached the payment page twice. It can start with the code.
Example: a shopping assistant
A shopper asks for “something warmer”. The assistant’s context shows they have spent the visit on lightweight running jackets in one size. It can suggest an insulated running jacket in that size, instead of a winter coat.
Example: a backend agent with no chat
An agent that decides whether to offer a trial extension never talks to the user. It reads context when a trial is about to end: how often the user came back, which features they set up, whether they invited anyone. The decision rests entirely on what the user did, because there is no conversation to read.
Format and size
Context is read on every call, so it costs tokens and time each time. A short list of the most recent events and a few computed values, like how many times a search failed, usually serve the agent better than a raw event log. Structured JSON suits a tool call the agent makes when it needs the state. A short narrative suits a prompt that is assembled before the agent starts. Context engineering vs prompt engineering covers how teams decide what goes in.
Context, not memory
Context and memory overlap but differ. Memory is what the agent carries forward over time; context is the snapshot it reads for the decision in front of it. The snapshot is often assembled from memory plus whatever is happening right now. See what is agent memory for the other half.
How Signals provides it
Signals collects behavioral events, computes attributes from them, and serves an agentic context: a customer’s recent activity as JSON or as a short narrative a model can read. Any agent that can call a REST API or an MCP server can read it. What the agent does with it stays in your code.
See it on your own traffic
Add the SDK, define one attribute, and see an attribute updating against your own traffic in the first session. The free tier runs on the real engine: no card, no sales call.