Agent memory

Agent memory for retaining what an agent learns from past cases and human escalation decisions, and reusing it as context in later runs.

Hinweis:

Diese Funktion ist in der Vorschau verfügbar.

Agent memory lets an agent retain what it learns from past cases and from human feedback, and apply that knowledge to later runs. Without it, an agent starts every run from scratch. It holds no record of how similar cases were handled before, and it repeats questions a person already answered.

With memory enabled, an agent can:

• Recall the inputs and outcomes of similar past cases and use them as context for the current run.
• Reuse human decisions. When a person resolves an escalation, the agent retains that resolution and applies it the next time a comparable case appears.
• Improve from feedback that users and subject matter experts add from traces and agent outputs.

For setup instructions, refer to Configuring agent memory.

Memory types

Two memory types are available. An agent can use both at the same time.

Typ	What it stores	When it is used
Episodic memory	Inputs, outputs, and outcomes of past cases, plus feedback added by users.	Before each run, to add context from semantically similar past inputs.
Escalation memory	The inputs, resolution comment, and outcome of a resolved escalation.	Before raising an escalation, to reuse a matching past resolution.

Memory spaces

Memories are stored in memory spaces. A memory space is a container that holds memory items and defines how those items are matched against new inputs.

Multiple agents can share one memory space, which lets them learn from each other's cases.

Memory spaces are managed from two places:

• Agent Builder in Studio Web: the Memory agent node, where a memory space is attached to an agent and its search settings are tuned.
• Agents instance management: the Memory spaces tab, which lists the memory spaces available and where individual memory items are inspected, edited, and deleted.

If your organization uses customer managed keys (CMK), encryption is set when the memory space is created. It cannot be changed on an existing space.

Episodic memory

Episodic memory retrieval is keyed on the agent's input arguments. Before the agent loop starts, a recall step embeds the current input values and searches the memory space for items with similar keys. Matching memories are added to the agent's context for that run as examples that guide its response.

Which memories come back is governed by three settings on the memory space: how closely a new query must match a past one, how many examples are retrieved, and whether the search matches on keywords and meaning or on meaning alone. Each input argument also carries a weight that determines its share of the match.

Adding memories

Memories enter a memory space manually, when a user promotes feedback to that space from one of two places:

• From a trace: on the agent run span of an agent trace. Only feedback applied to the agent run span is eligible for episodic memory. For details, refer to Agent traces.
• From an agent output: on a specific portion of the output.

Duplicate detection

Before feedback is added to a memory space, a semantic similarity search checks for near-duplicate items. If similar memories already exist, a dialog lists them and offers three choices:

• Replace: deletes the selected existing items and stores the new one.
• Merge: keeps the closest existing item and updates its feedback with a merged comment. If the new and existing feedback disagree in sentiment, the user chooses which one wins.
• Add anyway: stores the new item alongside the existing ones.

Duplicate detection keeps memory spaces from accumulating contradictory or redundant entries.

Files and long text as search keys

File inputs and very long text inputs do not embed well as raw values. The runtime handles them as follows:

• File inputs: during the recall step, each file is analyzed and converted to a text summary, and that summary becomes the search key. File-heavy agents therefore match on what an attachment contains rather than on a reference to it.
• Long text inputs: long values are compacted before embedding, so the key captures the meaning of the input rather than its full raw text.

Search keys belong to the memory space, and they are visible and editable per agent in Agent Builder. A key is either inherited from the space or overridden for one agent. A change to a key affects every agent that shares the space, and Agent Builder warns before applying such a change.

Escalation memory

Escalation memory builds on escalations. When a person resolves an escalation task in Action Center, the resolution is stored as a memory item: the escalation inputs, the resolution comment, and the chosen outcome.

On later runs, when the agent is about to raise the same escalation, it first searches the memory space for comparable past cases:

• If a match clears the similarity threshold, the agent applies the stored outcome and the run continues without human intervention.
• If no match is found, the escalation is raised as usual, and its resolution becomes a new memory.

Escalation memory returns only the top-ranked memory, never a set of candidates.

The effect is that human decisions accumulate. Each approval or override teaches the agent, and fewer cases need to be escalated over time.

Memory playground

The memory playground tests how a memory space behaves without running the agent:

• For episodic memory, it takes values for the agent's input arguments, runs the same recall step the agent would run, and reports which memories match and their similarity scores.
• For escalation memory, it takes escalation content and reports whether a past resolution would be applied.

The playground validates that search keys, weights, and the similarity threshold return the expected memories before an agent depends on them in production. For the procedure, refer to Configuring agent memory.

Exporting memories

The contents of a memory space can be exported, for example to create a backup or to review memory items outside the product. Moving memories between tenants uses the same export and import path.

Einschränkungen

• Editing the inputs of an existing episodic memory item is not supported. Correcting such a memory requires deleting it and adding a new one.
• The feedback dashboard and the add-feedback-to-memory view show a 30-day window. Older feedback remains in the backend but is not displayed.