The bundle size limit for Vercel Functions using the Python runtime is now 500MB, increasing the maximum uncompressed deployment bundle size from 250MB.

Learn more in the functions limitations documentation, or deploy FastAPI or Flask on Vercel to get started.

GPT 5.3 Codex is now available on AI Gateway. GPT 5.3 Codex brings together the coding strengths of GPT-5.2-Codex and the reasoning depth of GPT-5.2 in a single model that's 25% faster and more token-efficient.

Built for long-running agentic work, the model handles research, tool use, and multi-step execution across the full software lifecycle, from debugging and deployment to product documents and data analysis. Additionally, you can steer it mid-task without losing context. For web development, it better understands underspecified prompts and defaults to more functional, production-ready output.

To use this model, set model to openai/gpt-5.3-codex in the AI SDK.

1
import { streamText } from 'ai';
2

3
const result = streamText({
4
  model: 'openai/gpt-5.3-codex',
5
  prompt:
6
    `Research our current API architecture, identify performance
7
     bottlenecks, refactor the slow endpoints, add monitoring,
8
     and deploy the changes to staging.`,
9
});

AI Gateway provides a unified API for calling models, tracking usage and cost, and configuring retries, failover, and performance optimizations for higher-than-provider uptime. It includes built-in observability, Bring Your Own Key support, and intelligent provider routing with automatic retries.

Learn more about AI Gateway, view the AI Gateway model leaderboard or try it in our model playground.

The Slack Agent Skill is now available, enabling developers to build and deploy Slack agents in a single session with their coding agent of choice.

The skill handles the complexity of OAuth configuration, webhook handlers, event subscriptions, and deployment so you can focus on what your agent should do rather than on infrastructure setup.

The wizard walks through five stages:

1. Project setup: Choose your LLM provider and initialize from the Slack Agent Template

2. Slack app creation: Generate a customized app manifest and create the app in Slack's console

3. Environment configuration: Set up signing secrets, bot tokens, and API keys with validation

4. Local testing: Run locally with ngrok and verify the integration

5. Production deployment: Deploy to Vercel with environment variables configured automatically

Install the skill and run the wizard by invoking it in your coding agent (for example, /slack-agent new in Claude Code).

1
npx skills add vercel-labs/slack-agent-skill

Try the skill to make your custom agent or use the Slack Agent Template to deploy right away and customize later.

Building chatbots across multiple platforms traditionally requires maintaining separate codebases and handling individual platform APIs.

Today, we're open sourcing the new Chat SDK in public beta. It's a unified TypeScript library that lets teams write bot logic once and deploy it to Slack, Microsoft Teams, Google Chat, Discord, GitHub, and Linear.

The event-driven architecture includes type-safe handlers for mentions, messages, reactions, button clicks, and slash commands. Teams can build user interfaces using JSX cards and modals that render natively on each platform.

The SDK handles distributed state management using pluggable adapters for Redis, ioredis, and in-memory storage.

1
import { Chat } from "chat";
2
import { createSlackAdapter } from "@chat-adapter/slack";
3
import { createRedisState } from "@chat-adapter/state-redis";
4

5
const bot = new Chat({
6
  userName: "mybot",
7
  adapters: {
8
    slack: createSlackAdapter(),
9
  },
10
  state: createRedisState(),
11
});
12

13
bot.onNewMention(async (thread) => {
14
  await thread.subscribe();
15
  await thread.post("Hello! I am listening to this thread.");
16
});

You can post messages to any provider with strings, objects, ASTs and even JSX!

1
import { Card, CardText, Actions, Button } from "chat";
2

3
await thread.post(
4
  <Card title="Order #1234">
5
    <CardText>Your order has been received!</CardText>
6
    <Actions>
7
      <Button id="approve" style="primary">Approve</Button>
8
      <Button id="reject" style="danger">Reject</Button>
9
    </Actions>
10
  </Card>
11
);

Chat SDK post() functions accept an AI SDK text stream, enabling real-time streaming of AI responses and other incremental content to chat platforms.

1
import { ToolLoopAgent } from "ai";
2

3
const agent = new ToolLoopAgent({
4
  model: "anthropic/claude-4.6-sonnet",
5
  instructions: "You are a helpful assistant.",
6
});
7

8
bot.onNewMention(async (thread, message) => {
9
  const result = await agent.stream({ prompt: message.text });
10
  await thread.post(result.textStream);
11
});

The framework starts with the core chat package and scales through modular platform adapters. Guides are available for building a Slack bot with Next.js and Redis, a Discord support bot with Nuxt, a GitHub bot with Hono, and automated code review bots.

