AI SDR agent context and memory

Give an AI SDR agent a managed memory system. The prompt is one input in a larger context, and that context changes from action to action. Every agent harness eventually meets a context window too small for everything the model might remember.¹ As sessions grow, the harness decides what stays in the working set, what gets compressed, and what gets retrieved later.² Memory architecture can matter more than changing the underlying model.³ Set retention and retrieval rules before polishing prompt wording.

Set the memory boundary

Separate what the agent needs for the current action from what should survive the interaction. This gives it a small place to reason and a durable place to return to.

Context is the set of tokens included when a model samples from a large language model.⁴ Prompt engineering covers writing and organizing instructions for the model.⁵ Context engineering covers curating and maintaining the information available during inference, including material outside the prompt.⁶

Short-term context belongs to the active session, while long-term memory lives in a persistent profile graph.⁷ A state object can serve as a local-first memory store with a structured profile and notes.⁸ Let that state persist across runs so memories, notes, or preferences can evolve.⁹

For an outbound agent, create separate places for company context, prospect context, current conversation state, and durable notes. Decide which changes belong in durable memory and which details can disappear when the action ends. If a detail cannot change a later action, leave it out of the durable state.

Assemble the working set

Build the context for the action the agent is about to take. Load the smallest useful set first, then fetch supporting detail when the action needs it.

Keep high-value state close to the model, page through larger data on demand, use indexes to find needed material, and truncate content in a way that shows what else can be accessed.¹⁰ As sessions grow, the harness makes the same decisions about what remains in the working set, what gets compressed, and what gets retrieved later.²

Use this order:

• State the current action and the decision the agent must make.
• Load the durable profile for the company and prospect.
• Add the recent conversation state, including the latest response and unresolved point.
• Retrieve supporting research only when it can change the next action.

Move on when the working set gives the agent enough context to act without making it read the entire history. If a source is too large, retain a pointer or index path so the agent can retrieve more when needed.

Distill each touch into memory

Memory becomes useful when each touch leaves behind a compact state that a later action can use. Treat the end of an interaction as a memory writing step alongside message generation.

A run can distill memory by converting a tool call into session notes.¹¹ After each call, reply, or research action, record the facts that should affect a later decision. Keep the note focused on what changed, what remains uncertain, and what the agent should look for next time.

A durable note can contain:

• confirmed company or prospect facts
• the latest stated concern or priority
• an unresolved question
• the agreed or intended next action

Ask what changed, what would make the note wrong, and what the agent should retrieve before its next action. A compact answer gives retrieval something to select. When detail may matter later, keep it available behind a retrievable pointer instead of loading it into every working set.¹⁰

Retrieve for the action

Retrieval should explain why a memory belongs in the current action. Give the agent context that changes the response, timing, or next step, and leave unrelated history out of the working set.

An agent can feel personal, consistent, and context-aware when it manages what is stored, recalled, and injected into working memory.¹² Agent-generated account context and research can make human outreach more relevant.¹³ A context and ideation partner can track events, combine information across systems, and identify what a seller is forgetting.¹⁴

For each action, retrieve memories that answer these questions:

• Who is this action about, and which company context applies?
• What happened in the latest interaction?
• Which unresolved point makes this action relevant now?
• Which stored fact could change the wording or timing?

Remove anything that answers none of them. Relevance comes from the connection between the memory and the action, not from the age or size of the memory store.

Preserve continuity across touches

Continuity depends on durable state that carries forward decisions and constraints without replaying every earlier exchange. Keep that state inspectable.

An agent can use relevant information from a chat without referring back to the full chat history or other large datasets.¹⁵ Memory can persist across interactions while remaining governable and transparent.¹⁶ Make durable state easy to inspect, correct, and remove when a current interaction changes it.

Treat date-sensitive or decision-sensitive notes as conditional. Before using a durable note, check whether the current touch still supports it. An agent can carry stale context into a later decision,¹⁷ so the memory layer should make old assumptions visible instead of presenting them as current facts.

Test context, not only wording

Test whether the agent selects and carries context correctly as conversations grow. A polished instruction cannot repair a working set that contains the wrong state.

Observed sessions have included the model losing track of the task, file reads consuming half the context window with boilerplate, and tool results crowding out the conversation.¹⁸ Agents can also return outputs that appear correct while being wrong in context.¹⁹

Run tests that ask:

• Can the agent identify the current action?
• Can it separate current facts from older notes?
• Can it retrieve the company or prospect context that changes the action?
• Can it say what information is missing instead of filling the gap?
• Can it resume after earlier context has been compressed?

When a test fails, inspect what was stored, what was retrieved, and what was compressed before rewriting the instruction. The failure often sits in the context assembly, memory update, or retrieval rule.

What not to do

These mistakes turn memory into accumulated noise or leave the agent without continuity.

• Strong systems manage the context window actively, so it does not remain a passive transcript buffer.²⁰
• Keep file reads and tool results from crowding out the actual conversation.¹⁸
• Treating each interaction in isolation severely limits retention of user context, past decisions, and enterprise constraints across workflows.²¹
• Check durable notes before use. An agent can carry stale context into a later decision.¹⁷

Before the next outbound run, define the state object, decide what belongs in the working set, and specify how a touch becomes a durable note. Then test a resumed conversation containing both current and stale information before allowing the agent to act.