All nodes/AI/Conversation Memory

Summary Memory

Stores the history of this workflow's OWN past runs, compressing older messages via LLM; empty on the first turn — to read a conversation written before the workflow was built, use the Chat History node. The LLM can be taken from the connected agent or wired separately into the Model port.

Summary Memory▶S

ModelMemory

Set historyMessages

Type in the graph: summary_memory

ExecStateful

An error output can be enabled to handle failures on their own path.

Try it

An agent with a self-compressing history

Memory attaches over link_memory and summarises with the agent's own model by default.

Entry

LLM▦

Summary Memory▶S

AI Agent▶▦

Exit▶

Execute + Data
LLM
Memory

Press “Copy nodes”, open the editor and hit Ctrl+V on the canvas.

Runs as pasted Before running, set: a model in the LLM node.

When to use it

Summary Memory is for conversations that run long and cannot simply be cut short: a consultation, a guided selection, a ticket followed over days. The node accumulates history like Buffer Memory, but on overflow it does not drop the old part the way Window Memory does — it sends it to a model and replaces it with a single summary. The price is an extra LLM call: of the three memories, only this one spends money by itself.

How it works

The threshold is “Messages before summarizing” (20 by default). Once the store holds that many messages or more, everything except the last “Recent Messages to Keep Raw” (6 by default) goes to the model in one request, and the result replaces them with a text summary. The previous summary is included in that request, so it is extended rather than rewritten from scratch. In the agent’s context the summary arrives as a separate message ahead of the stored turns.

“Model source” decides where the model comes from. from_parent (the default) reuses the model of the connected agent and needs no extra port. external reveals a Model input: attach your own LLM node there, usually with a cheaper model — the summary is not written by the model that answers the user.

Compression runs synchronously, before the agent starts answering, and is capped at 45 seconds. If the request overruns or fails, the run does not fail: the un-compressed history goes to the model and a warning is written to the logs.

Common mistakes

Leaving “Model source” on external with no LLM node attached. Below the threshold everything looks fine; at the threshold compression simply does not happen, the history keeps growing, and nothing in the interface says so.
Looking for the summary in the scenario output. It lives in the memory store and goes into the agent’s context. The node exposes only the Memory link outward, plus the current messages when “Messages output” is enabled.
Forgetting that “Set history from input” clears the summary along with the messages: it described the previous conversation and would be wrong after an overwrite.
Expecting history where there is no chat thread. A webhook, a schedule or the manual Run button has no thread, so thread memory falls back to the execution id — it behaves like session.

Inputs

Port Wire Payload Notes

Port	Wire	Payload	Notes
Model`llm`	LLM`link_llm`	—	LLM config node used for summarization shown when llm_source ≠ "from_parent"
Set history`messages_in`	Execute + Data`execute_data`	`messages`	shown when overwrite_from_input = true

Modelllm

LLMlink_llm

—

LLM config node used for summarization

shown when llm_source ≠ "from_parent"

Set historymessages_in

Execute + Dataexecute_data

messages

shown when overwrite_from_input = true

Outputs

Port	Wire	Payload	Notes
Memory`output`	Memory`link_memory`	—
Messages`messages_out`	Data`data`	`messages`	shown when expose_messages_output = true

Configuration

Field	Type	Default	Description
Messages output`expose_messages_output`	`boolean`	`false`	Show an output that hands the stored messages on to the next step.
Model source`llm_source`	`string`	`from_parent`	Which model writes the summary: the one of the agent this memory is connected to, or a separate model wired into the Model port. Options: `from_parent` — From parent agent, `external` — Its own model
Messages before summarizing`max_messages_before_summary`	`integer`	`20`	When the number of messages reaches this value, older ones are summarized
Set history from input`overwrite_from_input`	`boolean`	`false`	Show an input port that both runs this step and brings a value: the messages that arrive fully overwrite the stored history. Also shows its Success output, which fires once the history is written.
Recent Messages to Keep Raw`recent_messages_to_keep`	`integer`	`6`	Number of latest messages kept verbatim after summarization
Scope`scope`	`string`	`thread`	thread: persists between chat messages · session: lives for one execution · call: fresh each time Options: `thread` — Thread, `call` — Call, `session` — Session

Shared fields

Every node has these three — the platform adds them, not the node author.

expose_error_output — Show an output that runs if writing the history fails.