What makes a Deep Agent different from a regular AI Agent?

A Deep Agent is built for multi-step, long-horizon tasks. While a standard agent handles a single prompt-response cycle, a Deep Agent decomposes a goal into sub-tasks, executes them iteratively, evaluates results, and adapts its approach, all within a single run.

How do I configure a Deep Agent's system message?

The system message defines the agent's role, goal, reasoning approach, and behavioral constraints. Since the agent will operate autonomously across many steps without human checkpoints, it's best to be explicit about the expected output format, how to handle ambiguity or tool failures mid-task, and any scope limits.

What's the difference between letting AI decide tool parameters vs manual configuration?

When you let AI decide, the agent dynamically chooses how to use the tool based on context. This enables the Deep Agents to adapt its approach across many steps. Manual configuration locks specific parameters, giving you more control but less flexibility.

How do I choose the right LLM for my Deep Agent?

It pays off to choose the latest mid to large AI models to power your deep agents (e.g. latest GPT, latest Claude Sonnet or Opus models, Gemini Pro models). These handle multi-step planning and tool chaining far better than smaller models. For cost-sensitive workflows, use a capable mid-range model and upgrade only if the agent struggles with planning or makes poor decisions mid-task.

When should I enable Agent Memory for a Deep Agent?

Enable Agent Memory when your Deep Agent needs to carry knowledge across multiple runs. For example, when working on an ongoing project, building a knowledge base incrementally, or recalling decisions from previous sessions. Within a single run, the agent already maintains full context through its execution history.

Deep Agent

Complete guide to building and configuring Deep Agents in FlowHunt — from basic setup to advanced multi-step task execution.

Agents

Try it Now Book a demo

The Deep Agent is FlowHunt’s most capable agent type, built for tasks that go far beyond a single prompt-and-response cycle. Where a standard AI agent answers a question or performs a discrete action, a Deep Agent pursues a goal — breaking it down, executing steps, evaluating results, and adapting its approach until the objective is complete.

How a Deep Agent Differs from a Regular AI Agent

A standard AI agent processes your input it with an LLM, optionally calls a tool, and returns a response. It’s great for single-step or simpler multi-step tasks, conversations, summarizing document, or triggering action.

A Deep Agent is proactive and iterative. Given a high-level goal, it:

Decomposes the goal into a sequence of concrete sub-tasks before taking any action
Plans its approach, deciding which tools to use and in what order
Executes steps iteratively, calling tools, processing results, and deciding what to do next based on what it finds
Self-evaluates after each step — retrying, refining, or changing strategy if a result is insufficient
Synthesizes a final output only after all sub-tasks are complete

The key practical difference: a regular agent can take several steps at best, but a Deep Agent can take dozens, and it knows when to stop.

When to Use a Deep Agent

Deep Agents are the right choice when:

The task requires gathering and synthesizing information from multiple sources
The workflow involves conditional logic, or in other words, when the next step depends on the outcome of previous steps
You need the agent to verify or cross-check its own intermediate results
The goal is too complex or open-ended to fully specify in a single prompt
You want the agent to operate autonomously over a longer time period

Remember: For simple, well-scoped tasks, a standard AI Agent is faster and more cost-effective. Only use a Deep Agent when the complexity justifies the extra reasoning depth.

Deep Agent Settings

LLM

Pick the large language model the agent will use. You can choose from models across 6 major providers. The default model is always the latest mid-range model from OpenAI, which should be enough for most tasks.

Deep Agents benefit most from more advanced models with strong reasoning capabilities (e.g. latest GPT, latest Claude Sonnet or Opus models, Gemini Pro models), because they can plan across many steps, handle ambiguity, and make sound decisions at each stage without human guidance.

Tools

Tools are what gives the Deep Agent its ability to act in the world. With over 900 available tools (spanning APIs, databases, communication platforms, search engines, code execution environments), and MCP servers — you can equip the agent with exactly the capabilities its task requires.

How to connect tools

Click + Add Tool. The full list of available tools appears. You can filter by category or search by name:

Select a tool to connect to the Deep Agent

Each tool has its own settings. For each one, you can either let the AI decide how to use it based on context (recommended for Deep Agents, since the agent needs flexibility to adapt across many steps) or configure parameters manually to lock specific values.

To switch to the manual input, click the “AI Decides” button. Once a parameter is manually defined, it is fixed and the AI cannot override it.

Once the tool is configured, click “Add with Config”, or skip the configuration entirely by clicking “Skip & Add”. You can then continue adding other tools.

For Deep Agents, a focused and relevant toolset leads to better decisions and faster execution than an overly broad one — the agent considers all available tools at every step, so unnecessary tools add noise.

System message

The system message is the most important configuration for a Deep Agent. It defines the agent’s role, objective, reasoning approach, and the constraints it must respect. It’s the primary mechanism for keeping an autonomous agent on track.

