Sanity is now available on the Vercel Marketplace as a native CMS integration. Teams can now install, configure, and manage Sanity directly from the Vercel dashboard, eliminating manual API token setup and environment variable configuration.

This integration keeps CMS setup inside your existing Vercel workflow instead of requiring a separate dashboard for provisioning and account management.

Link to headingGet started with the integration

Define your content schema, set up the client, and start fetching content. Schemas define your content structure in code, specifying document types and their fields.

1
import { defineField, defineType } from "sanity";
2

3
export const postType = defineType({
4
  name: "post",
5
  title: "Post",
6
  type: "document",
7
  fields: [
8
    defineField({ name: "title", type: "string" }),
9
    defineField({ name: "slug", type: "slug", options: { source: "title" } }),
10
    defineField({ name: "body", type: "array", of: [{ type: "block" }] }),
11
  ],
12
});

Register your schema types in an index file so Sanity can load them.

1
import { postType } from "./postType";
2

3
export const schemaTypes = [postType];

The Sanity client connects your application to your content. The Marketplace integration provisions the project ID as an environment variable automatically.

1
import { createClient } from "next-sanity";
2

3
export const client = createClient({
4
  projectId: process.env.NEXT_PUBLIC_SANITY_PROJECT_ID,
5
  dataset: "production",
6
  apiVersion: "2024-01-01",
7
  useCdn: false,
8
});

With the client configured, you can fetch content using GROQ (Graph-Relational Object Queries), Sanity's query language for requesting exactly the fields you need.

1
import { client } from "@/sanity/lib/client";
2

3
const POSTS_QUERY = `*[_type == "post"] | order(publishedAt desc)[0...12]{
4
  _id, title, slug, publishedAt
5
}`;
6

7
export default async function HomePage() {
8
  const posts = await client.fetch(POSTS_QUERY);
9
  return (
10
    <ul>
11
      {posts.map((post) => (
12
        <li key={post._id}>{post.title}</li>
13
      ))}
14
    </ul>
15
  );
16
}

That's all you need to go from install to fetching content. Install Sanity from the Vercel Marketplace to get started, or deploy the Next.js + Sanity Personal Website template to start from a working example.

The Vercel Sandbox SDK now includes two new methods that make file retrieval simple.

When you run code in a Vercel Sandbox, that code can generate files like a CSV report, a processed image, or a PDF invoice. These files are created inside isolated VMs, so they need to be retrieved across a network boundary. Until now, this required manual stream handling with custom piping.

Link to headingDownload a file

If you want to download a generated report from your sandbox to your local machine, you can use downloadFile() to seamlessly stream the contents.

1
const dstPath = await sandbox.downloadFile(
2
  { path: 'generated-file.csv', cwd: '/vercel/sandbox' },
3
  { path: 'generated-file.csv', cwd: '/tmp' }
4
);

Link to headingRead file contents to buffer

Both methods handle the underlying stream operations automatically. For example, if your sandbox runs a script that generates a chart as a PNG, you can pull it out with a single call to readFileToBuffer(), no manual stream wiring needed.

1
​const buffer = await sandbox.readFileToBuffer({ path: 'chart.png' });​

Learn more about the Sandbox SDK or explore the updated documentation.

Anthropic's latest flagship model, Claude Opus 4.6, is now available on AI Gateway. Built to power agents that handle real-world work, Opus 4.6 excels across the entire development lifecycle. Opus 4.6 is also the first Opus model to support the extended 1M token context window.

The model introduces adaptive thinking, a new parameter that lets the model decide when and how much to reason. This approach enables more efficient responses while maintaining quality across programming, analysis, and creative tasks, delivering equal/better performance than extended thinking. Opus 4.6 can interleave thinking and tool calls within a single response.

To use the model, set model to anthropic/claude-opus-4.6. The following example also uses adaptive thinking and the effort parameter.

1
import { streamText } from 'ai';
2

3
const result = streamText({
4
  model: 'anthropic/claude-opus-4.6',
5
  prompt:
6
    `Trace this race condition through the event loop, identify all
7
     affected code paths, and implement a fix with proper test coverage.`,
8
  providerOptions: {
9
    anthropic: {
10
      thinking: { type: 'adaptive' },
11
      effort: 'max',
12
    },
13
  },
14
});

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.

URLs in build logs are now interactive. Navigate directly to internal and external resources without manually copying and pasting. External links open in a new tab.

This eliminates any extra steps you may encounter when investigating build issues or following documentation links.

Learn more about accessing build logs.

You can now use Parallel's LLM-optimized web search and other tools all across Vercel.

Link to headingAI Gateway

Unlike provider-specific web search tools that only work with certain models, Parallel's web search tool works universally across all providers. This means you can add web search capabilities to any model without changing your implementation.

To use through AI SDK, set parallel_search: gateway.tools.parallelSearch() in tools.

1
import { gateway, streamText } from 'ai';
2

3
const result = streamText({
4
  model: 'moonshotai/kimi-k2.5', // Works with any model
5
  prompt: 'What are the best new restaurants in San Francisco?',
6
  tools: {
7
    parallel_search: gateway.tools.parallelSearch(),
8
  },
9
});

Parallel web search extracts relevant excerpts from web pages, making it ideal for agentic tasks and real-time information retrieval. For more control, you can also configure the tool to use specific parameters.

