Skip to main content

Agents

Orbis Studio's Agent component is critical for building agent flows. This component defines the behavior and capabilities of AI agents in your flows.

How do agents work?

Agents extend Large Language Models (LLMs) by integrating tools, which are functions that provide additional context and enable autonomous task execution. These integrations make agents more specialized and powerful than standalone LLMs.

Whereas an LLM might generate acceptable, inert responses to general queries and tasks, an agent can leverage the integrated context and tools to provide more relevant responses and even take action. For example, you might create an agent that can access your company's documentation, repositories, and other resources to help your team with tasks that require knowledge of your specific products, customers, and code.

Agents use LLMs as a reasoning engine to process input, determine which actions to take to address the query, and then generate a response. The response could be a typical text-based LLM response, or it could involve an action, like editing a file, running a script, or calling an external API.

In an agentic context, tools are functions that the agent can run to perform tasks or access external resources. A function is wrapped as a Tool object with a common interface that the agent understands. Agents become aware of tools through tool registration, which is when the agent is provided a list of available tools typically at agent initialization. The Tool object's description tells the agent what the tool can do so that it can decide whether the tool is appropriate for a given request.

Examples of agent flows​

For examples of flows using the Agent component, see the following:

  • Orbis Studio quickstart: Start with the Simple Agent template, modify its tools, and then learn how to use an agent flow in an application.

    The Simple Agent template creates a basic agent flow with an Agent component that can use two other Orbis Studio components as tools. The LLM specified in the Agent component's settings can use its own built-in functionality as well as the functionality provided by the connected tools when generating responses.

  • Use an agent as a tool: Create a multi-agent flow.

  • Use Orbis Studio as an MCP client and Use Orbis Studio as an MCP server: Use the Agent and MCP Tools component to implement the Model Context Protocol (MCP) in your flows.

Agent component​

The Agent component is the primary agent actor in your agent flows. This component uses an LLM integration to respond to input, such as a chat message or file upload.

The agent can use the tools already available in the base LLM as well as additional tools that you connect to the Agent component's Tools port. You can connect any Orbis Studio component as a tool, including other Agent components and MCP servers through the MCP Tools component.

For more information about using this component, see Use Orbis Studio agents.

Agent with Mem0 component​

The Agent with Mem0 component is a full agent with built-in long-term memory powered by Mem0. It combines the capabilities of the standard Agent component with automatic memory retrieval and storage, so the agent can remember durable facts about users across conversations without additional wiring.

When memory is enabled, the agent automatically retrieves relevant past memories before generating each reply and optionally saves new facts after each turn. The agent also receives a search_memory tool it can call proactively to look up specific details not already in its context.

Agent with Mem0 parameters​

NameTypeDescription
agent_llmDropdownInput parameter. The model provider for the agent's LLM. Select from supported providers or connect an external model.
api_keySecretStringInput parameter. API key for the selected model provider.
base_urlStringInput parameter. Base URL of the model provider API. Used for self-hosted or proxy deployments.
system_promptStringInput parameter. Agent Instructions — initial system prompt that guides the agent's behavior.
context_idStringInput parameter. Context ID for the chat session. Adds an extra isolation layer to local memory.
n_messagesIntegerInput parameter. Number of chat history messages to include in each request.
use_mem0BooleanInput parameter. Enable Mem0 Memory. When enabled, the agent retrieves past memories before responding and can save new facts after each reply.
mem0_retrieveBooleanInput parameter. Retrieve Memories — inject relevant past memories into the prompt and give the agent a search_​memory tool.
mem0_saveBooleanInput parameter. Save Memories — automatically extract and store new durable facts about the user after each reply. Uses one extra LLM call per turn.
mem0_api_keySecretStringInput parameter. Mem0 API Key. Falls back to the MEM0_​API_​KEY environment variable, then to a local Mem0 instance if neither is set.
mem0_base_urlStringInput parameter. Mem0 Base URL. Leave empty to use Mem0 Cloud (https://api.mem0.ai). Set for self-hosted Mem0.
mem0_namespaceStringInput parameter. Memory Namespace. Memories are stored under {namespace}_​_​{user_​id} to isolate each agent's memory scope. Example: sales_​agent.
mem0_user_idStringInput parameter. Mem0 User ID. Scopes memories to a single end user. Leave empty to use the flow's runtime user. In multi-user deployments, always pass each user's own ID to prevent memory leakage between users.
mem0_max_memoriesIntegerInput parameter. Max Memories to Retrieve — maximum number of memories fetched from Mem0 per request.
mem0_relevance_thresholdFloatInput parameter. Relevance Threshold — minimum similarity score (0–1) for a retrieved memory to be injected. 0 = no filtering. Example: 0.3 filters out weakly relevant memories.
mem0_instructionsStringInput parameter. Memory Instructions — guidance injected into the system prompt that tells the agent when to call save_​memory or search_​memory. Auto-filled with a sensible default.

Agent with Mem0 outputs​

NameTypeDescription
responseMessageOutput parameter. The agent's reply message.

See also​