AutoGineer
Generated banner for Deepagents Python Quickstart
Generated logo for Deepagents Python Quickstart

Deepagents Python Quickstart

LangChainOfficialPublished by LangChain

  • Skill
  • Workflow
  • Software development
  • MIT
  • No issues found
Download ZIP

From the author

Scaffold a minimal local Deep Agent in Python by following the official quickstart, using provider-native web search instead of Tavily. Use when the user wants to quickly build or try a Deep Agent locally.
— the description by LangChain

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured workflow for scaffolding a local Deep Agent in Python. It guides the user through the official quickstart process while enforcing specific constraints to ensure a clean, model-agnostic setup. By replacing external search dependencies like Tavily with provider-native search tools, it simplifies configuration and reduces the need for additional API keys.

What it does

  • Initializes a new project directory for the Deep Agent.
  • Prompts the user to select a preferred model provider.
  • Configures the agent to use the provider's built-in web search tool.
  • Installs necessary dependencies including deepagents and python-dotenv.
  • Executes a sample research task to verify the agent's functionality.

When to use it

  • When you want to quickly prototype a Deep Agent locally.
  • When you need a clean, isolated environment for agent development.
  • When you prefer using native search capabilities provided by your model vendor.
  • When you want to test agent behavior across different model providers.

Advantages

  • Keeps project setup minimal and organized in a dedicated directory.
  • Reduces dependency overhead by avoiding external search vendors.
  • Ensures the agent remains model-agnostic and flexible.
  • Provides a clear, verifiable path from installation to execution.

Usage examples

“Help me set up a new Deep Agent locally using Claude.”
The agent will create a new directory, install the required packages, configure the Anthropic provider with its native web search, and run a test research query.
“I want to build a research agent using Google Gemini.”
The agent will scaffold the project, set up the Google search tool integration, and demonstrate the agent performing a live research task.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/langchain-ai/deepagents-python-quickstart/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip deepagents-python-quickstart.zip -d .agents/skills

Documentation by LangChain

Deep Agents Python quickstart

Follow the live docs — do not invent an alternate API from memory:

https://docs.langchain.com/oss/python/deepagents/quickstart

Fetch that page (Docs MCP or HTTP) and implement the research-agent shape it shows (create_deep_agent, research system prompt, invoke with a research question like “What is LangGraph?”).

Local setup constraints

Apply these on top of the quickstart (they keep setup minimal and model-agnostic):

  1. Ask which provider/model to use. Showcase that Deep Agents are model-agnostic. Suggested prompt:

    Which model should this agent use? Pass a provider:model string — e.g. openai:gpt-5.5, anthropic:claude-sonnet-5, google_genai:gemini-3.5-flash. Default if you're unsure: anthropic:claude-sonnet-5.
    We'll use that provider's built-in web search (no separate search API key).

  2. Create a new directory (e.g. deep-agent/) and do all work there — do not pollute the open project.

  3. Do not use Tavily (or any second search vendor). Replace the quickstart's internet_search / Tavily tool with the chosen provider's built-in web search. Look up the current tool shape on that provider's LangChain chat docs (examples as of writing — re-check if needed):

    ProviderBuilt-in search tool
    Anthropic{"type": "web_search_20260209", "name": "web_search", "max_uses": 5}
    OpenAI{"type": "web_search"}
    Google{"google_search": {}}

    Prefer Anthropic / OpenAI / Google so provider search is available. Only secret: that provider's API key in .env (gitignored). Skip LangSmith tracing unless they ask.

  4. Install deepagents (+ python-dotenv) and the provider package for their model — not tavily-python.

  5. Run the research example, show output, then stop. Point to deep-agents-core / customization / Managed Deep Agents for next steps.

Files

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an API key, Needs Python

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
LangChain
Publisher
LangChain (Official)
Source
langchain-ai/langchain-skills · config/skills/deepagents-python-quickstart · commit 126c384
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by LangChain or LangChain.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download deepagents-python-quickstart.zip