Explore the documentation to learn more.

Vercel Sandbox can now automatically inject HTTP headers into outbound requests from sandboxed code. This keeps API keys and tokens safely outside the sandbox VM boundary, so apps running inside the sandbox can call authenticated services without ever accessing the credentials.

Header injection is configured as part of the network policy using transform. When the sandbox makes an HTTPS request to a matching domain, the firewall adds or replaces the specified headers before forwarding the request.

1
const sandbox = await Sandbox.create({
2
  timeout: 300_000,
3
  networkPolicy: {
4
    allow: {
5
      "ai-gateway.vercel.sh": [{
6
        transform: [{
7
          headers: {
8
            authorization: `Bearer ${process.env.AI_GATEWAY_API_KEY}`
9
          }
10
        }],
11
      }],
12
    },
13
  },
14
});
15

16
// Code inside the sandbox calls AI Gateway without knowing the API key
17
const result = await sandbox.runCommand('curl',
18
  ['-s', 'https://ai-gateway.vercel.sh/v1/models']
19
);

This is designed for AI agent workflows where prompt injection is a real threat. Even if an agent is compromised, there's nothing to exfiltrate, as the credentials only exist in a layer outside the VM.

Injection rules work with all egress network policy configurations, including open internet access. To allow general traffic while injecting credentials for specific services:

1
const sandbox = await Sandbox.create({
2
  networkPolicy: {
3
    allow: {
4
      "ai-gateway.vercel.sh": [{
5
        transform: [{
6
          headers: {
7
            Authorization: `Bearer ${process.env.AI_GATEWAY_API_KEY}` 
8
          }
9
        }],
10
      }],
11
      "*.github.com": [{
12
        transform: [{
13
          headers: {
14
            Authorization: `Bearer ${process.env.GITHUB_TOKEN}`
15
          }
16
        }],
17
      }],
18
      // Allow traffic to all other domains.
19
      "*": []
20
    }
21
  }
22
});

Link to headingLive updates

Like all network policy settings, injection rules can be updated on a running sandbox without restarting it. This enables multi-phase workflows, inject credentials during setup, then remove them before running untrusted code:

1
// Phase 1: Clone repos with credentials
2
await sandbox.updateNetworkPolicy({
3
  allow: {
4
    "api.github.com": [{
5
      transform: [{
6
        headers: {
7
          Authorization: `Bearer ${process.env.GITHUB_TOKEN}`
8
        }
9
        }],
10
    }],
11
  }
12
});
13

14
// ... clone repos, download data ...
15

16
// Phase 2: Lock down before running untrusted code
17
await sandbox.updateNetworkPolicy('deny-all');

Link to headingKey highlights

• Header overwrite: Injection applies to HTTP headers on outbound requests.

• Full replacement: Injected headers overwrite any existing headers with the same name set by sandbox code, preventing the sandbox from substituting its own credentials.

• Domain matching: Supports exact domains and wildcards (e.g., *.github.com). Injection only triggers when the outbound request matches.

• Works with all policies: Combine injection rules with allow-all, or domain-specific allow lists.
  

Available to all Pro and Enterprise customers. Learn more in the documentation.

Support for the legacy now.json config file will be officially removed on March 31st, 2026. Migrate existing now.json files by renaming them to vercel.json, no other content changes are required.

For more advanced use cases, try vercel.ts for programmatic project configuration.

Learn more about configuring projects with vercel.json in the documentation.

Generate high-quality videos with natural motion and audio using xAI's Grok Imagine Video, now in AI Gateway. Try it out now via the v0 Grok Creative Studio, AI SDK 6 or by selecting the model in the AI Gateway playground.

Grok Imagine is known for realistic motion and strong instruction following:

• Fast Generation: Generates clips in seconds rather than minutes

• Instruction Following: Understands complex prompts and follow-up instructions to tweak scenes

• Video Editing: Transform existing videos by changing style, swapping objects, or altering scenes

• Audio & Dialogue: Native audio generation with natural, expressive voices and accurate lip-sync

Link to headingThree ways to get started

Video generation is in beta and currently available for Pro and Enterprise plans and paid AI Gateway users.

• v0 Grok Creative Studio: The v0 team created a template that is powered by AI Gateway to create and showcase Grok Video and Image generations.

• AI SDK 6: Generate videos programmatically AI SDK 6's generateVideo.

1
import { experimental_generateVideo as generateVideo } from 'ai';
2

3
const { videos } = await generateVideo({
4
  model: 'xai/grok-imagine-video',
5
  prompt: 'A golden retriever catching a frisbee mid-air at the beach',
6
});

