deepagents: the Python framework for building production-ready AI agents

TL;DR

deepagents is a LangChain framework that delivers a production-ready autonomous agent in minutes — with sub-agents, automatic context management, filesystem tools, and sandboxed execution built in. For solo builders, that means less time assembling agent infrastructure and more time building the product that generates revenue. This article covers how it works, what you can build with it, and 3 product ideas with clear monetization paths.

The problem you already know: agents that work vs agents that produce

Every builder who has worked with AI agents hits the same wall. In the notebook, it works. The agent researches, reasons, executes. You test locally, things look good. Then you try to turn it into something someone else can use — or even something you can rely on consistently — and everything starts to break.

Context window overflows. The agent loops. There’s no visibility into what’s happening. Long tasks corrupt the conversation history. Complex sub-tasks stall the execution. You fix one problem, another appears.

The root cause is simple: most builders assemble agents manually on top of LangChain or LangGraph without a standardized structure. Every project starts from scratch. Every time you reinvent context management, task planning, safe command execution, sub-agent isolation.

deepagents solves this. It’s a harness — a pre-configured wrapper over LangGraph — that ships all that infrastructure ready to go. You install it, customize the business logic, and you already have a production-ready agent.

What deepagents is (and what it isn’t)

deepagents is an open-source framework from LangChain that provides a complete, pre-configured autonomous agent as a starting point. The technical definition: a compiled LangGraph graph with native tools, pre-configured prompts, and automatic context management.

What that means in practice: you don’t build the agent from scratch. You start with something that already works and layer your specific logic on top.

What deepagents is not:

• Not a visual interface (it’s not n8n or Zapier)
• Not an AI model (the model is pluggable — you choose)
• Not a SaaS platform (it’s a Python library, you host it wherever you want)
• Not a low-code automation framework

deepagents is for builders who write code. The audience is the same as LangGraph or LangChain — but without the work of assembling everything from scratch.

How it works: the 3-layer mental model

To use deepagents effectively, the right mental model is three layers.

Layer 1 — Runtime: LangGraph

At the core is LangGraph. It’s the engine that manages the agent’s execution flow: the reasoning loop, tool calls, streaming, state persistence, and checkpointing. You don’t interact with LangGraph directly — deepagents abstracts that away — but it’s worth knowing it’s there. Any LangGraph feature (persistence, deployment on LangGraph Platform, human-in-the-loop) is available to you.

Layer 2 — Native tools: what the agent can do

deepagents ships with 6 categories of pre-configured tools:

These tools are wired into the agent’s reasoning loop. The LLM decides on its own when to use each one.

Layer 3 — Your business logic

This is what you add: the AI model, custom tools, a system prompt specific to your use case. It’s the thinnest layer — and where your product’s value lives.

from deepagents import create_deep_agent
from langchain.chat_models import init_chat_model

agent = create_deep_agent(
    model=init_chat_model("openai:gpt-4o"),
    tools=[my_custom_tool],
    system_prompt="You are a specialist in legal contract analysis.",
)

Three lines to have a specialized agent, with all native tools available, running on LangGraph.

Sub-agents: when one agent isn’t enough

The most powerful deepagents feature for product builders is the task tool — the tool that lets the main agent spawn sub-agents with isolated context windows.

The problem it solves: long, complex tasks tend to degrade agent performance because the conversation history keeps growing. After many exchanges, the model starts to “forget” instructions, lose coherence, or simply produce worse results.

Sub-agents fix this through isolation. The main agent can delegate a sub-task to a sub-agent with a clean context, receive the consolidated result, and continue with the main reasoning.

Example flow with sub-agents:

Main Agent
  → receives: "Analyze the 50 financial reports in /data and give me a consolidated summary"
  → plans: splits into 5 batches of 10 reports
  → delegates to Sub-Agent 1: analyzes reports 1-10 → returns summary
  → delegates to Sub-Agent 2: analyzes reports 11-20 → returns summary
  → ... (parallelizable)
  → consolidates the 5 summaries
  → delivers: final consolidated report

Each sub-agent starts with a clean context, without the weight of accumulated conversation. The main agent maintains the high-level reasoning. This pattern is fundamental for any product that processes large data volumes or runs complex pipelines.

For builders working on orchestrated agent squads, deepagents provides exactly that primitive — in one line of code.

Automatic context management: a problem you don’t want to solve manually

Any agent running long tasks will eventually overflow the context window. It’s a matter of when, not if.

deepagents handles this automatically: when the conversation grows too large, the framework applies automatic summarization to compress history without losing essential context. Large outputs are saved to files instead of being kept in conversation memory.

You don’t implement this. It’s already there. That matters because manual context management is one of the most common sources of silent bugs in agent systems — the agent “works” but produces worse results because context was truncated incorrectly.

Practical use cases

Use case 1 — Research and synthesis pipeline

