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://mp-staging.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.

Download ZIP

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