1
import { gateway, streamText } from 'ai';
2

3
const result = streamText({
4
  model: 'moonshotai/kimi-k2.5',
5
  prompt: 'What new AI model releases have been announced this month?',
6
  tools: {
7
    parallel_search: gateway.tools.parallelSearch({
8
      mode: 'one-shot',
9
      maxResults: 10,
10
      sourcePolicy: {
11
        includeDomains: [
12
          'openai.com',
13
          'anthropic.com',
14
          'deepseek.com',
15
          'moonshot.ai',
16
          'deepmind.google',
17
        ],
18
        afterDate: '2026-01-01',
19
      },
20
    }),
21
  },
22
});

For agentic workflows, use mode: 'agentic' to get concise, token-efficient search results that work well in multi-step reasoning.

Time-sensitive queries can control cache freshness with maxAgeSeconds, while domain-specific search lets you restrict results to trusted sources or exclude noisy domains.

Parallel web search requests are charged at exactly the same rate as the Parallel API. $5 per 1,000 requests (includes up to 10 results per request) and additional results beyond 10 charged at $1 per 1,000 additional results. Read the docs for more information and details on how to use the tool.

Link to headingAI SDK

AI SDK supports Parallel as a tool for both web search and extraction. To use, simply install the parallel-web tool package.

1
pnpm install @parallel-web/ai-sdk-tools

View the docs for more details on how to utilize the tools.

Link to headingVercel Marketplace

You can utilize all Parallel products: Search, Extract, Task, Findall, and Monitoring in Vercel Agent Marketplace with centralized billing through Vercel and a single API key. To get started, go to the Parallel integration and connect your account or deploy the Next.js template to integrate Parallel's web research APIs with Vercel in action.

Get started with Parallel for your AI applications through AI Gateway, the AI SDK tool package, or Vercel Marketplace.

Parallel is now available on the Vercel Agent Marketplace with native integration support.

Parallel provides web tools and agents designed for LLM-powered applications, including Search, Extract, Tasks, FindAll, and Monitoring capabilities. The Vercel integration provides a single API key that works across all Parallel products, with billing handled directly through your Vercel account.

For developers building AI features on Vercel, Parallel enables agents to access the open web for tasks like answering questions, monitoring changes, and extracting structured data. Since Parallel returns results optimized for LLM consumption, your agents can resolve tasks with fewer round trips and reduced cost and latency.

1
import Parallel from "parallel-web";
2

3
const client = new Parallel({ apiKey: process.env.PARALLEL_API_KEY });
4

5
async function main() {
6
    const search = await client.beta.search({
7
        objective: "When was the United Nations established? Prefer UN's websites.",
8
        search_queries: [
9
            "Founding year UN",
10
            "Year of founding United Nations"
11
        ],
12
        max_results: 10,
13
        excerpts: { max_chars_per_result: 10000 },
14
    });
15

16
    console.log(search.results);
17
}
18

19
main().catch(console.error);

Install Parallel from the Marketplace or deploy the Next.js template to see Parallel's web research APIs integrated with Vercel in action.

ByteDance's coding agent TRAE now integrates both AI Gateway and direct Vercel deployments, bringing unified AI access and instant production shipping to over 1.6 million monthly active developers. Teams can now access hundreds of models through a single API key and deploy applications directly to Vercel from the TRAE interface.

AI Gateway provides unified access to models from Anthropic, OpenAI, Google, xAI, DeepSeek, Z.AI, MiniMax, Moonshot AI, and more without managing multiple provider accounts.

The integration includes automatic failover that routes around provider outages, zero markup on AI tokens, and unified observability to monitor both deployments and AI usage. Meanwhile, the Vercel deployment integration handles authorization automatically and returns live URLs immediately after clicking Deploy.

Link to headingSOLO Mode

Setting up Vercel deployment

In SOLO mode, click the + tab and choose Integrations to connect your Vercel account. When your project is ready, click Deploy in the chat panel to ship directly to production.

Once linked, all projects can immediately deploy to Vercel and are also visible in your Vercel dashboard.

Setting up AI Gateway

In Integrations, choose Vercel AI Gateway as your AI Service and add your API key from the Vercel AI Gateway dashboard. Select any model and start coding with automatic failover, low latency, and full observability.

Link to headingIDE Mode

TRAE's IDE mode supports AI Gateway as a model provider with access to the full range of available models alongside direct deployment capabilities.

Configuration

1
// Click the model list dropdown in Builder chat and select Add Model
2
// Choose Vercel AI Gateway for Provider
3
// Select your model or choose Other Models and enter the creator/model slug
4
// Add your API key

You can switch models with a single configuration change while maintaining unified billing through Vercel. This creates a complete development experience where teams write code with any AI model, then ship to production with one click from the same interface.

Get started with AI Gateway or explore the documentation to learn more.

Turbo build machines are now the default for all new Pro projects and projects upgrading from Hobby to the Pro plan.

Turbo build machines were introduced in October for all paid plans, delivering 30vCPUs and 60GB of memory for faster build performance.

Teams adopting Turbo build machines have seen significant build time improvements:

• up to 30% faster for builds under 2 minutes

• up to 50% faster for builds that take 2-10 minutes

• up to 70% faster for builds over 10 minutes

Learn more in the documentation or customize your build machine in settings.