The agent receives a topic or a list of URLs, performs research (via custom search tool or web scraping), reads the content, identifies relevant information, synthesizes it into a structured format, and saves the result to a file.

What you add: the search/scraping tool and the system prompt with the desired output format. Everything else — planning, reading, writing, context — is already in deepagents.

Use case 2 — Data analysis with report generation

The agent receives a directory with CSV or JSON files, uses read_file and execute (with pandas or polars) to process the data, generates statistical analyses, and writes a structured report in markdown or HTML.

This use case turns deepagents into an autonomous data analyst. The builder only needs to point to the data and define what they want to see in the report.

Use case 3 — Development agent with automated testing

The agent receives a feature specification, uses write_file to create the code, execute to run tests, reads the results, fixes errors, and iterates until tests pass. This pattern fits directly into AI-assisted TDD.

What makes deepagents suitable here is the execute tool with sandboxing — the agent can run real code in a controlled environment, not just generate static code snippets.

3 product ideas to monetize with deepagents

Product 1 — Automated competitive intelligence SaaS

Problem: Mid-sized companies need to monitor competitors, industry news, and market movements, but don’t have the staff for it. Hiring analysts is expensive. Doing it manually means the information arrives too late.

Solution: A SaaS where the customer configures which companies, topics, and sources to monitor. Every week (or every day), a deepagents agent runs automatically, searches the configured sources, identifies relevant developments, synthesizes them into a briefing, and delivers it via email or Slack.

How it works technically:

• deepagents with search tool (Tavily, SerpAPI, or custom scraping)
• System prompt specialized in competitive analysis
• External scheduler (cron job or n8n) triggers the agent periodically
• Formatted output saved to file and sent via webhook

Monetization model:

• Monthly subscription per company monitored ($25–75/company/month)
• Base plan: 5 companies — $99/month
• Advanced plan: 20 companies + real-time alerts — $249/month
• Target: managers, marketing teams, investors, consulting firms

Product 2 — Technical onboarding agent for development teams

Problem: When a new developer joins a team, it takes weeks to understand the codebase. Documentation is outdated or nonexistent. Senior devs lose hours answering the same questions repeatedly. Onboarding costs are high and invisible.

Solution: A deepagents agent that “reads” the customer’s codebase (via repository access), learns the structure, patterns, and conventions, and stays available to answer questions from new developers: “Where is the authentication logic?”, “How was the payment system implemented?”, “What are the naming conventions in this project?”

How it works technically:

• deepagents with repository access via read_file, ls, glob, grep
• Indexing phase: agent reads and summarizes key modules, saves context to file
• Response phase: agent uses indexed context + code access to answer questions
• Interface: can be a Slack bot or a simple UI via FastAPI

Monetization model:

• Team subscription ($150–400/month depending on repository size)
• Trial plan: 1 repository, 30 days free
• Ideal for selling to CTOs and engineering leads at companies with 5–50 devs
• Natural expansion: charge per additional repository

Product 3 — Content automation engine for vertical niches

Problem: Professionals in specific niches (nutritionists, lawyers, architects, accountants) need to produce content regularly for social media but don’t have time and don’t know how to write for digital channels. Hiring an agency is expensive and produces generic results.

Solution: A vertical product where the professional answers a configuration questionnaire (niche, style, topics they’re expert in, channels), and a deepagents agent produces every week: 5 LinkedIn posts, 3 X threads, 2 short articles, and 1 newsletter — all in the professional’s tone and with their technical knowledge.

How it works technically:

• deepagents with content generation tool (highly specialized system prompt per niche)
• Sub-agents for each format: one sub-agent handles LinkedIn, another handles the newsletter, etc.
• Weekly input: topics of the week + niche news + pending approvals
• Output: folder with all formatted content + preview for approval before posting

Monetization model:

• Per-professional subscription: $50–100/month
• Paid onboarding: $150 initial setup fee
• Natural scale: a single agent serves dozens of professionals simultaneously
• Differentiator: vertically specialized product, not generic — the niche justifies the price

How to get started: step by step

Prerequisites

• Python 3.10+
• An OpenAI API key (or any LLM that supports tool calling)
• Optional: uv for dependency management (recommended)

Installation

# With uv (recommended)
uv add deepagents

# With pip
pip install deepagents

First agent running

from deepagents import create_deep_agent

# Agent with default configuration
agent = create_deep_agent()

# Invoke with a task
result = agent.invoke({
    "messages": [
        {
            "role": "user",
            "content": "Research the 5 biggest micro-SaaS trends for 2026 and write a markdown summary."
        }
    ]
})

print(result["messages"][-1].content)

Customizing: model, tools, and system prompt

from deepagents import create_deep_agent
from langchain.chat_models import init_chat_model

