TechPrufer
Get started
Vercel
Vercel logoVercel · Feature trail

AI Gateway and AI SDK Integration

81 posts · Jan 2023 – Oct 2026

What this trail covers

Vercel's AI SDK continues to evolve, offering enhanced capabilities for building and running AI agents. Version 7 introduces production-ready features for agent development, including reasoning control, tool and runtime context management, provider file and skill uploads, MCP Apps for richer UIs, and a terminal UI for rapid testing. For running agents, it adds tool approvals (user-in-the-loop and automated), durability with WorkflowAgent, timeouts, and sandboxing. Integration with various agent providers and the introduction of Jev, a universal classifier model, are key advancements. The Python AI SDK now supports Jev via an experimental `evaluate()` API for narrow decision-making tasks.

All Vercel trails
  1. Jev for Python engineersThis post introduces the integration of Jev, a new type of AI model that functions as a universal classifier, into the Python AI SDK. It details the `evaluate()` API for interacting with Jev, providing examples of its use for tasks like classifying text as Python or English, and exploring its potential for code generation by building Abstract Syntax Trees (ASTs). The post highlights Jev's speed and structured JSON output as key differentiators from traditional LLMs, while also acknowledging its limitations in complex tasks.
  2. Jev is the fastest-adopted model in AI Gateway historyThis post details the rapid adoption of the Jev model on the AI Gateway, highlighting its performance metrics (speed and cost) compared to general-purpose language models for structured decision-making tasks. It introduces Jev as a probabilistic decision model that returns typed choices, scores, or true-or-false answers with probabilities, enabling direct use in code for tasks like agent tool selection, workflow control, and guardrail enforcement. The post emphasizes Jev's potential to replace slower and more expensive LLM calls for specific decision-making use cases.
  3. Open-weight models take 56% of token volume, Astra doubles Fable 5.1 spendThis post provides detailed monthly metrics on AI Gateway token volume and spend, specifically highlighting the shift towards open-weight models (now 56% of token volume) and the cost-effectiveness trend (23.2% price drop in August). It analyzes customer migration patterns within Anthropic's model offerings, showing Opus 5 replacing Fable 5 due to a better price-performance ratio. The post also tracks the rapid adoption of new model launches like OpenAI's Astra and Z.ai's GLM-5.3-Flash, demonstrating how model profile and consistency drive customer loyalty across providers.
  4. How our agents build on-brand pages with design.mdIntroduced `design.md`, a public file providing agents with brand and design guidance (typography, color, composition, responsiveness, information architecture) to ensure on-brand page generation. Developed a public stylesheet (`vercel-brand.css`) to standardize CSS classes and tokens used by agents. Established an evaluation loop with fixed scenarios and mock inputs, using human feedback to refine `design.md` and create deterministic checks for mechanical failures. This system aims to improve agent-generated page consistency and adherence to Vercel's design system.
  5. Introducing Run SDK: secure eval for your agentsIntroduces the Run SDK, a package for executing untrusted JavaScript and TypeScript in a sandboxed QuickJS context. It enables agents to interact with host functions, handle human-in-the-loop approvals, and enforce execution limits, enhancing the security and control of agent-driven code execution within applications. This builds upon existing AI SDK capabilities by providing a robust execution layer for agent-generated code.
  7. How v0 authenticates to Snowflake without exposing the user's OAuth tokenIntroduced a Snowflake request proxy for v0 sandboxes, built on the Vercel Sandbox firewall, to authenticate AI-generated code to Snowflake without exposing user OAuth tokens. This proxy resolves credentials server-side at request time, outside the sandbox runtime, by verifying the sandbox's OIDC token, resolving the user session, and minting a user-scoped token. It injects credentials only into protocol-defined authentication fields (Authorization header for SQL API, login token field for login requests) and rejects requests where the placeholder token appears outside these fields or where the Snowflake account host cannot be derived. This ensures generated code uses Snowflake without ever reading the user's OAuth token.
  8. How Searchable ships customer-requested features in 30 minutes on VercelThis talk highlights how Searchable leverages Vercel's AI SDK and AI Gateway to achieve 2-5x faster feedback loops when evaluating and integrating new AI models. By using these Vercel primitives, Searchable can test new models without rotating API keys or SDKs, enabling rapid iteration on their AI search tracking and guidance features. The core technical contribution is the demonstration of how these Vercel services accelerate the development lifecycle for AI-driven products.
  9. Building a software factory for AI SDKThis post details the creation and implementation of `ai-sdk-factory`, a software factory designed to automate the processing of issues and pull requests for the AI SDK. It introduces the concept of dedicated agents for specific tasks (bug reproduction, fixes, reviews, backports, documentation, feature analysis/implementation), emphasizes security through Vercel Sandbox and network shielding, and outlines the cloud infrastructure used (Vercel Functions, Queues, Blob, Sandbox, Neon Postgres). The post also provides a case study of how the factory processed a community-requested feature for blocked-domain support in OpenAI web search.
  10. DeepSeek overtakes Google on volume, cost per token falls 13.6%This post details Vercel's AI Gateway's August 2026 production index, analyzing AI usage trends through July 2026. Key technical contributions include: 1. Tracking a 13.6% average price per token decrease in July, driven by increased volume and a shift to cheaper models. 2. Highlighting DeepSeek's rise to become the second-largest lab by token volume, surpassing Google. 3. Analyzing Anthropic's premium pricing strategy and its impact on gateway spending. 4. Observing the significant adoption of new models like Kimi K3 and GLM 5.2 for long-horizon agent work, and their impact on open-weight model market share. 5. Quantifying the shift in model mix by companies, with a majority changing at least a tenth of their model usage. 6. Noting the increasing volume and spend on inference, even as cost per token decreases.
  11. Introducing Agent PluginsIntroduces Agent Plugins 1.0.0, an open, vendor-neutral standard for packaging AI agent skills and MCP servers into distributable plugins. The format defines a directory structure with a `plugin.json` manifest and fixed locations for components, allowing clients to discover and load them. This standardizes the packaging of reusable agent components, reducing the need for client-specific adaptations and promoting interoperability across different AI agent platforms like ChatGPT, Cursor, GitHub Copilot, and VS Code.
  12. Introducing the new v0 APIIntroduces the new v0 API, providing programmatic, headless access to v0's app-building agent. This API allows users to create chats from prompts or existing code (repos, ZIP archives), stream the agent's work (file edits, searches, tool calls), and render live previews. It supports synchronous, asynchronous, and streaming responses, and integrates with Vercel Sandbox for isolated execution. The API can be used to build white-labeled app builders, automate app changes via scripts or webhooks, and serve as a build tool for other agents. It offers multiple connection methods for agents (MCP, AI SDK, eve) and allows for connecting chats to Vercel projects for deployment and observability. Includes a migration guide for older API versions.
  13. Introducing the new Vercel AgentIntroduces the Vercel Agent, a new capability integrated into the Vercel dashboard that acts as an autonomous first responder for production issues. It investigates logs, metrics, and deployments to identify root causes and propose fixes, requiring user approval before taking action. The agent operates under its own identity (`vercel-agent`), is read-only by default, and uses a plan-to-permission model for scoped, least-privilege access. Generated code runs in Vercel Sandbox (Firecracker microVMs) for isolation. This enhances the AI Gateway and AI SDK's production capabilities by providing automated incident investigation and remediation.
  14. Open-weight models surge to 29% of volume, price per token flattensThis post provides detailed production data on AI model usage through Vercel's AI Gateway for June 2026. It quantifies the growth of open-weight models (29% of tokens, 4% of spend), highlighting DeepSeek and GLM 5.2's rapid adoption. It contrasts this with frontier model spend, noting Anthropic's dominance (61% of spend) in high-stakes use cases and OpenAI's increasing cost-per-token. The report also breaks down modality leaders for image and video generation. The core contribution is the empirical data on model routing strategies, cost-efficiency trade-offs between open-weight and frontier models, and the speed of adoption for new AI models in production environments.
  15. Build realtime voice agents on AI GatewayThis post introduces real-time voice, text-to-speech, and speech-to-text capabilities to Vercel's AI Gateway. It details how these audio modalities can be integrated using the AI SDK 7, including a `useRealtime` hook for browser-based conversational agents with features like barge-in and tool integration mid-conversation. It also covers `generateSpeech` for text-to-speech and `transcribe` for speech-to-text, demonstrating their usage with specific models from OpenAI and xAI. The post emphasizes that these audio capabilities are routed through AI Gateway with the same provider routing, observability, and spend controls as other modalities.
  16. AI SDK 7 is now availableAI SDK 7 introduces significant production depth for agent development and execution. Key contributions include: standardized reasoning control across providers, typed tool context for scoped API keys, typed runtime context for shared agent state, `uploadFile` and `uploadSkill` APIs for efficient handling of large inputs and reusable skills, MCP Apps for richer UIs alongside agent tools, and a Terminal UI (TUI) for interactive agent testing. For agent execution, it adds agent-level tool approvals (user-approval, auto-approve/deny, catch-all functions) with HMAC-signed options for security, `WorkflowAgent` for durable and resumable agent execution across restarts and approvals, and robust timeout management. It also enhances integration with agent harnesses and expands observability with telemetry and Node.js tracing.
  17. The Agent StackThis post introduces 'The Agent Stack,' a collection of building blocks for creating production-grade AI agents. It details three core capabilities: connecting to models (AI SDK, AI Gateway), executing complex workflows (Workflow SDK, Vercel Sandbox), and connecting to data and tools (Vercel Connect, Chat SDK). It highlights the benefits of each component, such as model-agnosticism with AI SDK, cost and latency management with AI Gateway, durability with Workflow SDK, secure execution with Vercel Sandbox, scoped access with Vercel Connect, and cross-platform deployment with Chat SDK. It also introduces 'eve,' an opinionated agent framework based on these building blocks.
  18. Introducing eveIntroduced 'eve', an open-source agent framework that provides a structured, directory-based approach to building, running, and scaling agents. eve includes built-in production capabilities such as durable execution (leveraging Workflow SDK), sandboxed compute (integrating with Vercel Sandbox, Docker, etc.), human-in-the-loop approvals, subagents, and evals. It simplifies agent development by defining components like models, instructions, tools, skills, subagents, channels, and schedules as files within a directory structure. eve also integrates with Vercel Connect for secure tool and service connections and supports multiple communication channels via adapter files.
  19. DeepSeek enters the fight for token volume, Anthropic continues to dominate spendThis post introduces data from May 2026 showing a significant shift in AI model usage patterns on Vercel's AI Gateway. Key contributions include: 1. The emergence of DeepSeek V4 as a major player in token volume (17% share) due to its low cost and sufficient quality for production, particularly in coding agent use cases. 2. The continued dominance of Anthropic in spend share (65%), especially for high-stakes applications like AI app generation and coding agents, indicating a trend of cost-conscious routing where lower-cost models handle high-volume tasks and frontier models are reserved for critical workloads. 3. An overall increase in AI Gateway tokens (+20% MoM) and spend (+43% MoM), with customers paying more per token on average, driven by the growth of frontier model usage in demanding applications.
  20. Protecting against token theftThis post introduces a defense mechanism against inference theft for AI endpoints. It details the problem of inference theft, why traditional web defenses are insufficient, and presents Vercel BotID with deep analysis as a solution. The implementation involves server-side `checkBotId()` within route handlers and client-side initialization of BotID to protect specific API paths. The core technical contribution is the per-request verification strategy to mitigate high-cost AI abuse.
  21. AI Gateway production indexThis post provides a detailed analysis of Vercel's AI Gateway production workload data from seven months, covering token volume and spend across various AI labs (Anthropic, Google, OpenAI, xAI, etc.). It highlights key trends such as the rise of open-weight models, the strategic routing of high-volume tasks to cheaper models, and the differing economics of B2C vs. B2B AI applications. The analysis breaks down cost and volume by use case (personal assistants, coding agents, back office, etc.) and by provider within those use cases, demonstrating that model selection is driven by the cost of incorrect outputs. The post also notes the rapid growth of OpenAI's spend share after recent model releases and the increasing dominance of agentic workloads.
  22. Agentic InfrastructureThis post introduces the concept of 'Agentic Infrastructure' as the next evolution of software infrastructure, driven by LLMs and coding agents. It outlines three key areas: 1. Infrastructure for coding agents to deploy to (immutable deployments, preview URLs, CLI, API, MCP servers, git integration). 2. Infrastructure for building and running agents, unifying AI primitives like AI SDK, Chat SDK, AI Gateway, Fluid compute, Workflows, Queues, and Sandbox. 3. Infrastructure that is itself agentic, enabling autonomous response to production anomalies by leveraging observability data, logs, and source code inspection. The post highlights the rapid growth of agent-driven deployments on Vercel and the shift towards software that writes, ships, and heals itself.
  23. Zero Data Retention on AI GatewayIntroduced team-wide Zero Data Retention (ZDR) and request-level ZDR controls for AI Gateway, enabling enforcement of data policies without code changes. Added a 'Disallow Prompt Training' option for specific sensitive workflows. Enhanced audit trails with metadata in responses indicating provider filtering. These features are integrated with existing AI SDKs and APIs.
  24. Agent responsiblyThis post introduces a framework for responsible AI agent usage in production. It contrasts 'relying' on AI with 'leveraging' it, emphasizing that engineers must maintain ownership and judgment over AI-generated code. Key recommendations include implementing self-driving deployments with incremental rollouts and automatic rollbacks, continuous validation through load tests and chaos experiments, and encoding operational knowledge as executable guardrails (e.g., 'safe-rollout' skills). The post outlines Vercel's investments in stronger guardrails, stricter static checks, production-mirroring E2E testing, read-only agents for invariant verification, and metrics like defect-commit vs. defect-escape ratios.
  25. Unified reporting for all AI Gateway usageIntroduced the Custom Reporting API for AI Gateway in beta, enabling programmatic access to cost, token usage, and request volume across AI Gateway traffic, including BYOK requests. This allows for detailed breakdown of spend by model, provider, user ID, custom tag, or credential type, facilitating per-feature, per-customer, and per-pricing tier cost tracking from a single endpoint. The API supports tagging requests with 'user' and 'tags' for attribution, and can be queried via a GET request to `/v1/report`. The API captures data for both BYOK and system credentials, enabling operational metrics for AI spend.
  26. Build knowledge agents without embeddingsIntroduces a file-system-based approach for knowledge agents, replacing vector databases and embedding models with `grep`, `find`, and `cat` executed within Vercel Sandboxes. This method aims for improved determinism, debuggability, and cost efficiency. It also details the integration of Chat SDK for multi-platform agent deployment (Slack, Discord, GitHub) and AI SDK with a complexity router for intelligent model selection and cost optimization. Built-in admin tools and an AI-powered admin agent are provided as part of the Knowledge Agent Template.
  27. Chat SDK brings agents to your usersIntroduces Chat SDK, a TypeScript library that enables developers to build bots that work across multiple chat platforms (Slack, Microsoft Teams, Google Chat, Discord, Telegram, GitHub, Linear, WhatsApp) from a single codebase. It abstracts platform-specific behaviors through adapters, handles message formatting and streaming inconsistencies, and supports pluggable state adapters (Redis, PostgreSQL). The SDK integrates directly with AI SDK text streams for AI-powered chat responses and supports rendering UI elements like tables, cards, modals, and buttons across different platforms.
  28. Building Slack agents can be easyIntroduces the `slack-agent-skill` and `slack-agent-template` for building and deploying Slack agents. Details a wizard-driven process for project setup, Slack app creation, environment configuration, local testing, and production deployment. Highlights agent capabilities like multi-turn conversations, human approval workflows, response streaming, and tool integration. Mentions the use of Workflow SDK for durability and AI Gateway for model flexibility.
  29. Keeping community human while scaling with agentsThis post details the implementation of the Community Guardian and c0 agents for automating community operations and providing research assistance. The Community Guardian uses Claude via AI Gateway and runs on Vercel Workflows for operational tasks like post analysis, routing, duplicate detection, and follow-ups. Agent c0 provides research context by searching knowledge bases, documentation, and GitHub issues. The post emphasizes the use of AI Gateway, AI SDK, and Vercel Workflows for building these agents, highlighting the conversational prompting approach for development, even by non-engineers. It also mentions the use of Chat SDK for building agents across platforms and Vercel Workflows for durable execution.
  30. Skills Night: 69,000+ ways agents are getting smarterThis post details the growth and impact of the "skills.sh" open skills ecosystem, highlighting its evolution from a weekend project to over 69,000 skills and 2 million CLI installs. It introduces security partnerships with Gen, Socket, and Snyk to audit skills and prevent vulnerabilities, with plans for an Audits leaderboard. Demos from partners illustrate how skills bridge training cutoff gaps, enable agents to drive full application stacks (like native iOS development), and are becoming infrastructure for documentation sites and static analysis. The post emphasizes the role of skills in improving agent quality, token efficiency, and providing a scalable method for distributing knowledge.
  31. Video Generation with AI GatewayThis post introduces video generation capabilities to Vercel's AI Gateway and AI SDK. It details how users can programmatically generate videos using AI SDK 6 with models like 'xai/grok-imagine-video' or experiment via the AI Gateway Playground. Four initial video models are highlighted: Grok Imagine (xAI) for speed and instruction following, Wan (Alibaba) for reference-based generation and identity preservation, Kling for image-to-video and audio, and Veo (Google) for visual fidelity and physics realism. The post explains video request nuances, including motion cues and provider-specific options, and outlines four generation types: Text-to-video, Image-to-video, First and last frame, and Reference-to-video. It provides code examples for programmatic video generation using different models and capabilities, including video editing with style transfer.
  32. Anyone can build agents, but it takes a platform to run themThis post details Vercel's internal data agent, d0, and how it runs on Vercel's agent orchestration platform. It highlights the use of Sandboxes for secure execution of arbitrary Python code and SQL generation, Fluid Compute for automatically scaling agent workloads and managing costs, and AI Gateway for routing model calls across providers to balance cost and accuracy. It also mentions the AI SDK for handling model calls and the Vercel Workflows for durable orchestration with retries and state recovery. The post emphasizes that the platform primitives enable rapid development and reliable operation of AI agents.
  33. How we built AEO tracking for coding agentsThis post details the implementation of an AI Engine Optimization (AEO) system to track how coding agents discover, interpret, and reference Vercel's web content. It introduces the Vercel Sandbox for safe execution of autonomous agents and outlines a six-step lifecycle for agent runs: sandbox creation, CLI installation, credential injection (routing through AI Gateway), agent execution, transcript capture, and teardown. The post also addresses the challenge of transcript format normalization across different agents (Claude Code, Codex, OpenCode) by introducing a four-stage process: transcript capture, parsing (tool name and message shape normalization), enrichment, and summary/brand extraction. It highlights how AI Gateway is used for routing and cost/log centralization by overriding base URLs via environment variables.
  34. AGENTS.md outperforms skills in our agent evalsThis post introduces AGENTS.md as a superior method for providing framework-specific knowledge to AI coding agents compared to the 'skills' abstraction. It details an evaluation comparing a 'skills' approach with an AGENTS.md index for Next.js documentation, demonstrating that AGENTS.md achieved a 100% pass rate in build, lint, and test evaluations, while skills maxed out at 79% even with explicit instructions. The post explains the advantages of passive context (no decision point, consistent availability, no ordering issues) and addresses context bloat concerns through aggressive compression of the documentation index. It also provides a codemod to set up AGENTS.md for Next.js projects.
  35. Agent skills explained: An FAQThis post introduces and explains the concept of 'agent skills' as a standardized, open format for packaging instructions, scripts, and resources for AI agents. It details how skills improve agent accuracy and consistency by providing centralized, on-demand expertise. The post compares skills to other configuration methods like MCP servers, tools, rules, and system prompts, highlighting their distinct use cases. It outlines the problems skills solve, such as prompt drift and instruction sprawl, and provides examples of skills in various domains. The structure of a skill package and how to install skill packages using the `skills` CLI are explained. The post also describes how agents utilize skills and the content of a `SKILL.md` file.
  36. Testing if "bash is all you need"This post introduces an evaluation harness to compare the effectiveness of SQL, Bash, and Filesystem abstractions for AI agent data querying. It details initial results showing SQL's superiority in accuracy and efficiency for structured data, while highlighting Bash's potential for exploration and verification. The post also discusses performance bottlenecks in `just-bash`, improvements made to the eval harness, and the benefits of a hybrid approach that combines SQL and Bash for robust agent design.
  37. Use Perplexity Web Search with Vercel AI GatewayIntroduces provider-agnostic web search functionality to Vercel AI Gateway using Perplexity. This is achieved by integrating `gateway.tools.perplexitySearch()` from `@ai-sdk/gateway` into the `tools` parameter of model calls. The post demonstrates use cases for models without native search, developer tooling, provider-agnostic chatbots, and operational agents. It also mentions provider-specific tools and pricing for the Perplexity search feature.
  38. How to build agents with filesystems and bashThis post introduces a new pattern for agent context management by leveraging filesystems and bash commands. Instead of custom retrieval tools or vector search, agents are given access to data structured as files and the ability to use Unix commands (ls, find, grep, cat) to explore and retrieve relevant information. This approach is demonstrated to reduce costs and improve output quality for agents, as LLMs are already trained on vast amounts of code and understand filesystem operations. A case study of a sales call summarization agent shows significant cost reduction and quality improvement. The open-source `bash-tool` is released to facilitate this pattern.
  39. How we made v0 an effective coding agentThis post details the technical enhancements made to the v0 agent's pipeline to improve generation reliability. Key contributions include: 1. Dynamic System Prompt: Implementing a system that injects specific knowledge (e.g., AI SDK version details) into the prompt based on intent detection (embeddings, keyword matching) and provides curated code samples in a read-only filesystem. 2. LLM Suspense: A streaming manipulation layer that performs real-time find-and-replace operations on LLM output, such as shortening long URLs and resolving incorrect icon imports by embedding icon names and searching for closest matches. 3. Autofixers: A post-streaming layer that uses deterministic fixes and a fine-tuned model to address complex errors like missing `QueryClientProvider` wrappers and incomplete `package.json` dependencies by analyzing ASTs.
  40. Building AI-Generated Pixel Trading Cards with Vercel AI GatewayThis post details the technical implementation of an AI-generated pixel trading card system, showcasing the integration of Vercel AI Gateway, Fal.ai's GPT Image 1.5 Edit model, and BRIA's RMBG 2.0 model. It describes the pipeline from image capture to pixel art generation, background removal, compositing with Canvas API and sharp image library, and on-site printing. It also presents a v0 template that replicates this functionality in the browser, highlighting the use of user image input, style reference, prompt engineering for pixel art constraints, and client-side compositing.
  41. AI SDK 6AI SDK 6 introduces the `Agent` abstraction for building reusable agents, with `ToolLoopAgent` providing a production-ready implementation for the complete tool execution loop. It enhances tool capabilities with `needsApproval` for human-in-the-loop control, strict mode for reliable input generation, input examples for better alignment, and `toModelOutput` for flexible tool outputs. New features include DevTools for debugging, support for standard JSON schema, image editing capabilities, and raw finish reason & extended usage reporting. The LangChain adapter has been rewritten, and new provider tools have been added.
  42. We removed 80% of our agent’s toolsThis post details a significant architectural shift in building AI agents, moving from a complex multi-tool approach to a simplified file system agent. The core contribution is the demonstration that by providing direct access to well-structured data (Cube DSL files) via Vercel Sandbox and leveraging powerful LLMs like Claude Opus 4.5, agents can achieve higher success rates (100% vs 80%), faster execution (3.5x), and reduced token usage (37% fewer) by using standard Unix tools (`grep`, `cat`, `ls`) instead of specialized agent tools. This approach emphasizes 'addition by subtraction' and trusting the model's reasoning over extensive prompt engineering and tool wrapping.
  43. Cline now runs on Vercel AI GatewayThis post details Cline's migration to Vercel AI Gateway, highlighting the performance improvements achieved. Specifically, it quantises P99 streaming latency improvements (10-14%) and API error rate reductions (43.8%) for Cline's operations. It also mentions model-specific improvements for Grok Code Fast 1 and Minimax M2. The post emphasizes Vercel's global network infrastructure, private backbone, and congestion-free routing as key enablers for these gains, and discusses transparent pricing and observability benefits.
  44. Vercel collaborates with Google for Gemini 3 Pro Preview launchThis post announces the integration and preview availability of Google's Gemini 3 Pro model through Vercel's AI Gateway and v0.app. It presents internal evaluation metrics from Vercel's Next.js evals, showing Gemini 3 Pro Preview achieving a 42% success rate, tied with `openai/gpt-5-codex`. The post highlights Gemini 3 Pro Preview's strengths in frontend generation and multi-turn agent flows, attributing its performance to a 1M context window and improved instruction following. It provides code snippets for integrating the model via the AI SDK and directs users to playgrounds for immediate testing.
  45. How AI Gateway runs on Fluid computeThis post details how Vercel's AI Gateway leverages Fluid compute and Active CPU Pricing for scalable and cost-efficient operation. It explains the architecture, including the use of Vercel's global delivery network for low-latency routing and in-region Redis for state management and caching. The post highlights Fluid's in-function concurrency model, which allows for server-like efficiency by reusing instances and persisting state across invocations, reducing network overhead and costs. It also describes the monitoring system that combines health checks with in-memory statistics from Fluid instances for self-correction and automatic adjustments.
  46. What we learned building agents at VercelThis post introduces a methodology for identifying and building high-ROI AI agent projects, focusing on tasks with low cognitive load and high repetition. It provides two detailed examples: a lead processing agent that automates initial qualification and email composition, and an anti-abuse agent that analyzes URLs for phishing or copyright violations. The post also highlights open-source agent templates for lead processing, data analysis, flight booking, and a Slack storytime bot, and mentions a hands-on program for direct support in agent implementation.
  47. Vercel Ship AI 2025 recapThis post announces AI SDK 6, introducing an agent abstraction for defining agents once and reusing them across applications and workflows. It includes a tool execution approval system (`needsApproval: true`) for human-in-the-loop review of agent actions. The Vercel Marketplace has expanded to include agents and AI services. The Workflow Development Kit (`use workflow`) is introduced as a way to add durability, retries, and state persistence to TypeScript functions. Vercel Agent beta is launched with AI code reviews and automated investigations. Zero-configuration Python support for frameworks like FastAPI and Flask is also announced. Open-source lead and data analyst agents are presented as examples of combining these tools.
  48. AI agents and services on the Vercel MarketplaceIntroduced a new AI agents and services category to the Vercel Marketplace. This category provides unified billing, observability, and installation flows for third-party AI tools. The marketplace features pre-built agents (CodeRabbit, Corridor, Sourcery) for specialized workflows and services (Autonoma, Braintrust, BrowserUse, Chatbase, Descope, Kernel, Kubiks, Mixedbread) for building custom agents. Integrations are designed to plug into Vercel workflows, CI/CD, observability, and automation.
  49. You can just ship agentsThis post introduces the Vercel AI Cloud as a unified platform for building and deploying AI agents, emphasizing the simplification of agent development. It highlights the AI SDK for defining agent logic and connecting tools, AI Gateway for model routing and cost management, Fluid compute for elastic scaling, Sandbox for secure execution of untrusted code, and Workflow tooling for durable agent execution. The post provides examples of AI agents built internally for customer support, security abuse detection, and content generation, showcasing how these agents improve productivity and quality. It also introduces the Workflow Development Kit for expressing durability directly in code for long-running agent tasks.
  50. Agents at work, a partnership with Salesforce and SlackThis post announces a partnership between Vercel and Salesforce to integrate Vercel's AI Cloud capabilities into the Slack ecosystem. It introduces the concept of AI agents living directly in Slack threads, interpreting user intent, and taking action. The post highlights the v0 Slack Agent as a demonstration of this capability, enabling collaborative agent development and deployment within Slack. It also mentions the use of Vercel's AI SDK, frameworks like Next.js, Hono, Nitro, and Express for agent development, and the deployment of these agents with automatic handling of message routing, context persistence, and security. The partnership aims to bring conversational interfaces to enterprise software and enable developers to build and ship agents more rapidly.
  51. Running Next.js in ChatGPT: How to Build ChatGPT AppsThis post details how to embed Next.js applications within ChatGPT using the Model Context Protocol (MCP). It addresses specific technical challenges arising from ChatGPT's nested iframe architecture, including: 1. Asset loading by configuring `assetPrefix` in `next.config.ts`. 2. Relative URL resolution by using the HTML `<base>` element. 3. Browser history manipulation by patching `history.pushState` and `history.replaceState` to store only relative paths. 4. Fetch request rewriting for client-side navigation by patching `window.fetch` to target the correct origin. 5. CORS handling for cross-origin requests by implementing middleware to manage `OPTIONS` preflight requests and add `Access-Control-Allow-Origin` headers. 6. Parent frame modifications by ensuring React hydration mismatches are avoided. The post provides code examples for each solution and offers a starter template for building ChatGPT apps with Next.js.
  52. Collaborating with Anthropic on Claude Sonnet 4.5 to power intelligent coding agentsThis post announces the integration of Claude Sonnet 4.5 into Vercel AI Gateway and AI SDK, highlighting its improvements for agentic coding workflows, specifically in Next.js builds, linting, and feature implementation. It also introduces the open-sourced Coding Agent Platform template, which leverages Vercel Sandbox, Fluid Compute, and AI Gateway for running multi-agent systems that can plan, execute, and commit code changes within isolated environments.
  53. Addressing security & quality issues with MCP tools - VercelIntroduces `mcp-to-ai-sdk`, a CLI tool that generates static AI SDK tool definitions from Model Context Protocol (MCP) servers. This addresses security risks (prompt injection, unexpected capability introduction), cost issues (unneeded context usage), and latency problems (low tool-call accuracy) associated with dynamic MCP tool definitions in production AI agents. The tool allows for versioned, customizable, and selectively loaded tools that are checked into source control, improving security, performance, and reliability.
  54. Introducing x402-mcp: Open protocol payments for MCP toolsIntroduced the x402 protocol and `x402-mcp` package for integrating open protocol payments into AI agents and MCP tools. Implemented `paymentMiddleware` for Next.js API routes to protect endpoints with pricing and `createPaidMcpHandler` for MCP servers to define `paidTool`s with prices. Provided client-side wrappers (`wrapFetchWithPayment` and `withPayment`) to facilitate payment authorization for API calls and MCP tool usage. The protocol leverages the 402 Payment Required HTTP status code and can settle payments in USDC on the Base blockchain, with future support for other payment networks.
  55. The second wave of MCP: Building for LLMs, not developersThis post introduces the concept of building 'intention-based' tools for LLMs, contrasting them with 'API-shaped' tools. It argues that LLMs, unlike developers, do not manage state or reuse code across conversations, necessitating tools that encapsulate complete user intentions (workflows) rather than exposing individual API operations. The post provides examples of how this shift improves reliability and efficiency, and suggests designing tools around complete user goals, using regular programming for deterministic parts and involving LLMs only for reasoning or NLP tasks. It also highlights the MCP handler and Next.js MCP template for implementation.
  56. AI Gateway: Production-ready reliability for your AI appsThis post announces the general availability of Vercel AI Gateway, a system designed to provide production-ready reliability for AI applications. It addresses the fragility of direct LLM provider integrations by offering a unified API that handles model switching, rate limits, API keys, and billing. The gateway supports hundreds of models and leverages Vercel's CDN for low latency. It aims to provide flexibility, speed, and reliability for AI apps, agents, RAG systems, and search/chat experiences without added markup on model prices.
  57. Proposal for inline LLM instructions in HTML based on llms.txtIntroduces a convention for embedding LLM instructions directly within HTML responses using `<script type="text/llms.txt">`. This convention is proposed as a way to guide AI agents on how to access protected Vercel deployments by providing instructions directly in the HTTP 401 response. The proposal leverages the fact that browsers ignore unknown script types, while LLMs can parse them. It aligns with the `llms.txt` standard for discoverable LLM-targeted content and is demonstrated with a production use case on Vercel's 401 pages.
  58. Vercel collaborates with OpenAI for GPT-5 launchIntroduces GPT-5 models (main, mini, nano) via AI Gateway and v0.dev, emphasizing improved frontend design generation and agentic workflow performance. Details internal adoption for Vercel Agent and v0.dev. Presents an open-source "vibe coding platform" demonstrating end-to-end AI infrastructure (Fluid compute, Vercel Functions, Sandbox) for prompt-to-live-preview application generation. Highlights the use of AI SDK for model interaction, BotID for user verification, and Vercel Firewall for abuse mitigation. Provides code examples for integrating GPT-5 with AI SDK and discusses the benefits of Fluid compute for prompt-based workloads.
  59. Introducing Vercel MCP: Connect Vercel to your AI toolsIntroduces Vercel MCP (Model Context Provider) server, a secure, OAuth-compliant interface allowing AI clients (like Cursor, Claude, VS Code Copilot) to interact with Vercel projects. MCP servers expose tools for AI models to call external systems. The Vercel MCP server enables read-only access to Vercel documentation, deployment logs, teams, and projects. It supports MCP's prompt templates and adheres to Authorization and Streamable HTTP specifications. Security best practices include a read-only mode, an allowlist of approved clients, and OAuth consent screens to prevent the Confused Deputy problem. Future plans include expanding client support and read-write capabilities.
  60. AI SDK 5AI SDK 5 introduces a redesigned chat with explicit UIMessage and ModelMessage types for improved persistence and type safety. It adds 'data parts' for streaming arbitrary, type-safe data between server and client, and enhances tool invocations with type-specific identifiers, automatic input streaming, and explicit error states. Experimental speech generation/transcription, tool improvements, V2 specifications, a global provider, access to raw responses, and Zod 4 support are also included.
  61. Model Context Protocol (MCP) explained: An FAQThis post introduces and explains the Model Context Protocol (MCP), a new specification for standardizing how LLMs access data and systems. It details MCP's purpose in enabling safe, predictable interactions between AI and applications by exposing data sources, tools, and context. The post clarifies the difference between MCP servers and APIs, highlighting that MCP is designed for models. It explains the easiest ways to create an MCP server using the AI SDK and the open-source mcp-handler, and describes how MCP works for tools via a tool manifest and HTTP requests. It also differentiates between local and remote MCP servers and outlines use cases such as e-commerce, finance, and marketing, as well as how MCP will benefit everyday internet users by enabling smarter, more helpful AI features.
  62. Grep a million GitHub repositories via MCPThis post details the integration of Grep's existing API with the Model Context Protocol (MCP), enabling AI applications to query a million public GitHub repositories via a standard HTTP interface. It provides configuration examples for AI clients like Cursor and Claude Code, and demonstrates how an AI agent can use the Grep MCP server to find code snippets related to error handling in MCP tool implementations. The integration was achieved using the `mcp-handler` package, abstracting boilerplate for schema, request routing, and response formatting.
  63. The AI Cloud: A unified platform for AI workloadsThis post introduces Vercel's AI Cloud, a unified platform for AI workloads that builds upon the Frontend Cloud. It highlights new AI-first tools and primitives: AI SDK for integrating with models and tools, AI Gateway for model routing and cost management, Fluid compute with Active CPU pricing for efficient AI execution, tool support, MCP servers, queues for autonomous actions and background tasks, and secure sandboxes for running untrusted code. The post emphasizes framework-defined infrastructure for AI, enabling agents to build AI apps without manual configuration. It details how AI SDK and AI Gateway simplify LLM interactions and model execution, and how Fluid compute optimizes for AI workloads with cost efficiencies. It also introduces simplified MCP server support via `@vercel/mcp-adapter` and the use of Vercel Queues for offloading background tasks.
  64. Building efficient MCP serversThis post introduces an update to the MCP adapter to support Streamable HTTP as the recommended transport for MCP servers, replacing the less efficient Server-Sent Events (SSE). It also details how to use the `mcp-remote` package to proxy Streamable HTTP over stdio for compatibility with clients that do not yet support the new transport. The post highlights a real-world example where migrating to Streamable HTTP reduced CPU consumption by over 50%.
  65. Building secure AI agentsThis post introduces security best practices for building AI agents, focusing on prompt injection prevention. It advises assuming total compromise, scoping tools tightly to the caller's authority (e.g., binding `tenantId`), treating all model input as untrusted, and sanitizing model output to prevent data exfiltration via markdown rendering (e.g., malicious image URLs). It recommends `harden-react-markdown` and `markdown-to-markdown-sanitizer` for output sanitization and emphasizes designing for failure by limiting the consequences of model misbehavior.
  66. The no-nonsense approach to AI agent developmentThis post outlines a three-step process for building AI agents: manual prototyping to understand the task and identify automation candidates, automating the execution loop by writing code to collect inputs and structure the agent's process (using plain code for deterministic tasks and LLMs for judgment), and optimizing for reliability through prompt refinement, precise tool calls, and structured evaluations. It provides an example of a stock analysis agent using the AI SDK and emphasizes that reliable agents are built on clear logic, good structure, and tight feedback loops.
  67. Introducing the AI GatewayThis post announces the alpha release of the Vercel AI Gateway, a product built on top of the AI SDK. The Gateway allows developers to switch between approximately 100 AI models without managing API keys, rate limits, or provider accounts. It handles authentication and usage tracking, with future plans for billing. The primary technical benefit highlighted is the ability to load balance across providers and fail over in case of downtime or performance degradation, leveraging Vercel's experience scaling v0. The post also details the tight integration with the AI SDK's features like tool calling and streaming.
  68. AI SDK 4.2AI SDK 4.2 introduces support for reasoning models (e.g., Anthropic Sonnet 3.7, DeepSeek R1) with dedicated `reasoning` property or `extractReasoningMiddleware`. It adds Model Context Protocol (MCP) client support for integrating external tools via stdio or SSE. The `useChat` hook now handles message parts (text, source, reasoning, tool-invocation, file) to preserve output sequence. Image generation is supported via models like Gemini 2.0 Flash, accessible as `file` message parts. URL sources are standardized across providers (OpenAI, Google, Vertex, Perplexity) for attribution. OpenAI's new Responses API is supported with a simple model instantiation change. Updates include Svelte 5 support and middleware enhancements.
  69. xAI and Vercel partner to bring zero-friction AI to developersThis post announces the integration of xAI's Grok models into the Vercel Marketplace, AI SDK, and v0. It highlights the availability of a free tier for prototyping, simplified authentication via environment variables, and integrated billing. The Next.js AI Chatbot template is now powered by xAI, and the AI SDK demonstrates a code example for using xAI models. Future integration with v0 is also mentioned.
  70. AI SDK 4.1AI SDK 4.1 introduces experimental image generation via the `generateImage` function, supporting multiple providers (Replicate, OpenAI, Google Vertex AI, Fireworks) and parameters like size, aspectRatio, n, seed, and provider-specific options. It also adds stream transformation and smoothing capabilities with `smoothStream` for better text streaming, filtering, and custom transformations. Persistence for `useChat` is simplified with improvements to chat ID forwarding, response message IDs, and the `appendResponseMessages` utility. Non-blocking data streaming is enabled with `createDataStreamResponse`, allowing for streaming retrieval-augmented generation (RAG) context and search results before LLM responses. Tool calling is enhanced with improved context in the `execute` function, including `toolCallId`, `messages` array, and `abortSignal`. Structured output improvements include a new `zod` schema for defining tool parameters and a `JSONSchema` type for generating JSON schemas. New and updated providers are also included.
  71. AI SDK 4.0AI SDK 4.0 introduces PDF support for Anthropic, Google Generative AI, and Google Vertex AI providers, allowing for text extraction, analysis, summarization, and question answering from PDFs. It also adds computer use support for Anthropic's Claude 3.5 Sonnet model, enabling mouse/keyboard control, screenshot capture, terminal commands, and text file manipulation through predefined tools. Continuation support is added for generating text beyond standard output limits by detecting and continuing incomplete generations across multiple steps. A new official provider for xAI Grok is introduced. Additional provider updates include v2 support and tool calling for Cohere, predicted output and prompt caching for OpenAI, file inputs, fine-tuned models, schema, tool choice, frequency penalty, and text embedding support for Google Generative AI and Vertex AI, Amazon Titan embedding models for Amazon Bedrock, and Groq support.
  72. Eval-driven development: Build better AI fasterThis post introduces and advocates for 'eval-driven development' as a new paradigm for building AI systems, contrasting it with traditional deterministic testing. It details three types of evals (code-based, human, LLM-based) and explains their necessity due to the probabilistic nature of AI. The post uses an example of generating a React component to illustrate how evals assess not just functionality but also code quality and style adherence. It then presents the 'AI-native flywheel' concept, where evals, data, models/strategies, and feedback form a continuous improvement cycle. Vercel's v0 product is highlighted as a practical application of this methodology, emphasizing the use of evals for rapid iteration, regression prevention, and ensuring quality in areas like refusal and safety. The post also touches on the role of the AI SDK in simplifying model switching and the use of tools like Braintrust for automated evaluations.
  73. AI SDK 3.4AI SDK 3.4 introduces language model middleware for RAG and caching, a data stream protocol to decouple AI SDK UI from AI SDK Core (enabling Python backends), new structured output modes (array and enum) for `generateObject` and `streamObject` functions, and multi-step calls for agentic workflows. It also includes tracing improvements and mock models for testing.
  74. Transforming customer support with AI: How Vercel decreased tickets by 31%This post details the implementation of an AI agent into Vercel's customer support workflow. The agent leverages an LLM and a multi-source knowledge base (website content, documentation, Next.js examples, help articles) to answer customer queries. Key technical aspects include the use of Edge Middleware for A/B testing the rollout, a seamless transition to human support with pre-filled forms, and the collection of data for continuous improvement of documentation and product interfaces. The implementation resulted in a 31% reduction in human-handled tickets and a 42% reduction in first response time.
  75. Using the AI SDK to fix edge-case errors in our codeThis post details the use of the Vercel AI SDK with GPT-4o to solve a specific bug in internationalized domain name (IDN) purchasing. The problem was that Punycode-encoded domains required an associated language code, which was not being utilized. Traditional language detection libraries failed due to short domain names. The AI SDK was used to call `generateText` with GPT-4o, which successfully identified the correct language codes for Punycode domains, leading to a 100% success rate on previously failed purchases and a production deployment.
  76. How to build scalable AI applicationsThis post details how the Vercel AI SDK facilitates multi-provider flexibility, enabling easy switching between AI models (e.g., OpenAI, Anthropic, Google) for optimizing speed, world knowledge, or coding expertise. It highlights the SDK's support for generative UI by streaming UI components directly from AI models and its multi-modal capabilities for processing diverse content types. The post also elaborates on advanced RAG techniques such as multi-modal RAG, dynamic RAG (real-time knowledge base updates), personalized RAG, and explainable RAG. It emphasizes Vercel's platform for simplifying AI implementation, particularly for RAG and data-intensive workflows, by integrating with Next.js data fetching patterns and Secure Compute. The post also discusses infrastructure considerations for AI applications, including latency, caching, streaming, long-running processes, scalability, memory/compute requirements, developer experience, frontend framework support, data storage/retrieval, integration, and cost, advocating for Vercel's AI-native experience over complex cloud provider configurations.
  77. Vercel AI SDK 3.3This post introduces experimental tracing with OpenTelemetry for the Vercel AI SDK, enabling detailed observability of AI function calls. It also adds experimental support for multi-modal file attachments (FileList or URLs) to the `useChat` hook and introduces the `useObject` hook for streaming structured object generation to the client, demonstrated with a Zod schema for expense tracking. New model providers (AWS Bedrock, Chrome AI) and additional LLM settings are also included.
  78. Introducing Vercel AI SDK 3.2This post introduces AI SDK 3.2, focusing on agentic workflows with extended `generateText` and `streamText` capabilities for multi-step agent execution using tools. It adds support for Azure OpenAI, Google Vertex, Cohere, and Ollama providers, along with image input for Anthropic and Google models. Embeddings support is introduced via OpenAI, Mistral, Azure OpenAI, and Ollama, including `embed` and `embedMany` functions and a `cosineSimilarity` helper. DX improvements include an `onFinish` callback for `streamText`/`streamObject` to report token usage and errors, and the ability to access the final typed object from `streamObject` results. Client-side tool execution is enabled via `useChat` and `streamText` with `onToolCall` and `addToolResult` utilities for interactive chatbots.
  79. 7 AI features you can add to your app todayThis post details how Vercel's platform and AI SDK enable businesses to integrate seven AI features: semantic search, natural chatbots, nuanced personalization, instant localization, automatic content generation, developer efficiency, and private data analysis. It highlights the use of LLMs for understanding user intent, generating content, and personalizing experiences. The post also mentions Vercel's infrastructure support for AI workloads, including streaming and caching, and provides examples of Vercel templates and integrations for these features, such as Morphic AI Answer Engine, Next.js AI Chatbot, and OpenAI GPT Slackbot. It also touches upon the use of v0 for generating UI components and the integration with tools like Glean.ai and Viable for data analysis.
  80. Vercel AI SDK 3.1: ModelFusion joins the teamThis post introduces Vercel AI SDK 3.1, which includes AI SDK Core, AI SDK UI, and AI SDK RSC. AI SDK Core provides a unified, ORM-style API for LLMs, abstracting provider differences and supporting text generation and structured object generation with Zod schemas. AI SDK UI offers framework-agnostic hooks for building chat interfaces quickly. AI SDK RSC introduces `streamUI` for generating component-based interfaces beyond text, building on the AI SDK Core's capabilities and supporting tools and tool calling.
  81. Composable AI for ecommerce: Hands-on with Vercel’s AI SDKThis post introduces the practical application of Vercel's AI SDK for building composable AI features in e-commerce, demonstrating a review summarizer built with Next.js, Mistral AI, and v0 for UI prototyping. It highlights the ease of integrating LLMs into applications, the utility of Vercel's AI Playground for model selection, and the benefits of using Next.js caching for AI responses. It also provides ideas for AI-powered search and customer support features.
  82. Introducing AI SDK 3.0 with Generative UI supportIntroduces Vercel AI SDK 3.0, enabling Generative UI by allowing LLMs to stream React Server Components (RSC). This moves beyond plaintext/markdown responses to rich, component-based interfaces. The new `render` method in the SDK supports OpenAI-compatible Functions/Tools, mapping LLM calls to specific RSCs for dynamic data retrieval and UI rendering. It also provides lower-level streaming APIs for custom component streaming. The post clarifies that this relies on RSC and Server Actions, currently implemented in Next.js App Router, and is compatible with LLMs supporting OpenAI's SDK and function calling.
  83. Introducing AI Integrations on VercelThis post announces the launch of nine new AI integrations from leading AI companies and a new model playground. It highlights the Vercel AI SDK as a tool for integrating these models, providing a code example for streaming responses with the Perplexity API in Next.js. It also encourages AI companies and developers to create their own integrations.
  84. Introducing the Vercel AI SDK: npm i aiIntroduces the Vercel AI SDK, an open-source library for building streaming AI applications with React/Next.js, Svelte/SvelteKit, and soon Nuxt/Vue. It includes built-in LLM adapters for OpenAI, LangChain, and Hugging Face, and streaming-first UI helpers like `useChat` and `useCompletion`. The SDK also provides stream helpers for database callbacks and is designed to work with Vercel Functions and Fluid compute. The Chat & Prompt Playground now features a chat interface and AI SDK code generation.
  85. Deploy AI-driven apps on VercelThis post introduces the concept of deploying AI-driven applications on Vercel, highlighting the use of Vercel Functions with Fluid compute for handling long-running AI requests and streaming responses. It details the integration of various AI models (OpenAI's ChatGPT, Whisper, DALL·E 2) and third-party services (Replicate) within Vercel-deployed applications. The post also emphasizes the suitability of frameworks like Next.js and SvelteKit for AI development due to features like API routes, code splitting, and TypeScript support. It mentions the use of Vercel's collaboration features like comments on Preview Deployments for iterating on AI applications. It also provides links to AI-specific templates.