• Gateway Playground: Experiment with video models with no code in the configurable AI Gateway playground that's embedded in each model page. Compare providers, tweak prompts, and download results without writing code. To access, click any video gen model in the model list.

Link to headingAvailable Model

Link to headingSimple: Text-to-Video

Generate a video from a text description.

In this example, xai/grok-imagine-video is used to generate a video of 2 swans. Note that you can also specify the duration of the output.

1
import { experimental_generateVideo as generateVideo } from 'ai';
2

3
const { videos } = await generateVideo({
4
  model: 'xai/grok-imagine-video',
5
  prompt:
6
   `Two elegant white swans gliding on a misty lake at dawn, soft golden light,
7
    reflections on still water, romantic atmosphere, cinematic`,
8
  aspectRatio: '16:9',
9
  resolution: '1280x720',
10
  duration: 3,
11
});

Link to headingAdvanced: Reference-to-Video

Transform an existing video into a new style:

In this example, using a previous generation from Grok Imagine Video, the output was transformed into an animated watercolor style.

The source video is used and edited, which is useful for style transfer, object swapping, and scene transformations.

1
import { experimental_generateVideo as generateVideo } from 'ai';
2

3
const { videos } = await generateVideo({
4
  model: 'xai/grok-imagine-video',
5
  prompt:
6
   'Transform into anime style, soft hand-painted look, warm dreamy atmosphere',
7
  providerOptions: {
8
    xai: {
9
      videoUrl: sourceVideo,
10
    },
11
  },
12
});

Link to headingLearn More

For more examples and detailed configuration options for Grok Imagine Video, check out the Video Generation Documentation. You can also find simple getting started scripts with the Video Generation Quick Start.

Generate stylized videos and transform existing footage with Alibaba's Wan models, now available through AI Gateway. Try them out now via AI SDK 6 or by selecting the models in the AI Gateway playground.

Wan produces artistic videos with smooth motion and can use existing content to keep videos consistent:

• Character Reference (R2V): Extract character appearance and voice from reference videos/images to generate new scenes

• Flash Variants: Faster generation times for quick iterations

• Flexible Resolutions: Support for 480p, 720p, and 1080p output

Link to headingTwo ways to get started

Video generation is in beta and currently available for Pro and Enterprise plans and paid AI Gateway users.

• AI SDK 6: Generate videos programmatically AI SDK 6's generateVideo.

1
import { experimental_generateVideo as generateVideo } from 'ai';
2

3
const { videos } = await generateVideo({
4
  model: 'alibaba/wan-v2.6-t2v',
5
  prompt: 'Watercolor painting of a koi pond coming to life.',
6
});

• Gateway Playground: Experiment with video models with no code in the configurable AI Gateway playground that's embedded in each model page. Compare providers, tweak prompts, and download results without writing code. To access, click any video gen model in the model list.

Link to headingAvailable Models

Link to headingSimple: Text-to-Video with Audio

Generate a stylized video from a text description.

You can use detailed prompts and specify styles with the Wan models to achieve the desired output generation. The example here uses alibaba/wan-v2.6-t2v:

1
import { experimental_generateVideo as generateVideo } from 'ai';
2

3
const { videos } = await generateVideo({
4
  model: 'alibaba/wan-v2.6-t2v',
5
  prompt:
6
   `Animated rainy Tokyo street at night, anime style,
7
    neon signs reflecting on wet pavement, people with umbrellas
8
    walking past, red and blue lights glowing through the rain.`,
9
  resolution: '1280x720',
10
  duration: 5,
11
});

Link to headingAdvanced: Reference-to-Video

Generate new scenes using characters extracted from reference images or videos.

In this example, 2 reference images of dogs are used to generate the final video.

Using alibaba/wan-v2.6-r2v-flash here, you can instruct the model to utilize the people/characters within the prompt. Wan suggests using character1, character2, etc. in the prompt for multi-reference to video to get the best results.

1
import { experimental_generateVideo as generateVideo } from 'ai';
2

3
const { videos } = await generateVideo({
4
  model: 'alibaba/wan-v2.6-r2v-flash',
5
  prompt:
6
   `character1 and character2 are playing together on the beach in San Francisco
7
    with the Golden Gate Bridge in the background, sunny day, waves crashing`,
8
  resolution: '1280x720',
9
  duration: 5,
10
  providerOptions: {
11
    alibaba: {
12
      referenceUrls: [shibaImage, yorkieImage],
13
    },
14
  },
15
});

Link to headingLearn More

For more examples and detailed configuration options for Wan models, check out the Video Generation Documentation. You can also find simple getting started scripts with the Video Generation Quick Start.