# With a custom model
agent = create_deep_agent(
    model=init_chat_model("openai:gpt-4o-mini"),  # cheaper for production
    system_prompt="""
    You are a SaaS market analysis specialist.
    Always structure your responses with: Executive Summary, Relevant Data, and Recommendations.
    Save all generated reports to /outputs with a timestamp.
    """
)

Adding custom tools

from deepagents import create_deep_agent
from langchain_core.tools import tool

@tool
def lookup_company_data(company_name: str) -> dict:
    """Looks up public data for a company by name."""
    # your implementation here
    return {"name": "...", "revenue": "..."}

agent = create_deep_agent(
    tools=[lookup_company_data],
    system_prompt="You analyze companies based on their public data."
)

Connecting with MCP

deepagents supports Model Context Protocol via langchain-mcp-adapters, which lets you connect to any MCP server — databases, development tools, proprietary APIs.

pip install langchain-mcp-adapters

How to deploy a deepagents agent to production

Having an agent running locally is the starting point, not the destination. To turn it into a product, you need a few more pieces.

Packaging as an API

The most direct path is wrapping the agent in a FastAPI endpoint:

from fastapi import FastAPI
from deepagents import create_deep_agent

app = FastAPI()
agent = create_deep_agent(...)

@app.post("/run")
async def run_agent(task: str):
    # For production, use `await agent.ainvoke(...)` to avoid blocking the event loop
    result = agent.invoke({"messages": [{"role": "user", "content": task}]})
    return {"output": result["messages"][-1].content}

That’s already enough to integrate with n8n, Make, Zapier, or any frontend.

Monitoring with LangSmith

For production, configure LangSmith for full visibility: every agent execution, every tool call, latencies, and errors. It’s free for low volumes and essential for debugging agents in production.

export LANGSMITH_API_KEY=your_key
export LANGSMITH_TRACING=true

Human-in-the-loop

deepagents supports pausing for human approval before executing critical actions — sending emails, deleting files, deploying code. This pattern is critical for products sold to businesses that need oversight of what the agent does.

Where to host

• Railway or Render: simple and cheap for getting started ($15–40/month)
• LangGraph Platform: the native option, with state management and integrated deployment
• Your own VPS: for full cost control at scale

The main cost in production isn’t hosting — it’s the LLM API. For products with many users, use smaller and cheaper models (gpt-4o-mini, Claude Haiku) for batch processing tasks and reserve more capable models for tasks requiring complex reasoning.

Is deepagents worth it? Conclusion for builders

deepagents isn’t another tool for “testing AI.” It’s a production foundation that compresses weeks of infrastructure work into a two-minute install.

For a solo builder building with AI agents, what this means in practice is direct: you spend less time solving context window issues, sub-agent routing, and tool orchestration, and more time building the product that generates revenue.

The gap between “agent that works” and “agent that produces” has always been infrastructure. deepagents closes that gap.

Concrete next steps:

1. Install deepagents and run the basic example — 5 minutes
2. Pick one of the 3 product ideas above (or define your own)
3. Customize the system prompt and tools for your use case
4. Package as an API and validate with 3–5 real users before charging
5. Configure LangSmith before opening to the public — you’ll need it

The code is available, the documentation is clean, and the framework is MIT-licensed. The only missing piece is you starting to build.

FAQ

Does deepagents work with models beyond OpenAI?

Yes. Any model with tool calling support works — Claude (Anthropic), Gemini (Google), Llama via Groq or Ollama locally. Use LangChain’s init_chat_model() to plug in your preferred model.

How is it different from CrewAI or AutoGen?

CrewAI and AutoGen focus on multi-agent orchestration with predefined roles. deepagents is more low-level and flexible — you start with a complete agent and add sub-agents as needed. For products that need granular control over agent behavior, deepagents tends to be a better fit.

Do I need a LangSmith account?

No. LangSmith is optional and free for low volumes. It’s highly recommended for production, but not required for development.

How much does it cost to run in production?

The main cost is the LLM API. An agent running GPT-4o-mini on processing tasks costs roughly $0.001–0.01 per execution depending on volume. For 1,000 executions per month, the LLM cost stays below $10.

Does deepagents support MCP?

Yes, via langchain-mcp-adapters. That allows connecting to any MCP server — databases, development tools, proprietary APIs.

deepagents vs raw LangGraph: when to use each?

Use deepagents when you want to start fast with a fully functional agent — it already includes tools, planning, and context management. Use LangGraph directly when you need a highly customized state graph with complex routing logic between multiple nodes. For most solo products, deepagents is the right starting point; raw LangGraph is for advanced cases where deepagents’ abstractions get in the way.

Can deepagents be used with Claude (Anthropic)?

Yes. deepagents is model-agnostic — any LLM with tool calling support works. To use Claude, install langchain-anthropic and pass the model via init_chat_model("anthropic:claude-3-5-sonnet-20241022"). Agent behavior is identical.