Deep Agent
Deep Agent is an autonomous AI agent that can plan, reason, and execute complex multi-step tasks with minimal user intervention. Instead of following a predefined sequence of actions, Deep Agent analyzes a user’s objective, determines the steps required to achieve it, and uses available Tools and Skills to complete the task.
Deep Agent is designed for scenarios where the execution path cannot be fully defined in advance and may require decision-making, iterative reasoning, file processing, research, analysis, content generation, or orchestration across multiple systems.
Each Deep Agent operates within a dedicated workspace scoped to a specific Tenant, Project, and Flow. The workspace provides isolated storage for input files, generated artifacts, execution outputs, chat history, AGENTS.md memory files, and selected Skills, ensuring secure and independent execution.
Why Use Deep Agent?
Traditional workflows are most effective when every step is known and defined upfront. However, many real-world automation scenarios require the system to determine actions dynamically based on available information and intermediate results.
Deep Agent enables intelligent execution by allowing it to:
a. Understand high-level objectives.
b. Plan the required execution steps.
c. Dynamically select and use Tools and Skills.
d. Adapt execution based on intermediate outcomes.
e. Perform iterative reasoning when required.
f. Complete complex tasks without requiring every step to be manually defined.
Standard Agent vs. Deep Agent
| Capability | Standard Agent | Deep Agent |
|---|---|---|
| Execution Model | Responds to a request. | Plans and executes multi-step tasks. |
| Reasoning | Limited to the current request. | Iterative reasoning and decision-making. |
| Planning | User-defined. | Agent-generated. |
| Tool Usage | Uses connected tools when required. | Dynamically selects and orchestrates tools. |
| File Processing | Basic interactions. | Advanced workspace-based operations. |
| Skills Support | Optional. | Designed for extensive Skill utilization. |
| Memory | Limited context. | Supports persistent memory and workspace context. |
| Best Suited For | Simple tasks and interactions. | Complex workflows requiring planning and orchestration. |
Use a Standard Agent When
a. The workflow is straightforward and follows a predictable execution path.
b. The task can be completed with limited reasoning and minimal decision-making.
Use a Deep Agent When
a. The workflow requires planning, reasoning, and dynamic execution across multiple steps.
b. The execution path may change based on available data, intermediate results, or user-defined objectives.
How Deep Agent Works
When a task is submitted, Deep Agent typically performs the following activities:
1. Understands the user objective.
2. Creates an execution plan.
3. Identifies the required Tools and Skills.
4. Executes one or more actions.
5. Evaluates intermediate results.
6. Refines the plan if necessary.
7. Produces the final output.
This planning and execution cycle continues until the objective is achieved or the configured execution limits are reached.
Tools and Skills
Deep Agent can use both Tools and Skills during execution. Although they work together, they serve different purposes.
Components
| Component | Description |
|---|---|
| Tools | Executable capabilities that allow the agent to interact with systems and perform actions. Tools provide the agent with the ability to perform work. |
| Skills | Reusable capability packages that provide task-specific knowledge, workflows, instructions, and supporting resources. Skills help the agent perform specialized tasks more effectively and consistently. |
How Tools and Skills Work Together
Tools and Skills are complementary.
i. Skills provide expertise and execution guidance.
ii. Tools perform actions.
Example
User Request: Analyze uploaded contracts and generate a risk assessment report.
Deep Agent Execution:
1. Uses a Contract Review Skill to understand how contracts should be evaluated.
2. Uses file-processing tools to access and read the documents.
3. Extracts relevant clauses and obligations.
4. Applies guidance provided by the Skill to identify risks.
5. Generates a report using document-generation tools.
Agent Instructions and Skills
Agent Instructions and Skills serve different purposes and should be used together.
Components
| Component | Description |
|---|---|
| Agent Instructions | Define the objective the agent must achieve, along with any business requirements, constraints, priorities, expected behavior, and desired output format. These instructions guide how the agent plans and executes tasks within the flow. |
| Skills | Provide reusable expertise and guidance that can be applied across multiple flows (see Tools and Skills above). |
Example: Generate a customer onboarding report that prioritizes accuracy over speed, includes a risk summary section, and does not modify the source files.
For example, a Customer Analysis Skill may contain customer segmentation methodologies, risk-scoring logic, reporting templates, and relevant reference documentation.
In short: Agent Instructions define what to accomplish; Skills provide how to do it; Tools carry out the actions.
Workspace Isolation
Each Deep Agent executes within its own dedicated workspace. The workspace can contain input files, generated artifacts, execution outputs, chat history, AGENTS.md memory files, and selected Skills.
When Skills are enabled, copies of the selected Skills are copied to the agent workspace. These workspace copies are independent of the original Skills managed through Skill Management. Any modifications made to files within the workspace affect only the workspace copy and do not modify the original Skill definition.
When to Use Deep Agent
Document Processing
Use Deep Agent when documents require multiple stages of analysis, such as extracting information, validating content, identifying risks, and generating summaries or reports. It is particularly useful for contract reviews, compliance assessments, policy analysis, and document processing workflows.
Research and Analysis
Use Deep Agent when information must be collected from multiple sources, evaluated, and transformed into meaningful insights. It is well suited for market research, competitive analysis, trend identification, and business intelligence scenarios.
Software Development
Use Deep Agent when development tasks require planning, code generation, file creation, validation, and iterative refinement. Common use cases include application scaffolding, code refactoring, automated testing, and documentation generation.
Data Analysis
Use Deep Agent when datasets require processing, transformation, analysis, and report generation. It is ideal for spreadsheet analysis, data quality validation, reporting, and other data-driven automation scenarios.
Enterprise Workflow Orchestration
Use Deep Agent when business processes involve coordinating activities across multiple systems, making decisions during execution, and adapting workflows based on intermediate results. It is particularly effective for operational automation, knowledge management, and end-to-end process orchestration.
Prerequisites
Before configuring a Deep Agent, ensure that the following requirements are met.
Requirements
| Requirement | Description |
|---|---|
| Language Model | Connect a Language Model component. The model must support tool calling and provide the reasoning capabilities required by the agent. |
| Local Filesystem Sandbox | Enable the local filesystem sandbox when the agent needs to create, read, modify, or manage files during execution. |
| Downstream Component | Connect a downstream component to consume the output generated by the agent. |
Parameters
| Parameter | Description |
|---|---|
| Deep Agent Name* | Specifies the name of the Deep Agent instance. |
| Language Model | Connects a Language Model component that provides reasoning and decision-making capabilities. |
| Tools | Connects the tools available to the agent during execution. |
| Input Files | Selects or uploads files to copy into the agent workspace for processing. |
| Input Data | Accepts a Message, Data, or DataFrame containing information for processing. |
| Input | Specifies the user request or task that the agent processes. |
| Agent Instructions | Specifies custom instructions that guide the agent's behavior and execution. |
| Number of Chat History Messages | Specifies the number of previous chat messages included as context. Default: 100. |
| Context ID | Specifies an optional identifier used to scope chat history lookup to a specific conversation context. |
| Enable AGENTS.md Memory | Loads instructions and memory from AGENTS.md files into the agent context. Default: Disabled. |
| Memory Rules | Defines how memory and previous context should be managed and utilized during execution. |
| Enable Skills | Enables the use of Skills during execution. Default: Disabled. |
| Skills | Selects one or more Skills available through Skill Management. |
| Use Local Filesystem Sandbox | Enables file system operations within the workspace. Default: Enabled. |
| Verbose | Enables detailed execution logging for troubleshooting. Default: Disabled. |
| Max Iterations | Specifies the maximum number of execution iterations allowed. Default: 5. |
| Recursion Limit | Specifies the maximum recursive execution depth allowed. Default: 500. |
| Context Length | Specifies the maximum context window available to the agent. Default: 75,000. |
| File Reuse Rules | Defines how existing workspace files are identified and reused. |
Configuration Options
Use Local Filesystem Sandbox
| State | Behavior |
|---|---|
| Enabled | Allows the agent to create, read, modify, and manage files within its assigned workspace. |
| Disabled | Prevents the agent from performing file operations within the workspace. |
Enable AGENTS.md Memory
| State | Behavior |
|---|---|
| Enabled | Loads instructions and memory from AGENTS.md files into the agent's context. |
| Disabled | Prevents the agent from loading instructions and memory from AGENTS.md files. |
Enable Skills
| State | Behavior |
|---|---|
| Enabled | Allows the agent to use the selected Skills during execution. |
| Disabled | Prevents the agent from using Skills during execution. |
Verbose
| State | Behavior |
|---|---|
| Enabled | Generates additional execution logs for troubleshooting and debugging purposes. |
| Disabled | Generates standard execution logs only. |
Outputs
| Output | Description |
|---|---|
| Response | Returns the final response generated by the agent after completing the task. |
Tool Mode
| Slug | Description |
|---|---|
| MESSAGE_RESPONSE | Returns the final response in a standardized format for downstream workflow components. |
Best Practices
Provide Clear Objectives
Use Agent Instructions to clearly define the desired outcome, business requirements, constraints, and expected output format.
Create Focused Skills
Design Skills around a single capability or workflow. Focused Skills improve reusability and help the agent select the most appropriate capability during execution.
Enable Only Required Tools
Connect only the tools needed for the task. Limiting tool access reduces unnecessary tool calls and improves efficiency.
Use Verbose Mode During Development
Enable Verbose mode while building or troubleshooting flows to gain visibility into the agent’s decisions and execution process.
Tune Execution Limits Carefully
Increasing Max Iterations, Recursion Limit, or Context Length allows the agent to perform more work but may increase execution time, resource consumption, and token usage.
Use Memory Strategically
Enable AGENTS.md memory and chat history when workflows benefit from retaining context, instructions, or knowledge across executions.
