AutoGineer
Generated banner for Deepagents Typescript Quickstart
Generated logo for Deepagents Typescript Quickstart

Deepagents Typescript Quickstart

LangChainOfficialPublished by LangChain

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

From the author

Scaffold a minimal local Deep Agent in TypeScript 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 developers to initialize a local Deep Agent using TypeScript. It follows the official quickstart documentation while enforcing specific constraints to keep the setup lightweight and model-agnostic. By replacing external search dependencies like Tavily with provider-native search tools, it simplifies the configuration process and reduces the number of required API keys.

What it does

  • Initializes a new project directory for Deep Agent development.
  • Prompts the user to select a preferred AI provider and model.
  • Configures the agent to use the selected provider's built-in web search capabilities.
  • Installs necessary dependencies while excluding external search tool packages.
  • Implements a research-agent structure based on the official quickstart.
  • Executes a sample research query to verify the agent's functionality.

When to use it

  • When you need to quickly prototype a Deep Agent locally.
  • When you want to experiment with different AI models using a consistent agent framework.
  • When you prefer using provider-native search tools over third-party search APIs.
  • When you are starting a new project and want to avoid polluting existing directories.

Advantages

  • Maintains a clean project structure by isolating the agent in a dedicated directory.
  • Reduces dependency complexity by leveraging built-in provider search tools.
  • Ensures model-agnostic flexibility by allowing user-defined provider selection.
  • Follows official documentation patterns for reliable implementation.

Usage examples

“Help me set up a new Deep Agent in a local folder.”
The agent will create a new directory, ask for your preferred model (e.g., anthropic:claude-sonnet-5), install the required packages, and configure the agent to use the provider's native search tool.
“I want to test a research agent using Google Gemini.”
The agent will scaffold the project, configure the Google provider with its built-in search tool, and run a test query to confirm the agent is working correctly.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/langchain-ai/deepagents-typescript-quickstart/download

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

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

Documentation by LangChain

Deep Agents TypeScript quickstart

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

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

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

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 @langchain/tavily). Replace the quickstart's search tool with the chosen provider's built-in web search. Look up the current export/tool shape on that provider's LangChain docs (examples as of writing — re-check if needed):

    ProviderBuilt-in search tool
    Anthropic@langchain/anthropic tools.webSearch_*() (or equivalent dict)
    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 packages from the quickstart minus Tavily; add the provider package for their model.

  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

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-typescript-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-typescript-quickstart.zip