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.

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.

Kling video models are now available in AI Gateway, including the newest Kling 3.0 models. Generate cinematic videos from text, images, or motion references with Kling's state-of-the-art video models, now available through AI Gateway and AI SDK.

Kling models are known for their image to video models and multishot capabilities:

• Image-to-Video Capabilities: Strong at animating still images into video clips

• Realistic Motion and Physics: Known for coherent motion, facial expressions, and physical interactions

• High Resolution Output: Supports up to 1080p generation (pro mode)

• Multishot Narratives: Kling 3.0 can generate multi-scene videos from a single narrative prompt

• Audio Generation: Create synchronized sound effects and ambient audio alongside your video

• First & Last Frame Control: Specify both start and end frames for precise scene transitions

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: 'klingai/kling-v2.6-t2v',
5
  prompt: 'A chef plates a dessert with caramel drizzle. Kitchen ambiance.',
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 video from a text description.

In this example, model klingai/kling-v3.0-t2v is used to generate a video of a cherry blossom tree with no inputs other than a simple text prompt.

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

3
const { videos } = await generateVideo({
4
  model: 'klingai/kling-v3.0-t2v',
5
  prompt:
6
   `Cherry blossom petals falling in slow motion through golden sunlight,
7
    Japanese garden with a stone lantern, peaceful atmosphere, cinematic`,
8
  aspectRatio: '16:9',
9
  duration: 5,
10
  providerOptions: {
11
    klingai: {
12
      mode: 'pro',
13
    },
14
  },
15
});

Link to headingAdvanced: Multishot Video

Generate a narrative video with multiple scenes with only a single prompt. Using Kling 3.0's multishot feature, the model intelligently cuts between shots to tell a complete story:

The prompt is written as a narrative with multiple distinct scenes for the best results. shotType: 'intelligence' lets the model decide optimal shot composition and sound: 'on' generates synchronized audio for the entire video. Note that the prompt here is in the providerOptions since this functionality is specific to Kling. The Kling 3.0 models support this functionality: here klingai/kling-v3.0-t2v is used.

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

3
const { videos } = await generateVideo({
4
  model: 'klingai/kling-v3.0-t2v',
5
  prompt: '',
6
  aspectRatio: '16:9',
7
  duration: 10,
8
  providerOptions: {
9
    klingai: {
10
      mode: 'pro',
11
      multiShot: true,
12
      shotType: 'intelligence',
13
      prompt:
14
       `Elephants walk across a golden savanna under gathering storm clouds.
15
        Lightning cracks in the distance. Rain begins to fall heavily.
16
        The herd finds shelter under acacia trees.
17
        The storm clears revealing a double rainbow.`,
18
      sound: 'on',
19
    },
20
  },
21
});

Link to headingAdvanced: First & Last Frame Control

Control exactly how your video starts and ends by providing both a first frame and last frame image. This is perfect for time-lapse effects or precise scene transitions:

These 2 images were provided as start and end frames.

Using AI SDK 6, you can set image and lastFrameImage with your start and end frames. In this example, klingai/kling-v3.0-i2v is used for the model.

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

3
const { videos } = await generateVideo({
4
  model: 'klingai/kling-v3.0-i2v',
5
  prompt: {
6
    image: startImage,
7
    text: `Time-lapse of a pink peony flower blooming.
8
     The tight bud slowly unfurls, petals gently separating and opening outward.
9
     Smooth organic movement. Soft natural lighting.`,
10
  },
11
  duration: 10,
12
  providerOptions: {
13
    klingai: {
14
      lastFrameImage: endImage,
15
      mode: 'pro',
16
    },
17
  },
18
});

Link to headingLearn More

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

Generate photorealistic videos with synchronized audio using Google's Veo models, now available through AI Gateway. Try them out now via AI SDK 6 or by selecting the models in the AI Gateway playground.

Veo models are known for their cinematic quality and audio generation:

• Native Audio Generation: Automatically generate realistic sound effects, ambient audio, and even dialogue that matches your video

• Up to 1080p Resolution: Generate videos at 720p and 1080p

• Photorealistic Quality: Realism for nature, wildlife, and cinematic scenes

• Image-to-Video: Animate still photos with natural motion

• Fast Mode: Quicker generation when you need rapid iterations

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: 'google/veo-3.1-generate-001',
5
  prompt: 'Woman sipping coffee by a rain-streaked window, cozy morning light.',
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

Describe a scene and get a video.

Generate a cinematic wildlife video with natural sound: here google/veo-3.1-generate-001 is used with generateAudio: true.

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

3
const { videos } = await generateVideo({
4
  model: 'google/veo-3.1-generate-001',
5
  prompt:
6
   `Close-up of a great horned owl
7
    turning its head slowly in a moonlit forest.`,
8
  aspectRatio: '16:9',
9
  providerOptions: {
10
    vertex: { generateAudio: true },
11
  },
12
});

Link to headingAdvanced: Image-to-Video with Dialog

A common workflow to ensure quality is generating a custom image with Gemini 3 Pro Image (Nano Banana Pro), then bringing it to life with Veo, complete with motion and spoken dialog.

Starting image from Nano Banana Pro:

Use prompts with image input with the Veo models for more control over the output. This example uses google/veo-3.1-generate-001, which supports image to video.

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

3
const { videos } = await generateVideo({
4
  model: 'google/veo-3.1-generate-001',
5
  prompt: {
6
    image: imageUrl,
7
    text:
8
     `The podcast host says "Welcome back to the show! Today we are diving
9
      into something really exciting." with a friendly smile, rain falling on
10
      window, cozy atmosphere.`,
11
  },
12
  aspectRatio: '16:9',
13
  duration: 4,
14
  providerOptions: {
15
    vertex: { generateAudio: true },
16
  },
17
});

Link to headingLearn More

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