Use an Agent in a process

The Agent task node directly selects an Agent, an exact revision, and an activity. It then maps that activity's inputs and can independently use Agent Memory or not.

Agent, revision, and activity are selected on the node

Agent task Agent + revision + activity
Agent Memory optional
Agent revision immutable
Activity executable contract
Agent Run
Process continuation outputs / route

Agent Task carries the complete executable dependency. Agent Memory is an optional invocation channel, separate from Agent selection.

In the Process Builder, configuration follows the order Agent → revision → activity. Once the activity is chosen, the inspector displays only its inputs to map. This sequence is comparable to a subprocess: the dependency is chosen before its input contract is exposed.

An Agent role is not an assignment

A process may declare Agent roles for memory continuity, but a role contains neither Agent, revision, nor activity. An Agent Task without a role is normal.

Each Agent Task pins a specific revision

The selected revision freezes the general objective, instructions, model provider and model, and the complete activity contract. The node retains this exact dependency: publishing a new Agent revision never silently changes an already-published process.

Changing revision is a process decision

To adopt a new Agent version, the designer changes the revision on the relevant Agent Task. Mappings are then validated against the activity contract of that new revision.

Inputs, outputs, and routes follow the activity

Configurable node parameters are the inputs declared by the selected activity. The process supplies them through ordinary bindings or expressions; tools, instructions, and guardrails remain in the Agent revision and are not copied into the Process Builder.

Outputs are not inspector configuration: they become typed sources for downstream nodes. When the activity designates a routing output, values of that choice become node branches on the canvas.

This boundary avoids implicit context: new business information passes through inputs, while optional working continuity passes through Agent Memory.

Completed Agent Run, including activity and link to the parent process instance.
After a call from a process, the Run identifies the executed activity and preserves the link to its parent instance. Enlarge

Agent Memory is a separate invocation option

Each Agent Task independently chooses its memory source. The default is to use none.

SourceBehavior
NoneThe Run executes without memory continuity. It remains durable and observable.
Memory objectA binding or expression supplies a typed platform.agent_memoryvalue. The memory must belong to the same Agent as the node.
Agent roleThe role serves only as a continuity namespace. First use resolves or creates the Agent Memory corresponding to the instance, role, and Agent selected on this node.

Two different Agents using the same role therefore do not implicitly share memory. Conversely, two revisions of the same Agent may recover the same Agent Memory when they use the same continuity.

Some activities declare required_activities. In that case a memory source is mandatory and the admitted memory must already contain the requested successful contributions. See Agent Memory.

Authority and disclosure remain explicit

Selecting an Agent or memory grants no general authority over the platform. Actions possible during the Run come only from tools configured on the activity, under applicable permissions and business rules.

Three different boundaries

A binding passes data. A tool grants a bounded capability. Disclosure consent may authorize raw exposure of protected data. None of these decisions automatically implies the other two.

Requests for raw inputs or tool results belong to the pinned Agent revision and are evaluated when used from the process. See Data protection, Node permissions and Tool catalog and risk.