For Deep Agents, your system message should cover:

The goal — what the agent is ultimately trying to achieve
The expected output — format, length, structure
Decision rules — what to do when it encounters missing data, conflicting sources, or tool failures
Scope constraints — what the agent should and should not do

Example system message:

You are a deep research agent. Your goal is to produce a comprehensive, accurate, and well-structured report on any topic you are given.

Process:
1. Break the topic into 4–6 key research questions.
2. For each question, search for relevant information using the available tools.
3. Evaluate the quality and relevance of each source before using it.
4. Synthesize findings across all questions into a coherent report.
5. Include a summary, key findings, and a list of sources at the end.

Rules:
- Do not fabricate information. If you cannot find a reliable source, say so.
- If a tool call fails, retry once with a modified query before moving on.
- Do not stop until all research questions have been addressed or you have exhausted available sources.
- Keep the final report factual, neutral in tone, and free of speculation.

Output format: Markdown, with clear headings for each section.

Max recursion depth

Controls how many levels deep the agent can recurse when breaking down and executing sub-tasks. A higher value allows the agent to tackle more complex, nested problems, but increases execution time and resource usage. For most tasks, the default value is more than enough. Increase it only when the agent needs to pursue genuinely multi-level sub-goals.

Agent Chat History

Provides past chat messages as context for the current run. With history enabled, the Deep Agent can reference earlier exchanges, which is useful when the agent is part of an ongoing conversation or iterative workflow where prior context shapes the next step. Without history, the agent treats each run as fully independent.

Agent Memory

Controls whether the agent can read from and write to your Workspace memory. When enabled, the Deep Agent can persist findings, decisions, and accumulated knowledge across separate runs — making it possible to build up a knowledge base incrementally or resume long-running projects where picking up from scratch would be wasteful. If enabled, you’ll be asked to define the memory mode and behavior prompts that govern what gets stored and how it’s retrieved.

Note: Only the Tools input is strictly required; all other settings are optional but have a significant impact on the quality and reliability of a Deep Agent’s output.

How a Deep Agent Solves Tasks

Deep Agents follow a structured execution loop. This loop is exactly what makes Deep Agents capable of handling tasks that would overwhelm a standard agent:

Goal decomposition: The agent analyzes the objective and breaks it into a sequence of sub-tasks.
Iterative execution: The agent works through sub-tasks one at a time, calling tools, processing results, and deciding what to do next based on finished steps.
Self-evaluation: After each step, the agent assesses whether the result is sufficient to move forward or whether it needs to retry, refine its query, or take an entirely different approach.
Synthesis: Once all sub-tasks are complete, the agent combines intermediate results into a final, coherent output.
Termination: The agent stops when the goal is achieved, when it reaches the configured limits, or when it determines it’s not able to complete the task with the available tools and information.

Choosing the Right Model for a Deep Agent

The LLM is the reasoning engine behind every decision the Deep Agent makes. For deep, multi-step tasks, model quality has an outsized impact on performance.

Frontier models (GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 Pro): Best for complex reasoning, long-horizon planning, and tasks where the agent must handle ambiguity or make judgment calls without human input. The higher cost is usually justifiable for Deep Agent workloads.
Mid-range models: A solid balance of capability and cost for moderately complex but well-defined tasks.
Small language models: Not recommended as the primary model for Deep Agents. They lack the reasoning depth needed for reliable multi-step execution. That being said, they’re still suitable for simple sub-tasks within a larger workflow where speed and cost matter more than reasoning quality.

Start with a mid-range model and move up only if performance requires it. The right choice depends on your task complexity, acceptable latency, and budget.

Frequently asked questions

: A Deep Agent is built for multi-step, long-horizon tasks. While a standard agent handles a single prompt-response cycle, a Deep Agent decomposes a goal into sub-tasks, executes them iteratively, evaluates results, and adapts its approach, all within a single run.
: The system message defines the agent's role, goal, reasoning approach, and behavioral constraints. Since the agent will operate autonomously across many steps without human checkpoints, it's best to be explicit about the expected output format, how to handle ambiguity or tool failures mid-task, and any scope limits.
: When you let AI decide, the agent dynamically chooses how to use the tool based on context. This enables the Deep Agents to adapt its approach across many steps. Manual configuration locks specific parameters, giving you more control but less flexibility.
: It pays off to choose the latest mid to large AI models to power your deep agents (e.g. latest GPT, latest Claude Sonnet or Opus models, Gemini Pro models). These handle multi-step planning and tool chaining far better than smaller models. For cost-sensitive workflows, use a capable mid-range model and upgrade only if the agent struggles with planning or makes poor decisions mid-task.
: Enable Agent Memory when your Deep Agent needs to carry knowledge across multiple runs. For example, when working on an ongoing project, building a knowledge base incrementally, or recalling decisions from previous sessions. Within a single run, the agent already maintains full context through its execution history.