Agent Memory
Agent Memory preserves working context across multiple Agent Runs. It belongs to an Agent , not to a revision or process, and can therefore be reused by several revisions of that same Agent when continuity is explicitly requested.
What is Agent Memory for?
An Agent may be invoked several times around the same work: analyze a situation, receive new information, then revisit its conclusion. Agent Memory avoids artificially rebuilding the entire context on every Run by preserving structured contributions and their provenance.
Observations, hypotheses, and results produced by the Agent remain working context. A business fact that must become reliable, shareable, or controllable by the process must be materialized through a typed output, platform object, or another canonical contract intended for that purpose.
Memory belongs to the Agent, not its revision
Agent Memory is attached to an Agent Definition. A contribution retains the exact revision and activity of the Run that produced it for traceability, but that provenance does not limit reuse by a later revision of the same Agent.
The same Agent Memory may provide continuity to several Runs and several revisions of the same Agent. Durable facts remain explicitly published outside memory.
Agent Memory cannot be reused by another Agent. When two Agents need to exchange information, the process must pass it explicitly through their typed outputs and inputs.
In a process, each Agent Task chooses its source
Memory is never an implicit business input. It is associated with the Agent Task invocation and remains optional unless an activity requires prior history.
| Source | When to use | Guarantee |
|---|---|---|
| None | The task requires no continuity. | No hidden Agent Memory is created. |
| Memory object | The process already has a platform.agent_memoryvalue, for example produced by Create Agent Memory. | The mapped memory must belong to the Agent selected on the node. |
| Agent role | Several Agent Tasks in the same process must automatically recover the same continuity for a given Agent. | Continuity is resolved by process instance + role + Agent. |
An Agent role is therefore only a continuity namespace. It references no revision and never selects the Agent. Two different Agents using the same role in the same instance receive distinct Agent Memories.
The node Create Agent Memory also lets a process explicitly create standalone memory and then map its output to a later Agent Task. This is useful when the memory itself must flow as a typed object or be linked to a business object.
The activity defines how it uses memory
Memory does not belong to the activity. However, each activity carries a memory policy controlling admission and access level for the context associated with the Run.
| Setting | Effet |
|---|---|
restricted_data_access | Determines whether restricted data admitted into memory remains projected or can be exposed in raw mode when the required consent exists. |
required_activities | Requires certain activities to have already contributed successfully to the same Agent Memory before the current activity can run. |
An empty required_activities list simply means no prerequisite is required. It does not disable reading the associated memory. When a key is required, it must exactly match an activity that has already contributed successfully; renaming an activity in a new revision does not retroactively transform old contributions.
Memory and protected data
Agent Memory preserves the protections applicable to the data it contains. An activity requesting raw access to restricted data does not bypass the protection model: that exposure remains subject to the corresponding consent and rights of the current Run.
Observability surfaces remain masked by default. Storing a value in memory does not make it readable in clear text; a precise investigation uses the intended reveal mechanisms when authorized.
See Data protection for disclosure and reveal rules.
Design working continuity well
- Use None when an activity can be understood solely from its current inputs.
- Use a Memory object when memory must be created, passed, or explicitly linked to other objects.
- Use a Agent role when several Agent Tasks in the same process must automatically recover continuity for the same Agent.
- Use
required_activitiesonly for a genuine work prerequisite, not to artificially impose a prompt sequence. - Prefer platform objects and typed outputs for durable, verifiable business facts.
Agent Memories are addressable platform objects and may be associated with business objects through Ormuz object relationships without inventing a specialized business field on the memory itself.