LangChain

This guide shows how to give a LangChain agent a tool that executes code in Vercel Sandbox, so model-generated code runs in an isolated microVM instead of on your host. Model requests route through AI Gateway.

1. Create a new project

   Create a new directory for your project and initialize it:

   terminal

   mkdir langchain-sandbox
   cd langchain-sandbox
   npm init -y

2. Install dependencies

   Install LangChain, the Anthropic and OpenAI provider packages, and the Sandbox SDK:

   pnpmyarnnpmbun

   Terminal

   pnpm i langchain @langchain/core @langchain/anthropic @langchain/openai @vercel/sandbox zod

   Terminal

   yarn add langchain @langchain/core @langchain/anthropic @langchain/openai @vercel/sandbox zod

   Terminal

   npm i langchain @langchain/core @langchain/anthropic @langchain/openai @vercel/sandbox zod

   Terminal

   bun add langchain @langchain/core @langchain/anthropic @langchain/openai @vercel/sandbox zod

3. Configure authentication

   Link the project to Vercel and pull your development environment. This creates a .env.local file with a VERCEL_OIDC_TOKEN, which authenticates the Sandbox SDK:

   terminal

   vercel link
   vercel env pull

   Create an AI Gateway API key, then add it to .env.local:

   .env.local

   AI_GATEWAY_API_KEY=your_ai_gateway_api_key

   Outside Vercel and local development, authenticate the Sandbox SDK with an access token by setting VERCEL_TOKEN, VERCEL_TEAM_ID, and VERCEL_PROJECT_ID.

4. Create your agent

   Create a new file called index.ts with the following code:

   index.ts

   import * as z from 'zod';
   import { createAgent, tool } from 'langchain';
   import { ChatAnthropic } from '@langchain/anthropic';
   import { Sandbox } from '@vercel/sandbox';
    
   const sandbox = await Sandbox.create({ timeout: 300_000 });
    
   try {
     const runCode = tool(
       async ({ code }) => {
         const result = await sandbox.runCommand('node', ['-e', code]);
         return result.exitCode === 0
           ? await result.stdout()
           : `Command failed: ${await result.stderr()}`;
       },
       {
         name: 'run_code',
         description:
           'Run Node.js code in an isolated Vercel Sandbox and return its output.',
         schema: z.object({
           code: z.string().describe('Node.js code to execute'),
         }),
       },
     );
    
     const model = new ChatAnthropic({
       model: 'anthropic/claude-opus-5',
       apiKey: process.env.AI_GATEWAY_API_KEY,
       anthropicApiUrl: 'https://ai-gateway.vercel.sh',
     });
    
     const agent = createAgent({ model, tools: [runCode] });
    
     const result = await agent.invoke({
       messages: [
         {
           role: 'user',
           content:
             "Compute the SHA-256 hex digest of the exact string 'vercel sandbox' with Node.js, then report the digest.",
         },
       ],
     });
    
     console.log(result.messages.at(-1)?.content);
   } finally {
     await sandbox.stop();
   }

   The timeout value gives the sandbox up to five minutes to finish the agent loop. The finally block stops it sooner when the loop finishes or throws.

   The following code:

   • Creates a sandbox that the agent reuses across tool calls
   • Defines a run_code tool that executes code with sandbox.runCommand()
   • Points the Anthropic chat model at AI Gateway, authenticated with your Vercel credentials
   • Passes the tool to createAgent, which runs the tool-calling loop

   The example uses an Anthropic model. To use an OpenAI model instead, import ChatOpenAI from @langchain/openai and point it at the same gateway:

   index.ts

   import { ChatOpenAI } from '@langchain/openai';
    
   const model = new ChatOpenAI({
     model: 'openai/gpt-5.6-sol',
     apiKey: process.env.AI_GATEWAY_API_KEY ?? process.env.VERCEL_OIDC_TOKEN,
     configuration: { baseURL: 'https://ai-gateway.vercel.sh/v1' },
   });

   Any AI Gateway model works the same way.

5. Run the agent

   Run your agent with the environment variables from .env.local:

   terminal

   npx tsx --env-file=.env.local index.ts

   The agent writes Node.js code, executes it in the sandbox, and reports the digest.