Your agent remembers what the customer did, as well as what they said.
An agent that opens with a profile from before this session is guessing. Signals hands it what this customer has been doing, as JSON or narrative a model reads without a parser, before the first reply.
The agent below is reading your session. It will speak up to five times on its own, then wait for you.
Signals returns this
connectingWaiting for the first read of your session.
Your agent uses it
The agent is reading your session. It will speak first, on its own.
The agent learns what happened from the customer.
The CRM profile trails the session, and raw events mean nothing to a model. So the agent opens by asking what went wrong.
Agents that start from what the customer just did.
Each of these reads the session before the agent speaks, so the customer does not have to retell it.
Shorter handle time
A customer who writes in has to explain from the start. Signals gives your agent the page they were stuck on and the error they hit, so it skips the first questions.
Higher assisted conversion
The assistant answers from the catalog. Signals gives it what this customer compared and dropped in this visit, so it answers about those.
Fewer exits after a failed search
Help waits to be asked. A rule fires after the third failed search and opens your agent with the session in hand.
Higher CSAT
Frustration shows in the chat after it has built up. Signals counts the errors this session, so your rule hands the customer to a person sooner.
One call returns what the customer has been doing, in words or JSON.
Add a Snowplow SDK
Web, mobile or server. Events start flowing, validated against your schemas. No event stream to build first.
Choose what the agent should know
An agentic context holds the recent events you pick, such as pages, searches and errors. Attributes hold the counts your rules check.
Call it from your agent, or over MCP
Works with the agent you already run, on any framework that can call an API. Signals supplies the context; the model decides.
Step by step: Give an AI agent session context →The background: AI agents and memory, explained →
- Claude
- LangChain
- LangGraph
- LlamaIndex
- CrewAI
- OpenAI Agents SDK
- Vercel AI SDK
- Mastra
- Pydantic AI
- Google ADK
- CopilotKit
- Amazon Bedrock
- Vertex AI
The session, in the prompt, before the first reply.
Your backend reads the agentic context as narrative for the prompt, and the service for the counts your own rules check. The model sees what happened; your code keeps the thresholds.
npx plugins add snowplow/skillsimport { Signals } from "@snowplow/signals-node";
const signals = new Signals({
baseUrl, apiKey, apiKeyId, organizationId,
});
// What they did this session, as text the model reads as is.
const activity = await signals.getAgenticContext({
name: "support_session",
identifier: sessionId,
format: "narrative",
});
const counts = await signals.getServiceAttributes({
name: "support_agent",
attribute_key: "domain_sessionid",
identifier: sessionId,
});
const system = [supportPrompt, "What this customer did before the chat:", activity].join("\n\n");
if (counts.errors_this_session >= 3) handOffToPerson(sessionId);Add Snowplow Signals to this support agent so it knows what the customer did before the chat opened. Add the Node SDK, define an agentic context named support_session over page views, searches and errors, read it with getAgenticContext in narrative format, and add it to the system prompt before the first model call. Leave the agent's instructions and tools as they are, so the only thing that changes is what it knows.
An agentic context covers one session, up to the number of events or the age you set. For what a customer did in earlier visits, add attributes keyed on the user.
The feature: Agentic context →Full reference: Defining agentic contexts →
The first reply knows what happened.
Read before the first reply, p50 in-region
JSON for tools, narrative for prompts
Shared by the agent and the site it is helping with
Before you give it to your agent
Is this a memory framework?
No. Memory frameworks such as mem0, Zep and Letta recall what the customer said. Signals holds what the customer did, such as pages, searches, errors and time on step. They sit side by side, one for recall, one for behavior.
Does Signals decide what the agent says?
No. Signals hands the agent what the customer is doing. What it says, and when it hands off, is your model's call and your code's.
Which agents does it work with?
Any agent that can call an API or an MCP server. Agentic context comes back as JSON or narrative over the REST API, the Node.js or Python SDK, or the MCP server.
How far back does it go?
An agentic context covers the current session, up to the number of events or the age you set. Attributes keyed on the user carry what happened in earlier visits.
Do I need an event stream already?
No. Collection is part of Signals. Add a Snowplow SDK and events start flowing. If you already run Snowplow, Signals reads the pipeline you have.
Where does it run?
Managed SaaS, or a private deployment in your own AWS or GCP account. Same architecture either way.
Give your agent this session before its first reply.
Add the SDK, define an agentic context for your support surface, and read it from your agent, the same way the agent above read your visit. The free tier runs on the real engine: no card, no sales call.