Give your AI agent customer context.
Signals hands your agent what the customer is doing in this session, what they did before and any scores you keep in your warehouse, before its first reply.
The agent below is reading your session.
An agent is talking to you
connectingYour agent only knows what the customer types.
Chat memory holds the conversation. Their visits, orders and any scores your models keep sit in other systems, and reach the agent too late for its first reply.
Your agent reads the whole customer before it replies.
Signals keeps what the customer does this session, what they did in earlier visits and tables synced from your warehouse, such as a churn score or plan tier. Your agent reads the session as JSON or narrative and the rest as attributes, over the API or MCP, each read in 6ms, in-region. Your model decides what to say.
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
One conversation, start to finish.
Pick an agent to see what it knows before each reply and what it does with it.
- Opens the chat
The agent sees the error they hit
last_error: pickup_unavailableIt offers next-day delivery instead of asking what went wrong. - Is a regular
The agent knows their order history
orders_last_year: 6It talks to them as a returning customer, not a stranger. - Is likely to leave
The agent sees your churn score
churn_score: 0.82Your rules let it offer a refund without an escalation. - Keeps hitting errors
A person takes over sooner
errors_this_session: 3Your rule hands the chat to a person before frustration builds.
- Asks for help
The assistant knows what they compared
compared: trail_shoe_2, trail_gripIt answers about those two, not the whole catalog. - Asks about size
It knows what they bought before
last_size_bought: 10It suggests the size they usually buy. - Is a loyalty member
It knows their tier
loyalty_tier: goldIt mentions the free returns gold members get. - Searches fail
The assistant opens after failed searches
Triggers to Braze, Kafka and webhooksfailed_searches: 3A trigger fires, and your app opens the assistant with the session in hand.
- Opens the copilot
The copilot sees where they are stuck
failed_imports: 2It starts with the import error, not a generic greeting. - Asks how to do something
It knows their plan
plan_tier: teamIt only suggests features their plan includes. - Is new to the product
It knows what they have set up
setup_steps_done: 3It skips the steps they already finished.
The customer, in the prompt, before the first reply.
Your backend reads the agentic context as narrative, and the customer's attributes keyed on their user ID, and puts both in the prompt. The model sees what happened and who they are; 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",
});
// Earlier visits and synced warehouse values, keyed on the user.
const customer = await signals.getServiceAttributes({
name: "support_agent",
attribute_key: "user_id",
identifier: userId,
});
const system = [
supportPrompt,
"What this customer did before the chat:", activity,
"Their history and scores:", JSON.stringify(customer),
].join("\n\n");
if (customer.churn_score > 0.8) offerRetention(userId);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, define a service named support_agent with the attributes you keep on the user, read it keyed on user_id with getServiceAttributes, and add both 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
Frequently asked questions
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, and warehouse attributes bring in tables such as a churn score or plan tier.
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 the whole customer before its first reply.
Add the SDK, define an agentic context and the attributes your agent needs, and read them 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.