Enterprise
Pricing

All Posts
Engineering
Community
Company News
Customers
v0
Security
Changelog
Press

Search posts

No "" results found at this time.
Try again with a different keyword.

Featured articles

Mar 18
360 billion tokens, 3 million customers, 6 engineers
Impact at a glance Durable ships new production agents to customers in a single day AI features and agents serve ~1.1B tokens per day (360B per year) 10x leverage for every engineer, product manager, and designer 3-4x lower infra cost compared to self hosting Durable began with a simple goal: make owning a business easier than having a job. 60% of U.S. adults say they want to be their own boss, but only about 4% actually do it. Durable’s bet is that the blocker isn’t ambition. It’s friction. “Small businesses are death by a thousand tools, logins, workflows, and designs,” explained James Clift, founder of Durable. “If you remove those barriers, business owners can focus on their customers.” Today, Durable is an AI business builder that helps entrepreneurs launch in minutes, then optimize with agents that handle things like SEO, content, and operations. The gap between idea and ownership has never been smaller. It feels like one seamless experience to their customers, but under the hood it’s a multi-tenant, multi-product platform that has to run millions of individual businesses safely, reliably, and cost-effectively. As they scaled, manually operating multiple services just to self-host was enough work to be a second product. With a small team, Durable chose rapid consolidation over incremental improvement: one codebase, one infrastructure platform. Infra is hard; multi-tenant infra is harder Durable isn’t serving one app. They are managing millions of customer sites, CRMs, and agents, each with different traffic patterns and different operational needs. One customer site might get 100x the traffic of another, and power laws show up quickly. When spikes happen, a small portion of Durable customers can consume a disproportionate share of compute, which made cost isolation, attribution, and pricing strategy significant engineering problems. Khan called out a few of the most acute pain-points from self-hosting: Custom domains and SSL at SaaS scale, including paying thousands of dollars for SSL termination for custom domains Multi-region cluster maintenance, which previously required infrastructure engineers to keep clusters running across multiple geographies Security and bot protection as a multi-tenant risk, so that DDoS attacks aimed at one customer don’t degrade the performance of other sites Observability and cost attribution across millions of tenants From AI as plumbing to AI as product Durable offers more than sites. They help their customers run businesses with a multi-agent, multi-model, multi-modal product. Once agents became a core part of their platform, their developers ran into three problems that were fundamentally different from self-hosting a website platform: Model orchestration: They needed to switch models and providers quickly for reliability and cost, without getting locked into long contracts or reworking the system every time there was an outage or a new model release. Tenant isolation: In a multi-tenant agent system, “context spilling” is existential. Durable needed strict guardrails so one business’s context could never leak into another’s workflows. Per-customer AI economics: AI workloads vary wildly, so Durable needed customer-level visibility into runs, models, and spend to support usage-based or outcome-based pricing with real fidelity. Managing self-hosting and AI infrastructure was a massive distraction for Khan's team of six, so he chose to consolidate their platform into a single system designed for multi-tenant AI workloads. The migration, and why it worked The team realized their existing stack was limiting their ability to solve their customer and platform problems quickly. They knew that in order to win, they needed to tackle those, and future challenges, faster than the competition. “We’re an AI native application,” Khan explained, “so we must focus on creating value with agents, not building out AWS infrastructure.” Khan said that the simplicity of Vercel made their app migration possible. He described the infrastructure upgrade as a single, decisive swing they implemented before touching their code: "We skinned the old product using an iframe, pushed to production on Vercel, then ripped out the self-hosted infrastructure entirely." They didn’t refactor the old way. With a lean team, Durable used coding agents to accelerate the rewrite, burning tokens to move faster as models improved, ultimately emerging with a production-quality codebase. “Everyone tells you not to rewrite your product,” said Khan, “but we did exactly that, and it worked.” Even though resource constraints weren't the motivation for the move, their new infrastructure turned out to be far more cost-efficient as well. Today, Durable’s entire stack runs on Vercel, and they can ship new agents to their customers in a single day. Area of stack What Durable uses on Vercel Build, ship, and run the app Next.js, Functions, Fluid Compute, Turborepo, Flags, Toolbar AI + agents Durable Agents, AI SDK, AI Gateway, Workflows, Skills Edge delivery + multi-tenant routing CDN, Domains (API), Cron Security + abuse prevention Firewall, Bot Protection, BotID, Sandbox Observability + performance Analytics, Speed Insights, OpenTelemetry Data + output Blob (public & private assets), Streamdown, json-renderer 10x leverage to support more entrepreneurs Durable serves more than 3 million businesses. “Think about a 19-year-old selling chocolate-covered bananas at fairs, a holiday porch decoration business in Texas, a plumber who just got their license, and a tech exec who just got laid off,” said Khan. “Those are all Durable customers who are rejecting the 9-5 and building their own future as entrepreneurs.” That’s impressive for 6 engineers and no DevOps team. James Clift, founder of Durable, feels like they've gotten 100x leverage running on Vercel. "It’s incredible what we’ve shipped with such a lean team," Clift reflected. "This is how every tech company in the future will operate."
Eric Dodds
Feb 9
Anyone can build agents, but it takes a platform to run them
Prototyping is democratized, but production deployment isn't. AI models have commoditized code and agent generation, making it possible for anyone to build sophisticated software in minutes. Claude can scaffold a fully functional agent before your morning coffee gets cold. But that same AI will happily architect a $5,000/month DevOps setup when the system could run efficiently at $500/month. In a world where anyone can build internal tools and agents, the build vs. buy equation has fundamentally changed. Competitive advantage no longer comes from whether you can build. It comes from rapid iteration on AI that solves real problems for your business and, more importantly, reliably operating those systems at scale. To do that, companies need an internal AI stack as robust as their external product infrastructure. That's exactly what Vercel's agent orchestration platform provides. Build vs. buy ROI has fundamentally changed For decades, the economics of custom internal tools only made sense at large-scale companies. The upfront engineering investment was high, but the real cost was long-term operation with high SLAs and measurable ROI. For everyone else, buying off-the-shelf software was the practical option. AI has fundamentally changed this equation. Companies of any size can now create agents quickly, and customization delivers immediate ROI for specialized workflows: OpenAI deployed an internal data agent to democratize analytics Vercel’s lead qualification agent helps one SDR do the work of 10 (template here) Stripe built a customer-facing financial impact calculator (on a flight!) Today the question isn’t build vs. buy. The answer is build and run. Instead of separating internal systems and vendors, companies need a single platform that can handle the unique demands of agent workloads. Every company needs an internal AI stack The number of use cases for internal apps and agents is exploding, but here's the problem: production is still hard. Vibe coding has created one of the largest shadow IT problems in history, and understanding production operations requires expertise in security, observability, reliability, and cost optimization. These skills remain rare even as building becomes easier. The ultimate challenge for agents isn't building them, it's the platform they run on. The platform is the product: how our data agent runs on Vercel Like OpenAI, we built our own internal data agent named d0 (OSS template here). At its core, d0 is a text-to-SQL engine, which is not a new concept. What made it a successful product was the platform underneath. Using Vercel’s built-in primitives and deployment infrastructure, one person built d0 in a few weeks using 20% of their time. This was only possible because Sandboxes, Fluid compute and AI Gateway automatically handled the operational complexity that would have normally taken months of engineering effort to scaffold and secure. Today, d0 has completely democratized data access that was previously limited to professional analysts. Engineers, marketers, and executives can all ask questions in natural language and get immediate, accurate answers from our data warehouse. Here’s how it works: A user asks a question in Slack: "What was our Enterprise ARR last quarter?" d0 receives the message, determines the right level of data access based on the permissions of the user, and starts the agent workflow. The agent explores a semantic layer: The semantic layer is a file system of 5 layers of YAML-based configs that describe our data warehouse, our metrics, our products, and our operations. AI SDK handles the model calls: Streaming responses, tool use, and structured outputs all work out of the box. We didn't build custom LLM plumbing, we used the same abstractions any Vercel developer can use. Agent steps are orchestrated durably: If a step fails (Snowflake timeout, model hiccup), Vercel Workflows handles retries and state recovery automatically. Automated actions are executed in isolation: File exploration, SQL generation, and query execution all happen in a secure Vercel Sandbox. Runaway operations can't escape, and the agent can execute arbitrary Python for advanced analysis. Multiple models are used to balance cost and accuracy: AI Gateway routes simple requests to fast models and complex analysis to Claude Opus, all in one code base. The answer arrives in Slack: formatted results, often with a chart or Google Sheet link, are delivered back to the Slack using the AI SDK Chatbot primitive. Vercel is the platform for agents Vercel provides the infrastructure primitives purpose-built for agent workloads, both internal and customer-facing. You build the agent, Vercel runs it. And it just works. Using our own agent orchestration platform has enabled us to build and manage an increasing number of custom agents. Internally, we run: A lead qualification agent d0, our analytics agent A customer support agent (handles 87% percent of initial questions) An abuse detection agent that flags risky content A content agent that turns Slack threads into draft blog posts. On the product side: v0 is a code generation agent, and Vercel Agent can review pull requests, analyze incidents, and recommend actions. Both products run on the same primitives as our internal tools. Sandboxes give agents a secure, isolated environment for executing sensitive autonomous actions. This is critical for protecting your core systems. When agents generate and run untested code or face prompt injection attacks, sandboxes contain the damage within isolated Linux VMs. When agents need filesystem access for information discovery, sandboxes can dynamically mount VMs with secure access to the right resources. Fluid compute automatically handles the unpredictable, long-running compute patterns that agents create. It’s easy to ignore compute when agents are processing text, but when usage scales and you add data-heavy workloads for files, images, and video, cost becomes an issue quickly. Fluid compute automatically scales up and down based on demand, and you're only charged for compute time, keeping costs low and predictable. AI Gateway gives you unified access to hundreds of models with built-in budget control, usage monitoring, and load balancing across providers. This is important for avoiding vendor lock-in and getting instant access to the latest models. When your agent needs to handle different types of queries, AI Gateway can route simple requests to fast, inexpensive models while sending complex analysis to more capable ones. If your primary provider hits rate limits or goes down, traffic automatically fails over to backup providers. Workflows give agents the ability to perform complex, multi-step operations reliably. When agents are used for critical business processes, failures are costly. Durable orchestration provides retry logic and error handling at every step so that interruptions don't require manual intervention or restart the entire operation. Observability reveals what agents are actually doing beyond basic system metrics. This data is essential for debugging unexpected behavior and optimizing agent performance. When your agent makes unexpected decisions, consumes more tokens than expected, or underperforms, observability shows you the exact prompts, model responses, and decision paths, letting you trace issues back to specific model calls or data sources. Build your agents, Vercel will run them In the future, every enterprise will build their version of d0. And their internal code review agent. And their customer support routing agent. And hundreds of other specialized tools. The success of these agents depends on the platform that runs them. Companies who invest in their internal AI stack now will not only move faster, they'll experience far higher ROI as their advantages compound over time.
Eric and Jeanne
Mar 12
How Notion Workers run untrusted code at scale with Vercel Sandbox
Notion Workers let you write and deploy code to give Custom Agents new powers: sync external data, trigger automations, call any API. With Workers, developers can build agents that sync CRM data on a schedule, open issues when error rates spike, and turn Slack threads into formatted content. Under the hood, every Worker runs on Vercel Sandbox. The problem: safely running code from any developer or agent Notion wanted to let anyone extend their platform with custom code. That's a hard infrastructure problem, but an even bigger security problem. Every Notion Worker runs arbitrary code generated by a third-party developer or agent, on behalf of a Notion user, potentially inside an enterprise workspace. Without proper isolation, a Worker would run in the same environment as the Custom Agent, with access to its secrets, permissions, and everything else in that execution context. A single prompt injection could exfiltrate credentials or access another user's data. The requirements were clear: Hard isolation: One Notion Worker can never access another's data or state Credential security: Notion Workers need API keys to talk to external services, but those secrets can never be exposed to the code itself Network controls: Enterprise customers need guarantees about the external services a Worker is allowed to reach Scale: Workers need to support millions of users running concurrent executions without performance degradation State preservation: Workers need fast cold starts, which require the ability to snapshot and restore filesystem state Economics: A billing model that is built for agents with low CPU utilization rates Why Vercel Sandbox Vercel Sandbox runs each Notion Worker in an ephemeral Firecracker microVM. Every VM boots its own kernel, providing stronger isolation than containers. Each execution gets its own filesystem, its own network stack, and its own security boundary. When the Notion Worker finishes, the microVM is either destroyed or snapshotted for later retrieval. To support workloads like Notion Workers at scale, Vercel Sandbox provides several critical capabilities: Credential injection. Sandbox's firewall proxy can intercept and inject API keys into outbound requests at the network level, so credentials never enter the execution environment. For agent-driven workloads, this eliminates the most dangerous prompt injection vector: an agent being tricked into exfiltrating secrets. (We wrote about this architecture in depth in security boundaries in agentic architectures). Network policies. Sandbox supports dynamic network policies that can be updated during runtime without restarting the process: start with internet access to install dependencies, then lock down egress before running untrusted code. Platform builders can pass these controls through to their own customers. Snapshots. Install dependencies once, snapshot the filesystem state, and resume from that snapshot on subsequent invocations. Combined with active-CPU billing, where CPU costs only accrue when your code is actually executing, not waiting on I/O, this keeps costs predictable as usage scales. The bigger picture: Notion as a developer platform Notion Workers isn't a one-off feature. It's the beginning of Notion becoming a developer platform. This shift requires infrastructure that Notion shouldn't have to build. Secure code execution, credential management, network isolation, file-sytem based snapshotting: these are hard problems that compound as the platform scales. Vercel Sandbox handles the infrastructure complexity so Notion can focus on the developer experience. What developers are building with Notion Workers Notion Workers support three main patterns: third-party data syncing, custom automations, and AI agent tools. Developers use them to sync external data, such as CRM records, analytics, and support tickets, into Notion on a schedule. A Worker can also be attached to a button, triggering arbitrary code with a single click. And when Notion's custom agents invoke Workers as tool calls, they become far more capable than agents limited to pre-built integrations. Extend your platform with Vercel Sandbox Notion Workers requires the same capabilities as other agent platforms. Any platform that wants to let users or agents run custom code faces the same set of problems: isolation, credential security, network controls, and scale. Vercel Sandbox provides these as capabilities out of the box. If you're building a platform that needs to run untrusted code, whether for AI agents, developer plugins, or workflow automation, then this is how you do it.
Karson and Harpreet

Latest news.

Customers
Mar 18
360 billion tokens, 3 million customers, 6 engineers
Impact at a glance Durable ships new production agents to customers in a single day AI features and agents serve ~1.1B tokens per day (360B per year) 10x leverage for every engineer, product manager, and designer 3-4x lower infra cost compared to self hosting Durable began with a simple goal: make owning a business easier than having a job. 60% of U.S. adults say they want to be their own boss, but only about 4% actually do it. Durable’s bet is that the blocker isn’t ambition. It’s friction. “Small businesses are death by a thousand tools, logins, workflows, and designs,” explained James Clift, founder of Durable. “If you remove those barriers, business owners can focus on their customers.” Today, Durable is an AI business builder that helps entrepreneurs launch in minutes, then optimize with agents that handle things like SEO, content, and operations. The gap between idea and ownership has never been smaller. It feels like one seamless experience to their customers, but under the hood it’s a multi-tenant, multi-product platform that has to run millions of individual businesses safely, reliably, and cost-effectively. As they scaled, manually operating multiple services just to self-host was enough work to be a second product. With a small team, Durable chose rapid consolidation over incremental improvement: one codebase, one infrastructure platform. Infra is hard; multi-tenant infra is harder Durable isn’t serving one app. They are managing millions of customer sites, CRMs, and agents, each with different traffic patterns and different operational needs. One customer site might get 100x the traffic of another, and power laws show up quickly. When spikes happen, a small portion of Durable customers can consume a disproportionate share of compute, which made cost isolation, attribution, and pricing strategy significant engineering problems. Khan called out a few of the most acute pain-points from self-hosting: Custom domains and SSL at SaaS scale, including paying thousands of dollars for SSL termination for custom domains Multi-region cluster maintenance, which previously required infrastructure engineers to keep clusters running across multiple geographies Security and bot protection as a multi-tenant risk, so that DDoS attacks aimed at one customer don’t degrade the performance of other sites Observability and cost attribution across millions of tenants From AI as plumbing to AI as product Durable offers more than sites. They help their customers run businesses with a multi-agent, multi-model, multi-modal product. Once agents became a core part of their platform, their developers ran into three problems that were fundamentally different from self-hosting a website platform: Model orchestration: They needed to switch models and providers quickly for reliability and cost, without getting locked into long contracts or reworking the system every time there was an outage or a new model release. Tenant isolation: In a multi-tenant agent system, “context spilling” is existential. Durable needed strict guardrails so one business’s context could never leak into another’s workflows. Per-customer AI economics: AI workloads vary wildly, so Durable needed customer-level visibility into runs, models, and spend to support usage-based or outcome-based pricing with real fidelity. Managing self-hosting and AI infrastructure was a massive distraction for Khan's team of six, so he chose to consolidate their platform into a single system designed for multi-tenant AI workloads. The migration, and why it worked The team realized their existing stack was limiting their ability to solve their customer and platform problems quickly. They knew that in order to win, they needed to tackle those, and future challenges, faster than the competition. “We’re an AI native application,” Khan explained, “so we must focus on creating value with agents, not building out AWS infrastructure.” Khan said that the simplicity of Vercel made their app migration possible. He described the infrastructure upgrade as a single, decisive swing they implemented before touching their code: "We skinned the old product using an iframe, pushed to production on Vercel, then ripped out the self-hosted infrastructure entirely." They didn’t refactor the old way. With a lean team, Durable used coding agents to accelerate the rewrite, burning tokens to move faster as models improved, ultimately emerging with a production-quality codebase. “Everyone tells you not to rewrite your product,” said Khan, “but we did exactly that, and it worked.” Even though resource constraints weren't the motivation for the move, their new infrastructure turned out to be far more cost-efficient as well. Today, Durable’s entire stack runs on Vercel, and they can ship new agents to their customers in a single day. Area of stack What Durable uses on Vercel Build, ship, and run the app Next.js, Functions, Fluid Compute, Turborepo, Flags, Toolbar AI + agents Durable Agents, AI SDK, AI Gateway, Workflows, Skills Edge delivery + multi-tenant routing CDN, Domains (API), Cron Security + abuse prevention Firewall, Bot Protection, BotID, Sandbox Observability + performance Analytics, Speed Insights, OpenTelemetry Data + output Blob (public & private assets), Streamdown, json-renderer 10x leverage to support more entrepreneurs Durable serves more than 3 million businesses. “Think about a 19-year-old selling chocolate-covered bananas at fairs, a holiday porch decoration business in Texas, a plumber who just got their license, and a tech exec who just got laid off,” said Khan. “Those are all Durable customers who are rejecting the 9-5 and building their own future as entrepreneurs.” That’s impressive for 6 engineers and no DevOps team. James Clift, founder of Durable, feels like they've gotten 100x leverage running on Vercel. "It’s incredible what we’ve shipped with such a lean team," Clift reflected. "This is how every tech company in the future will operate."
Eric Dodds
Community
Mar 17
Vercel Open Source Program: Winter 2026 cohort
In April, we launched the Vercel Open Source Program to give maintainers the resources, credits, and support they need to ship faster and scale confidently. The first group joined through our spring 2025 cohort. Today we are welcoming the winter 2026 cohort. From AI-native apps and developer infrastructure to design systems and creative tooling, open source builders continue to amaze us. Meet the creators and explore their projects. Winter 2026 Cohort Answer Overflow Answer Overflow is an open source project that makes the content sent in public Discord servers accessible to search engines and AI agents. Over 300+ communities use Answer Overflow to create web pages from their Discord content and it serves 1.5 million month active users. Creator: Rhys Sullivan View the project View GitHub Repository UI TripleD UI TripleD offers UI blocks, components, and full pages in shadcn/ui and Base UI, powered by Framer Motion, with a Landing Builder, Background Builder, and Grid Generator. Creator: Moumen Soliman View the project View GitHub repository hot-updater An open source React Native OTA (Over-The-Air) update solution built as a modern alternative to CodePush, designed to avoid vendor lock-in and work across many infrastructure providers. Creator: Kang Sungyu View the project View GitHub repository Screenshot Studio Screenshot Studio is an open source, fully in-browser canvas editor for creating high-quality visual designs without installs or backend dependencies, with real traction and an active contributor community. Creator: Kartik Labhshetwar View the project View GitHub repository Takumi JSX → Image. A next/og alternative with more advanced features, with growing adoption across companies and open source projects. Creator: Kane Wang View the project View GitHub repository APIs.guru A directory and tooling hub for OpenAPI definitions of public APIs, used by thousands of developers and increasingly by LLM-driven workflows. Creator: Ivan Goncharov View the project View GitHub repository YourDigitalRights.org A free, open source platform that helps people regain control of online privacy by automating data deletion requests to organizations and guiding users through resolution. Creator: Yoav Aviram View the project View GitHub repository KDE Connect An open source project that connects Android devices with desktops for file sharing, notification syncing, and remote control—powered by a global user base and active contributors. Creator: Shakil Ahmed Faisal View the project View GitHub repository heroicons A free, open source library featuring hundreds of beautifully animated Heroicons for React, Vue, and Svelte—ready to drop into modern UIs. Creator: Aniket Pawar View the project View GitHub repository Neobrutal UI A neobrutalist UI component library focused on bold, expressive design—built as an alternative to the minimalism-heavy component library landscape. Creator: Bridget Amana View the project View GitHub repository KanaDojo A free, community-built Japanese learning platform inspired by open source typing tools, with a growing global user base and contributor community. Creator: Aldi Dauletuly View the project View GitHub repository InsForge An AI-agent-first backend platform that helps developers spin up production-ready backends in minutes, with a Supabase-style stack designed for agent workflows via MCP. Creator: Tony Chang View the project View GitHub repository Pett.ai An AI companion app where players care for and build relationships with virtual pets—grown from a simple bot into a highly engaged, global community experience. Creator: Joaquim Cavalheiro View the project View GitHub repository mapcn An open source, copy-paste-friendly map components library for modern web apps, built to make map integration clean, composable, and design-consistent. Creator: Anmoldeep Singh View the project View GitHub repository ui-layouts An open source front-end universe for React and Next.js with 100+ interactive components and motion-rich blocks—built to help developers ship beautiful UIs faster. Creator: Naymur Rahman View the project View GitHub repository data-peek A lightweight, open source tool for exploring databases and SQL without the overhead of traditional clients—popular in education and among developers who want simplicity. Creator: Rohith Gilla View the project View GitHub repository Eldora UI An open source React component library built with TypeScript, Tailwind CSS, MDX, and Framer Motion—focused on clean, reusable, well-documented UI building blocks. Creator: Karthik Mudunuri View the project View GitHub repository OutRay An open source Ngrok alternative built for developers who want a cost-effective, feature-rich tunneling tool with transparent ownership and community momentum. Creator: Akinkunmi Oyewole View the project View GitHub repository GitFriend An open source AI developer assistant for repository chat and automated README generation—built to reduce friction in understanding codebases and maintaining documentation. Creator: Krishna Kant Maharshi View the project View GitHub repository SmoothUI An open source component library with production-ready React components and UI blocks featuring smooth, performance-focused animations and strong accessibility defaults. Creator: Eduardo Calvo López View the project View GitHub repository Cossistant An open source, fully customizable support system built as the “shadcn of support”—open components, open source, and designed to look and feel like your product. Creator: Anthony Riera View the project View GitHub repository Wigggle UI An open source library of simple, well-designed widgets for the web—bringing OS-style widgets into web apps, built on modern standards and shadcn/ui foundations. Creator: Henil Shah View the project View GitHub repository itshover A project that saw rapid adoption and strong community engagement shortly after launch, reaching major milestones in stars and traffic within the first week. Creator: Abhijit Jha View the project View GitHub repository VengenceUI An open source UI system focused on composable components, performance-first patterns, and real-world workflows—built to be easy to own, extend, and ship. Creator: Ashutosh Singh View the project View GitHub repository GoDoxy A high-performance reverse proxy and container orchestrator for self-hosters, designed to simplify service management and reduce setup headaches. Creator: Yu Sing Wong View the project View GitHub repository Moving Icons An animated icon library built natively for the Svelte 5 ecosystem, created to bring motion-rich, developer-friendly icons to Svelte projects. Creator: Jakob Isermann View the project View GitHub repository Ersilia Model Hub A large open source repository of AI/ML models for antibiotic drug discovery, run by a nonprofit focused on fueling biomedical research in the Global South. Creator: Miquel Duran-Frigola View the project View GitHub repository useLayouts An open source animated UI components library offering ready-to-use motion components for free, built to help developers quickly add polish to interfaces. Creator: Urvish Mali View the project View GitHub repository Assertify An open source, AI-powered test generation tool that produces framework-specific, production-ready tests—built to reduce the time and effort of maintaining automated test suites. Creator: Shirley Ugwa View the project View GitHub repository Domainstack An open source domain monitoring and reporting platform built to replace spreadsheets with a clean, end-to-end system for tracking and managing domain portfolios. Creator: Jake Jarvis View the project View GitHub repository Pixjis An open source 2D rendering engine for the web that powers fast, interactive graphics experiences across games, visualizations, and creative tooling. Creator: Sean Burns View the project View GitHub repository browser-ai A TypeScript SDK for different in-browser AI model providers, built to make client-side AI integration simpler and more consistent across vendors. Creator: Jakob Mørk View the project View GitHub repository The world runs on open source Thank you to the winter 2026 cohort of our Open Source Program. We’re looking forward to giving back to the community and watching these projects grow. And to our currently running cohorts (spring, summer, and fall): we're so glad to have you a part of our program!
Alli Pope
General
Mar 16
Meet the 2026 Vercel AI Accelerator Cohort
The Vercel AI Accelerator is back, and this year we selected 39 early-stage teams from across the US, Europe, Asia, and Latin America to build with us for six weeks. The next generation of AI startups is building on our self-driving infrastructure, and the accelerator is how we work directly with the earliest-stage founders among them. This year’s cohort spans every industry, at varying points in their journey, but they share a clear point of view on what needs to exist right now and the urgency to ship it. Teams in the program get access to Vercel infrastructure, $8M+ in partner credits (AWS, Anthropic, OpenAI, Cartesia, ElevenLabs, and more), weekly sessions with founders and technical leaders, and dedicated VC mentors. Meet the 2026 cohort Alloy — Founder: Joe Harris Alloy Robotics turns terabytes of robot data into instant debugging, analysis, and reporting. Archival — Founders: Pablo Diaz-Granados, Jay Katyan, Griffin Ogura Archival reveals how teams are actually using AI. With workflow-level visibility and analytics, leaders can improve AI adoption and ROI. Ares — Founder: Tony Hunter Ares is a revenue command center, a single surface to find, engage, close, and grow revenue, powered by agents that work across your customer data. Carbyn AI — Founders: Jungkeun Hong (CEO), Tim Phuan (CTO) Carbyn AI is Claude Code for machinists, with AI glasses that capture tribal knowledge and coach operators in real time. Cloudglue — Founders: Amy Xiao, Kevin Dela Rosa Cloudglue is the context layer for video, enabling users, AI agents, and applications to understand and work across video at scale. CodeYam — Founders: Nadia Eldeib, Jared Cosulich CodeYam introduces simulations to create a powerful AI-native software development experience. Coreviz — Founder: Wassim Gharbi An AI-native media workspace that understands, organizes, and edits your organization's photos and videos with AI. Grid58 — Founders: Mani HK, Sures Kumar TS Grid58 is the operating system for making software, enabling you to understand what to build, research, design, and code. Hacktron AI — Founders: Zayne Zhang, Mohan Pedhapati, Harsh Jaiswal Hacktron is your AI teammate for security. As AI accelerates the volume of code being written, vulnerabilities scale with it. Hacktron integrates into your development lifecycle to find and remediate real, exploitable issues. HiveBase — Founders: Nick Bae, Tim Tong Plug in your tools, get an AI Chief of Staff, a living company brain, and agents that run your code, marketing, GTM, and strategy. Hotfix — Founders: Sam Forrester, Evan Eissler, Jack Neil Hotfix is an AI production operator that connects to your codebase and cloud infrastructure to fix issues as they happen. Integrated Reasoning — Founder: David Cox Integrated Reasoning is building ARROW, the world's first wafer-scale solver for mixed integer linear programming. Judea — Founder: Maggie Chen Judea is an autonomous agent that continuously optimizes your product on autopilot. Simply define your target metric, and Judea handles the rest. Kinect — Founders: Kratik Agrawal, Varun Kandula Kinect is building dynamic storefronts for human and agent customers, an intelligent AI brand layer that adapts to each visitor. Kuvia — Founders: Martina Belluomini, Ana Gorodisch Kuvia develops AI for digital pathology to detect cancer biomarkers and expand access to precision cancer care. Lane — Founders: Jack Clark, Jorge Armenta Lane is payments and commerce infrastructure for the agentic web, giving AI agents the ability to buy on your behalf and sellers a way to reach them. Mighty — Founders: Johnny Hung, Munam Wasi Mighty stops AI-powered fraud before it happens. The security gateway protects AI agents across text, images, and documents in real time. Milq — Founders: Juan Djuwadi, Neel Makhecha Milq is Lovable for iOS — a delightful Mac app for building Swift applications. Niyam AI — Founders: Samarth Shyam, Agrim Singh Niyam AI is building the control plane for hardware manufacturing. Nura — Founder: Usman Ahmed Nura is the AI copilot for real estate development, automating zoning, feasibility, and pro forma analysis. OpenVet — Founder: Adam Sager OpenVet is an AI hospital for every animal on earth, advancing veterinary medicine with the first outcome-based biological dataset across all species. Orchestra Research — Founders: Zechen Zhang, Amber Jiachen Liu Orchestra Research is building the Jarvis for Science and democratizing science for everyone. Pai — Founders: Gigi Grimes, Everhett Grimes Pai builds digital twins of your real customers so you can test products, ads, and messaging in minutes. Partly — Founders: Shivani Bajaj, Shantanu Prakash Partly is building the data intelligence layer for agent-assisted hardware commerce. Penelope Health — Founders: Sohum Patel, Mattijs De Paepe Penelope is the API and MCP layer for US medical payments — building the largest corpus of payer policies to reduce medical claim denials. ProxieLabs — Founders: Alex Junod, Cristian Besliu ProxieLabs replaces slow, expensive market research with AI-powered conjoint analysis, delivering validated consumer preference data in minutes. Rex — Founders: Merlin Kafka, Lewis Blackwood Rex is an AI platform for operational finance work. Rex unifies customer context across finance systems so agents can run AR processes end to end. Roots — Founders: Lauren Self, David Golovin Roots offers the easiest way to buy and sell homes. Buyers save $100s to $1000s monthly, while sellers net $1000s more at closing. Sentia Labs — Founders: Akshay Murthy, Sarthak Gupta, Advait Kushe Sentia is building the always-on UX insights engine for product teams. Smithery — Founders: Henry Mao, Anirudh Kamath Smithery is building the connectivity infrastructure to enable the agent economy. Takeoff — Founder: Brad Bitler Takeoff is an AI travel platform that helps consumers plan better trips and helps hotels and travel brands reach them at the moment of discovery. Truli — Founders: Catherine Zhou, Michael Wu Truli builds AI agents that help food, supplement, and beverage brands stay compliant. Vakoi AI — Founders: Ao Fu, Gagan Devagiri Vakoi AI delivers customized immersive ads in video games at scale. Zomma — Founders: Jihyun Kim, Cashel Fitzgerald Zomma is a computer-use agent that handles sales and application support for enterprise: 24/7, global, and grounded in your SOPs What's next for the cohort On March 18th, we're bringing the cohort together with the entire Vercel ecosystem for Builder Day at our new San Francisco headquarters. The day will include a fireside chat with Guillermo Rauch (Vercel CEO) and Stephen Haney (Paper CEO), as well as office hours with our accelerator partners. From there, teams will have four weeks to refine and ship, leading up to Demo Day on April 16th in San Francisco. Each team will present what they've built to AI leaders, VCs, and builders, and judges will select three winners to receive over $100K in credits and prizes from Vercel and our partners, including an investment from Vercel Ventures for the first-place team. Past accelerator teams like Stably AI, Cervo, and Bear AI have gone on to raise venture rounds, land enterprise customers, and form partnerships through the program. Follow along as this year's cohort builds over the next six weeks.
Alli and Caroline
Customers
Mar 12
How Notion Workers run untrusted code at scale with Vercel Sandbox
Notion Workers let you write and deploy code to give Custom Agents new powers: sync external data, trigger automations, call any API. With Workers, developers can build agents that sync CRM data on a schedule, open issues when error rates spike, and turn Slack threads into formatted content. Under the hood, every Worker runs on Vercel Sandbox. The problem: safely running code from any developer or agent Notion wanted to let anyone extend their platform with custom code. That's a hard infrastructure problem, but an even bigger security problem. Every Notion Worker runs arbitrary code generated by a third-party developer or agent, on behalf of a Notion user, potentially inside an enterprise workspace. Without proper isolation, a Worker would run in the same environment as the Custom Agent, with access to its secrets, permissions, and everything else in that execution context. A single prompt injection could exfiltrate credentials or access another user's data. The requirements were clear: Hard isolation: One Notion Worker can never access another's data or state Credential security: Notion Workers need API keys to talk to external services, but those secrets can never be exposed to the code itself Network controls: Enterprise customers need guarantees about the external services a Worker is allowed to reach Scale: Workers need to support millions of users running concurrent executions without performance degradation State preservation: Workers need fast cold starts, which require the ability to snapshot and restore filesystem state Economics: A billing model that is built for agents with low CPU utilization rates Why Vercel Sandbox Vercel Sandbox runs each Notion Worker in an ephemeral Firecracker microVM. Every VM boots its own kernel, providing stronger isolation than containers. Each execution gets its own filesystem, its own network stack, and its own security boundary. When the Notion Worker finishes, the microVM is either destroyed or snapshotted for later retrieval. To support workloads like Notion Workers at scale, Vercel Sandbox provides several critical capabilities: Credential injection. Sandbox's firewall proxy can intercept and inject API keys into outbound requests at the network level, so credentials never enter the execution environment. For agent-driven workloads, this eliminates the most dangerous prompt injection vector: an agent being tricked into exfiltrating secrets. (We wrote about this architecture in depth in security boundaries in agentic architectures). Network policies. Sandbox supports dynamic network policies that can be updated during runtime without restarting the process: start with internet access to install dependencies, then lock down egress before running untrusted code. Platform builders can pass these controls through to their own customers. Snapshots. Install dependencies once, snapshot the filesystem state, and resume from that snapshot on subsequent invocations. Combined with active-CPU billing, where CPU costs only accrue when your code is actually executing, not waiting on I/O, this keeps costs predictable as usage scales. The bigger picture: Notion as a developer platform Notion Workers isn't a one-off feature. It's the beginning of Notion becoming a developer platform. This shift requires infrastructure that Notion shouldn't have to build. Secure code execution, credential management, network isolation, file-sytem based snapshotting: these are hard problems that compound as the platform scales. Vercel Sandbox handles the infrastructure complexity so Notion can focus on the developer experience. What developers are building with Notion Workers Notion Workers support three main patterns: third-party data syncing, custom automations, and AI agent tools. Developers use them to sync external data, such as CRM records, analytics, and support tickets, into Notion on a schedule. A Worker can also be attached to a button, triggering arbitrary code with a single click. And when Notion's custom agents invoke Workers as tool calls, they become far more capable than agents limited to pre-built integrations. Extend your platform with Vercel Sandbox Notion Workers requires the same capabilities as other agent platforms. Any platform that wants to let users or agents run custom code faces the same set of problems: isolation, credential security, network controls, and scale. Vercel Sandbox provides these as capabilities out of the box. If you're building a platform that needs to run untrusted code, whether for AI agents, developer plugins, or workflow automation, then this is how you do it.
Karson and Harpreet
Security
Mar 10
How we run Vercel's CDN in front of Discourse
Vercel's CDN can front any application, not just those deployed natively on the platform, and it's simple to set up. This allows you to add firewall protection, DDoS mitigation, and observability to platforms like Discourse or WordPress without migrating them completely. The Vercel Community is an example of this architecture. It is a Discourse application hosted elsewhere, but we proxy it ourselves via Vercel's CDN, which both protects the app and gives us access to useful features in Vercel's website stack: Web Analytics gives us anonymized, cookie-free demographic and referrer data, so we can see where users are coming from and what they're looking for. Firewall gives us DDoS protection and has automatically prevented several attacks in the last year. Bot Management lets us block malicious scrapers while allowing trusted crawlers to index the forum and allow community posts to show up in ChatGPT searches. Some parts of the community platform, like Vercel Community live sessions, run directly on Vercel with Next.js. We use Vercel Microfrontends to mount a Next.js app on the same domain as the Discourse app, for three reasons: To create new pages that would be impractical to implement as CMS plugins. To overwrite existing Discourse pages that we can't fully customize. To keep users authenticated through Sign in with Vercel When the new pages are ready to launch, we add the path to our microfrontends configuration and users are rerouted seamlessly on the next deploy. Vercel as a CDN To set up Vercel as a CDN proxy like this, you need two domains: Inner host: The origin server where the site is actually hosted. This might look like your-site.discourse.com Outer host: The Vercel project domain that users interact with, such as community.vercel.com Ensure that all links on the site and its canonical URLs use the outer domain. Once those are in place, create a new project on Vercel that deploys to the outer host. You can then use vercel.ts (formerly vercel.json) to rewrite traffic to the inner domain. Running multiple apps on a single domain with microfrontends To extend the community forum beyond the limits of Discourse, we configured with the outer host domain using a vertical microfrontend approach. Vercel's microfrontends allow you to mount different Vercel projects to different route paths. We added a microfrontends.json file that directs traffic for specific routes to separate Vercel projects. Additional pages can be added incrementally, route by route. We also added the .well-known/workflow route to use Workflow Development Kit for event creation and video processing. While you could accomplish some of this by using negative matching in the proxy regex to avoid proxying certain routes, splitting the projects provides better isolation. This approach allows for independent environment variables and organization permissions, locking down the project that talks to the third-party host. A modern CDN without a massive migration At this point, you have Vercel's CDN standing between your users and your origin server. All traffic flows through Vercel's global network, giving you enterprise-grade security without touching your existing application. You get even more flexibility when you combine this with microfrontends. You now have a path to modernize your application incrementally. Instead of a "big bang" refactor, you can create a Next.js application and turn on specific routes one by one, while your core application continues to run on Discourse, WordPress, or whatever platform it is built on. This architecture unlocks a pragmatic path forward: secure your existing investment with Vercel's CDN today, then layer modern features on top tomorrow, all without the risk of a full platform migration. Learn more by reading the Vercel microfrontends documentation or see it in action at community.vercel.com/live.
Jacob Paris
General
Mar 5
From idea to secure checkout in minutes with Stripe
Building commerce applications looks very different than it did even a few years months ago. Teams are no longer treating storefronts and billing systems as long-running integration projects that happen after the product is complete. They iterate quickly, deploy globally by default, and increasingly rely on AI tools to generate UI, checkout flows, and subscription logic. Commerce is becoming more programmable and increasingly agent-driven. As AI systems begin to generate storefronts, assemble checkout flows, and optimize billing logic, the setup, integrations, and infrastructure need to be just as composable and automated. With tools like v0, and agentic coding agents working with Vercel CLI and Vercel Marketplace, developers can move from idea to deployed product much faster than before. As that workflow becomes more automated and AI-native, the surrounding systems need to keep pace, and the developer's experience (which includes the agent's) needs as much focus as the end-user's. An improved developer experience Historically, moving from a Stripe Sandbox to accepting live payments required retrieving API keys, copying them into environment variables, and verifying configuration across multiple environments. It worked, but it introduced unnecessary friction and risk at precisely the moment a team was ready to go live. Stripe is now generally available on the Vercel Marketplace and in v0, with full support for connecting production accounts. You can connect an existing live Stripe account directly to a Vercel project or import one into your environment and begin accepting real payments without rebuilding your integration. The connection flow provisions the required environment variables automatically, so moving from test mode to live transactions does not require manual key exchange or rewiring your application. The beta release supported Stripe Sandbox account creation, and now general availability unlocks full production use cases, including live ecommerce storefronts, SaaS subscriptions, usage-based billing, and invoicing. With this release, going to production with payments is a single integration between your project and Stripe, rather than a separate configuration step that happens outside of it. Reducing setup friction while improving security Making payments easier to connect is only useful if it is also secure by default. To support production connections, Vercel partnered with Stripe to build a new set of key management APIs. Credentials are now generated, exchanged, and stored programmatically, reducing the surface area for human error while maintaining correct separation across development, preview, and production environments. Under the hood, the integration performs a cryptographic key exchange rather than requiring developers to manually retrieve and paste API credentials. The required Stripe keys are provisioned automatically and stored as environment variables within the appropriate Vercel environment, Stripe provides two types of API keys: Secret keys (STRIPE_SECRET_KEY): These must only be used in server-side code, such as API routes or Server Actions. They should never be exposed in client-side code or committed to version control Publishable keys (NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY): These are safe for client-side use. They identify your Stripe account but cannot perform sensitive operations. Get started With Stripe connected through the Vercel Marketplace, moving from a working application to live revenue becomes part of the same workflow you use to build and deploy your product. You can start with a simple example that creates a Checkout Session and deploy your first online store using Vercel and Stripe. Create a Checkout Session: Install Stripe from the Vercel Marketplace or v0, connect your account, and your environment variables are ready before you write a line of payment code. See the changelog and documentation for more details.
Dima and Hedi
General
Mar 3
Building Slack agents can be easy
Slack is already where teams work. It provides a natural interface for agents, with messages, threads, buttons, and events, so you don't need to invent a new UI or onboarding flow. Getting from "I want a Slack agent" to a running deployment, though, means coordinating across a lot of systems: Creating an app in the Slack API console Configuring OAuth scopes and event subscriptions Writing webhook handlers and signature verification Deploying to infrastructure that can handle Slack's 3-second response window Each piece has its own docs, and they all need to work together. Coding agents like Claude Code, OpenCode, Cursor, and GitHub Copilot are well suited for exactly this kind of coordination because they can read docs, reason through dependencies, and generate code in seconds. We built the Slack agent skill to take advantage of that. It builds on our Slack Agent Template, works with the coding agent of your choice, and takes you from idea to a deployed Slack agent on Vercel in a single session, automating steps when possible and showing you exactly what to click when it can't. From idea to deployed agent with the skill wizard Install the skill and run the wizard: Then run the skill in your agent. For example, with Claude Code: The wizard starts by asking what kind of agent you want to build. You might say "a support agent that answers questions from our internal docs," or "a standup bot that collects updates from the team every morning." Based on your answer, it generates a custom implementation plan tailored to your use case. You review and approve the plan before any code is written. From there, you move through five stages: Project setup: You choose your LLM provider, and the agent scaffolds your project from our Slack Agent Template. Slack app creation: The agent customizes your manifest.json with your app name, description, and bot display settings, then opens Slack's console and walks you through creating the app and installing it to your workspace. OAuth scopes, event subscriptions, and slash commands come pre-configured from the template. Environment configuration: The agent walks you through setting up your signing secret, bot token, and any API keys your project needs. Local testing: The agent starts your dev server and connects it to Slack so you can message your bot and see it respond in real time before anything touches production. Production deployment: The agent walks you through deploying to Vercel and setting up your environment variables. From this point, every git push triggers a new deployment. What the skill gives you The Slack agent skill gives you an agent that can: Hold multi-turn conversations across messages and threads Pause for human approval before taking sensitive actions Stream responses to Slack in real time Read channels and threads on its own Your agent interacts with Slack and your systems through tools, functions it can call to take actions or retrieve information. The template ships with tools for: Reading channel messages Fetching thread context Joining channels (with human approval) Searching channels by name, topic, or purpose You can also tell your coding agent to add custom tools that connect to your own systems. Want the agent to look up a customer record, create a support ticket, or query a database? Each of those becomes a tool the agent knows when and how to call. Workflow DevKit is what makes the agent durable. A Slack agent often needs to hold a conversation across many messages, or wait hours for someone to approve a request. Workflow DevKit lets the agent suspend mid-conversation, wait for external input, and pick back up exactly where it left off. Tool calls are automatically retried on failure, and responses stream back to Slack in real time. Human-in-the-loop is built in. When the agent needs to perform a sensitive action like joining a channel, it posts a message with Approve and Reject buttons and suspends. You're only billed for active CPU time, so waiting costs nothing, even if approval takes days. This pattern extends to any action requiring approval, from sending messages to modifying data to calling external APIs. AI Gateway gives your agent access to hundreds of models from every major provider through a single API key. Switching models is a one-line change, and if a provider goes down, AI Gateway automatically routes to another so your agent stays up. Going deeper Once your agent is live, there are a few ways to extend it and understand it better. Our Vercel Academy Slack Agents course covers the entire lifecycle, from creating and configuring a Slack app to handling events and interactive messages, building agents with the AI SDK, and deploying to production. Vercel preview deployments let you test changes before they reach production. For Slack bots, this may require bypassing deployment protection so Slack's webhook verification can reach your endpoint. Our testing guide explains how to set this up. Vercel Sandboxes let your agent execute code in isolated environments, so it can run user-provided scripts like analyzing a spreadsheet, generating a chart, or transforming data without risking your infrastructure. Get started The whole experience fits in one session with your coding agent. Slack Agent Skill Slack Agent Template Vercel Academy: Slack Agents
Timothy Jordan
General
Mar 3
Scaling redirects to infinity on Vercel
Redirects are trivial at a small scale, but at millions, latency and cost become real systems problems. Previously on Vercel, redirects were handled by routing rules and middleware. Routing rules support up to 2,000 complex redirects with wildcards, and they function as an ordered list evaluated in sequence. Each rule may involve regex matching, meaning a single request could trigger many expensive evaluations. This is acceptable for a few thousand routing rules, but as counts grow, per-request work increases linearly. Middleware offers more flexibility, but it adds latency by running extra code on every request. To serve millions of redirects with low latency, we needed a dedicated lookup path with near-constant or logarithmic time per request. Building on our previous work to make global routing faster with Bloom filters, we found a way to scale to millions of redirects. What we optimized for Scale: Support millions of static redirects per project Runtime behavior: No additional latency cost for projects that don't configure redirects A fast "no redirect" path, since most requests won't be redirected Low process memory usage, relying on external storage and caching layers instead Engineering values: Simplicity and debuggability over premature optimization Evolve iteratively rather than trying to get it perfect on the first try With those goals in mind, we started with the simplest design we could think of, combining the redirects and Bloom filter in a single file. Since the redirect data was already JSON, and our Bloom filters already supported JSON exporting, we decided to use the JSONL file format to store this information. JSON and Bloom filters versus napkin math A Bloom filter is a probabilistic data structure that tests whether an element is a member of a set. Bloom filters can return false positives but never false negatives, so they answer "definitely not in the set" or "maybe in the set." By checking a small, cached Bloom filter first, we could skip the redirect lookup entirely for requests that don't match, keeping the common "no redirect" path extremely cheap. Only on a positive match would we parse the JSON file. Simple, but would it scale? The napkin math said no. A million redirects could easily produce a file in the hundreds of megabytes, and fetching and parsing something that large would blow our latency and memory budgets. We needed to avoid loading the entire dataset at once. Sharding and Bloom filters keep memory low and lookups fast The fix was sharding. Instead of one massive JSONL file, we hashed the redirect path to distribute entries across many small shards. This allows us to load a small slice of data for a specific request, which shifts the burden from process memory to external storage and the file system cache. The Bloom filter still sits in front, short-circuiting the lookup for the vast majority of traffic. But now, when a request does pass the Bloom filter, we only need to fetch and parse a single small shard rather than the entire redirect set. Shard structure Each shard contains 3 parts: A header line that encodes the properties of the Bloom filter The base64 encoded Bloom filter A JSON object of redirects, keyed by src path Here is a sample: At build time, we generate all of the shards and their Bloom filters and upload them to external storage. At runtime, the server only needs to know which dataset and shard count apply to a given project or deployment when it receives a request. The lookup path checks the Bloom filter before parsing JSON At request time, the bulk redirect lookup works like this: Check whether the project or deployment has bulk redirects configured. If not, skip everything and proceed as usual. Compute the redirect key from the incoming request and hash it to determine the shard. Retrieve the shard from the cache or origin, and check the Bloom filter. If the key is not present in the Bloom filter, we do not parse the JSON body of the shard. If the key is maybe present in the Bloom filter, we load the JSON body of the shard and look up the exact redirect inside that object. This design has some nice properties: Fast negative lookups: Bloom filters are very fast and can be tuned to have a very low false positive rate Human‑readable shards: Shards are just JSONL files. If something goes wrong, it's easy to dump a shard and see exactly what it contains Low implementation risk: JSON parsing and Bloom filters are simple, so this can ship quickly, allowing us to gather real‑world data JSON parsing became a bottleneck on positive lookups We suspected JSON parsing might become a bottleneck, and our dogfooding confirmed it. When the Bloom filter indicated a redirect might exist, parsing the full JSON body for the relevant shard took considerable time. We also saw massive latency spikes under high CPU load, since JSON parsing is CPU-intensive and competes for resources with everything else on the node. Reducing shard size would help with parsing speed, but smaller shards increase cardinality (the number of shards to manage) and cache miss rates. This created a trade-off. Large shards meant higher CPU overhead from parsing, while small shards meant more I/O latency from cache misses. We needed a data format that could retrieve a single value without parsing the entire shard. Binary search over sorted keys to avoid parsing the entire shard Instead of storing redirects in a JSON blob, we implemented a binary search keyed by the redirect path. Each shard stores its redirect keys in sorted order, so we can perform a logarithmic-time search over those keys. Once we find the key, we only need to parse the JSON for that specific redirect. This sidesteps the shard size problem entirely. Lookup cost no longer scales with the total amount of data in the shard, so we can keep shards large enough for good cache hit rates without paying for full JSON parsing. Latency dropped and the spikes disappeared With JSON parsing out of the hot path for positive lookups, requests for redirects that actually exist became both faster and more predictable. The most visible improvement was the elimination of the latency spikes we had seen under high CPU load. When parsing a full JSON shard, redirect lookups competed for CPU time with everything else running on the node. With binary search, the per-request CPU cost dropped low enough that resource contention stopped being a factor. Designing for the common case Redirects themselves are simple. The challenge comes from combining that simple abstraction with large, mostly cold datasets and strict latency expectations at the edge. Routing rules were the wrong tool for this job. Instead, we built a dedicated path for bulk redirects: Shard redirect data so each piece stays small Use Bloom filters so the common "no redirect" case stays cheap Store redirects in a layout that supports binary search over keys This development cycle reinforced a principle we keep coming back to. Avoid premature optimization. By starting with a simple, debuggable implementation and instrumenting it, we let production data dictate where complexity was actually needed. Get started with bulk redirects Bulk redirects are available for Pro and Enterprise customers, configurable via project configuration, the dashboard, API, or CLI. The current limit is 1 million redirects per project. If you need more capacity, reach out to us. Plan Included redirects Additional capacity Pro 1,000 per project $50/month per 25,000 Enterprise 10,000 per project $50/month per 25,000 Use bulk redirects to manage large-scale migrations, fix broken links, handle expired pages, and more. See our bulk redirects documentation or the getting started guide.
Ben, Tim, and Sudais
General
Mar 2
Advancing Python typing
We’re excited to share a year-long research effort aimed at making Python’s type system more expressive and composable, something closer in spirit to the programmable types in TypeScript, but carefully crafted for Python’s runtime model. The result is PEP 827: Type Manipulation. Python’s runtime is incredibly powerful: classes, methods, and even whole APIs can be generated on the fly from a few lines of code. Concepts like metaprogramming can transform class declarations, decorators can give functions and methods additional behaviors, and those are just a few examples. But Python's static typing often can’t “follow along” without typechecker plugins or boilerplate code. PEP 827 proposes a set of standard, type-level building blocks for introspecting existing types and constructing new ones, designed to help both type checkers and runtime tooling. FastAPI creator Sebastián Ramírez summed up the potential impact well on our post in the Python Discourse: Quick taste One concrete example is the familiar TypeScript utility types, like Pick and Omit. Here's Pick implemented in TypeScript and Python side by side: We can immediately see that the TypeScript dedicated typing syntax is short and to the point, albeit quite different from the rest of the language. Python, on the other hand, relies on the standard Python imperative syntax combined with type-level APIs. Now let's look at how Omit can be implemented: Interestingly enough, Python's version is more in line with the Pick implementation, the only difference is inverting the condition. TypeScript, on the other hand, composes quite differently, and requires a deeper rewrite. This illustrates that the big idea isn't "make Python look like TypeScript." It’s to give Python typing a programmable core that matches Python’s semantics and stays introspectable at runtime, so frameworks like Pydantic can benefit too. What's next PEPs are debated, revised, and sometimes rejected. We’re excited to be part of that process, and we invested in this research because we build across TypeScript and Python and want both ecosystems to thrive. One might ask: in an age where agents are writing an increasing share of source code, should we even care about programming language syntax, tooling, or type system capabilities? We argue the answer is, more than ever, "yes". We want type checkers to be more thorough and frameworks to be more expressive, so that we can safely ship more reviewable, succinct code. The less boilerplate we have to maintain, the better, and we don’t see that changing anytime soon. So yes, agents will care. And so will we.
Yury and Michael
Customers
Feb 28
Gamma builds design-first agents with Vercel
Gamma began with a simple idea: what if your presentation could design itself? With a single sentence, users can generate a complete presentation that respects layout, spacing, and hierarchy. Columns reflow automatically. Diagrams adjust when new layers are added. The product handles the formatting so teams can stay focused on the ideas. That philosophy reflects the company's DNA. Of Gamma's first ten hires, three were designers. "The attention to detail and value placed on design has been baked into the culture from the very, very beginning," says Sherwin Yu, Head of AI and Product Engineering. "Our designers at Gamma are fantastic. They ship code, they're technical. They'll push to production." "There's a lot of discussion about how do we, whenever possible, elevate the user experience," Sherwin says. As adoption grew, the team realized generation was only the beginning. Real presentation work happens in iteration. Teams outline, restructure, refine tone, and polish visuals. In October 2025, Gamma launched Gamma Agent, a conversational editing that shifted the AI capabilities dramatically. Evolving complex agent architectures with AI SDK The first version of Gamma generated decks from a prompt. Gamma Agent introduced dialogue, and with it, a new relationship between the user and the product. As the team started prototyping more powerful agents, that simplicity broke down. They needed finer control and more persistence over conversation state. They needed the ability to pass context from one agent to another, manage message history across sessions, and orchestrate more complex multi-step interactions than a simple request-response loop. The decisions a user made early in a workflow, the reasoning behind the structure, the tone they'd settled on… all of that was valuable context that couldn't just live in a disposable chat window. By building on the AI SDK rather than custom orchestration code, Gamma can evolve agent behavior without re-architecting its backend. Gamma's investment in composable, model-agnostic architecture extends beyond text. The company's image pipeline, which has generated more than 1.5 billion images across 60 models and 20 providers, has gone through its own architectural reckoning. Image generation Staying on the frontier of image generation means integrating new models fast… sometimes within days of launch. When the Vercel AI SDK introduced ImageModelV3, a standard interface for image generation with a composable middleware layer, Gamma's team saw it as yet another opportunity. Today, adding a new image model to Gamma is about 30 lines of code: just a model ID, cost formula, supported sizes, and capability flags. Tracing, cost tracking, and image preprocessing are handled automatically by shared middleware that wraps every model. Engineers never think about that plumbing; they just declare what a model can do. This pays off in the product. Infographics When the team shipped AI infographics, Gemini needed multimodal style references (actual images showing the target aesthetic), while Flux worked best with concise, text-only prompts. Because the model layer is just configuration, those per-model strategies live in the feature code, not buried in infrastructure. New model, new capability, new feature—each independent. The result: Gamma ships new models in hours, not weeks, and every model automatically gets production-grade observability from its first request. Shipping continuously with preview deployments Gamma applies the same philosophy to its deployment workflow: pick stable foundations, then move fast on top of them. Instead of building its own release system, the team relies on Vercel's Preview Deployments, production deployments, and Instant Rollbacks. "We try not to reinvent infrastructure we don't have to," Sherwin says. "We'd rather spend that engineering energy on the product." Despite Gamma’s team of just 20 or so engineers, Gamma averages more than 250 deployments per day across preview and production. Deploys complete in just over 7 minutes at median, with a 99 percent success rate. Preview deployments make it safe to experiment with agent behavior on every pull request. Instant Rollbacks provide confidence when shipping changes that affect model logic or orchestration. Scaling the AI content pipeline on Vercel Gamma's AI outputs raw HTML, but a presentation is more than markup, it's a structured document with layout rules, resolved images, live charts, and editable diagrams. Every generated card passes through a conversion layer that bridges that gap in real time. Gamma runs this critical translation layer as Vercel Functions. Every AI-generated card passes through a serverless endpoint that instantiates the complete Tiptap editor schema inside JSDOM, parses the LLM's HTML output into structured editor content, and resolves async assets. Other serverless functions handle the reverse direction (serializing editor content into AI-readable HTML) and generating theme preview images on the fly. All together, Gamma’s use of serverless functions ensures presentations load quickly and AI-powered editing stays responsive for users worldwide. Designing for what’s next As agents across the industry get more capable, the limiting factor shifts from intelligence to information. "An agent that knows your brand guidelines, your previous presentations, and your company's tone of voice is infinitely more valuable than a generic model," Sherwin says. "Right now, context is what separates a useful agent from a generic chat bot." He sees context operating at three levels: the immediate session, the user's history across projects, and the organizational layer (meaning things like brand assets, templates, knowledge base). Getting all three into the model's window, efficiently and at the right moment, is the architectural challenge every company building agents is wrestling with. It's the same vision Gamma has been building toward from day one, making it effortless to turn ideas into polished, compelling communication. First through intelligent layout and design. Then through conversational editing. And now, through a context layer that understands what you're building and why. What hasn't changed is how Gamma builds: pick the right abstractions, stay model-agnostic, keep enough flexibility to rebuild when the landscape moves, and ship before the window closes. In a space that reinvents itself every six months, that adaptability is the real moat.
Madison McIlwain
Customers
Feb 28
How Avalara turns pipe dreams into patent-pending with v0
Avalara connects businesses to more than 1,400 systems to automate tax compliance around the world. It’s a massively complex ecosystem that spans ERP systems, finance platforms, and compliance tools, all talking to each other. For Chief Strategy and Product Officer Jayme Fishman, the path forward is modernizing how Avalara builds. His mandate is to drive digital transformation, with a sharp focus on AI and innovation. Enter Vercel’s v0, which translates plain language into working prototypes. Within months, the team built two new patent pending products—and along the way, changed how the company builds. Seeing is believing Before v0, bringing an idea to life required a mountain of slides, careful specs, and ample interpretation. Fishman might have a strong vision, but getting started meant writing everything down, then waiting for designers and engineers to bring it to life. “It could be a significant delay before we even had a conceptual mock-up.” That changed overnight. One of Avalara's biggest challenges was supporting customers who could be plugging into more than a thousand different systems. "We could provide technical documentation and show customers what to do," Fishman said, "but we couldn't see what they were doing. Once they left our system, we lost visibility… and the ability to help." Fishman imagined a solution that could meet customers where they were. What if Avalara built a Chrome extension that could live alongside a user's workflow, walk them through each step of an integration specific to the systems they were using, and stay behind to answer any questions? He described it to a teammate, who went straight into v0. "The next morning, there's a video in my Slack. It shows exactly what I described the night before," Fishman recalled. "I showed it to my exec team, and all the light bulbs lit up." “I can describe what I want and wake up to a working demo. It’s tectonically shifting how we build.” That demo—built in v0—became the basis for a new patent, a production build, and a press release, all within about 60 days. “It was one of those moments,” he said, “where you realize you don’t need to talk people into an idea if they can see it.” Driving alignment with product design Like many SaaS organizations, Avalara’s product and design process used to depend on long handoffs. Product managers wrote PRDs. Designers translated them into Figma files. Engineers reviewed and rebuilt. “There’s desire and intent,” Fishman said, “and then there’s what actually happens—where everyone gets tagged in late and we lose momentum.” With v0, that flow changed completely. Product leads now start directly in the tool, describing what they want in plain language and watching v0 translate intent into a functioning interface. “It’s like you can will it into existence,” Fishman said. “You describe the problem, and five minutes later, you’re looking at a solution.” For designers, the shift has been equally dramatic. “You can just grab someone, show them what you mean, and start iterating,” Fishman explained. “It takes something that used to be async and turns it into a real conversation.” A new way of building Across Avalara, prototypes have replaced concepts. Fishman calls it “a cultural accelerant.” The results speak for themselves: two patent-pending products created in roughly 60 days, faster design and validation cycles, and a company-wide shift toward building through iteration, not interpretation.” About Avalara: Avalara connects businesses to more than 1,400 systems to automate tax compliance around the world.
Nic Vargus
Community
Feb 27
Keeping community human while scaling with agents
At Vercel, our developer community is at the heart of everything we do. It's how we stay closest to the people using what we build. As our community grew, automation helped us scale. But questions still got lost, routing took time, and context switching pulled us away from the work that actually required our expertise. And automation could never help with the things that mattered most, the moments where you really connect with someone and help them. You can't use AI to replicate the feeling of talking to a person who really cares. So we built agents to take over the routing, triage, and follow-ups that don't need a human. We call this the Community Guardian. Let's talk about what it does, how we built it, and how anyone, including non-engineers, can ship agents too. The Community Guardian operations layer When a new post comes in, the Guardian analyzes it, checks for duplicates, and assigns it to the team member with the right specialty and bandwidth. Each person handles up to 10 questions before new ones go to someone else, keeping the workload balanced across time zones. Nothing gets overlooked. If a question goes unanswered for 48 hours, the Guardian reassigns it. It sends reminders when we're waiting for more information and detects when conversations are resolved. Under the hood, the Guardian uses Claude through AI Gateway and runs on Vercel Workflows, which lets it check in every 10 minutes and sleep between cycles without consuming resources. That handles the operations side, but our team still needed better context to respond well. The intelligence layer: c0, the research assistant While the Guardian manages logistics, c0 is the agent that goes deep on research. It lives in Slack, where our team already works. When a team member needs context on a thread, c0 searches our knowledge base, documentation, GitHub issues, and past discussions to put together a context package. The context package helps our team respond faster and more accurately instead of relying on their own memory. Beyond individual threads, c0 helps us close the loop with our product teams. It tracks community sentiment and recurring technical hurdles, so rather than someone spending hours auditing a week's worth of posts, we can ask c0 for the "top product feedback" and bring real data to our product conversations. Reclaiming human focus In its first 23 days, the system helped 281 unique users: Metric Outcome Initial context gathering 4,716 first responses triaging issues and gathering logs before a team member arrives Thread revival 1 in 8 "ghosted" threads brought back to life, resulting in 23 confirmed solutions Operational scale Over 1,400 agent runs in a recent two-week period, from stale-checks to auto-solving Duplicate detection 4 duplicate threads detected via vector similarity, with 3 auto-closed at 95%+ confidence Every substantial answer still comes from our team. Agents handle everything else around those answers. Without the repetitive parts of triage and tracking, our team can spend time on complex pair-debugging and relationship building, creating content for the broader community, or just having fun with the developers they care about. Build your own You don't have to be a developer to build something like this. You just need an idea. I'm not an engineer. I manage community and talk to developers. Sure, I understand the problems we're solving, but I'm not writing production code every day. My idea started at a talk in Zurich where I showed how we were automating community workflows. But that was traditional automation, scripts and rules and if-this-then-that logic. It worked, but it was brittle. Every edge case needed a new rule. I wanted something smarter, so I started experimenting with my coding agent to add a thinking layer, the step between "new post arrives" and "take action." Instead of "if post contains 'billing' then route to billing team," it became "read this post, understand what the person actually needs, then decide." The thinking layer is like another DX engineer looking at each post who can read between the lines when a user says "it's not working," connect dots to a GitHub issue from three months ago, understand when someone's frustrated vs. just confused, and know when to escalate vs. when to gather more context. Building this way meant I could describe what I wanted in plain English, get working code back, test it against real community threads, and iterate. I wanted to use different models for different tasks, give our agent access to read our docs and community, and allow it to suspend, resume, and recover if something failed. Instead of building all of that from scratch, I described what I needed to my coding agent and landed on AI Gateway, AI SDK, and Vercel Workflows, which already handle those complexities. The prompts that built it The first prompt was the core idea: "Build me an agent that helps me with the community, day-to-day operations like assigning posts and formatting. I don't know which model will work best yet but make it easy to switch without needing new API keys. Use the AI SDK for the agent." From there, the prompts got more specific as I understood more about what I was building. "And triggers every 10 minutes, I want to check for the latest threads." I'd started with cron jobs, but switched to Vercel Workflows for this. The durable execution meant the agent could suspend between checks and resume exactly where it left off. "Make sure we're rotating assignments every 4 hours." Every prompt unlocked the next question. I wasn't following a tutorial or docs. I was having a conversation, and the system grew from that conversation. You don't need to know the right terminology or how to code. You just need to know your problem well enough to describe it and be willing to iterate when something doesn't work the way you expected. The thinking layer turns automation from "follow these exact rules" into "understand the situation and make a judgment call." Build with heart Community is about people, and we want our people to have the time and energy to show up fully, building with and for the developers in our community. If you want to build something similar, we built c0 with the Chat SDK, a unified TypeScript SDK for building agents across Slack, Teams, Discord, and more. The Guardian uses Vercel Workflows for durable execution. Come share what you build in the community. We're always happy to talk through what we've learned.
Pauline P. Narvas

Ready to deploy? Start building with a free account. Speak to an expert for your Pro or Enterprise needs.

Start Deploying

Talk to an Expert

Explore Vercel Enterprise with an interactive product tour, trial, or a personalized demo.

Explore Enterprise

Get Started

Templates
Supported frameworks
Marketplace
Domains

Build

Next.js on Vercel
Turborepo
v0

Scale

Content delivery network
Fluid compute
CI/CD
Observability
AI GatewayNew
Vercel AgentNew

Secure

Platform security
Web Application Firewall
Bot management
BotID
SandboxNew

Resources

Pricing
Customers
Enterprise
Articles
Startups
Solution partners

Learn

Docs
Blog
Changelog
Knowledge Base
Academy
Community

Frameworks

Next.js
Nuxt
Svelte
Nitro
Turbo

SDKs

AI SDK
Workflow DevKitNew
Flags SDK
Chat SDK
Streamdown AINew

Use Cases

Composable commerce
Multi-tenant platforms
Web apps
Marketing sites
Platform engineers
Design engineers

Company

About
Careers
Help
Press
Legal
Privacy Policy

Community

Open source program
Events
Shipped on Vercel
GitHub
LinkedIn
X
YouTube

Loading status…

Select a display theme:systemlightdark

Build applications with AI

The AI Toolkit for TypeScript

One endpoint, all your models

An agent that knows your stack

AI workflows in live environments

Helping teams ship 6× faster

Content Delivery

Fast, scalable, and reliable

Servers, in serverless form

Trace every step

Scalable bot protection

Invisible CAPTCHA

Platform Security

DDoS Protection, Firewall

Web Application Firewall

Granular, custom protection

Trusted by the best teams

The latest posts and changes

See what shipped

Read the latest news

Join us at an event

Vercel documentation

Linear courses to level up

Find help quickly

Join the conversation

The native Next.js platform

The progressive web framework

The web’s efficient UI framework

Speed with Enterprise scale

Deploy at the speed of AI

Composable Commerce

Power storefronts that convert

Marketing Sites

Launch campaigns fast

Multi-tenant Platforms

Scale apps with one codebase

Ship features, not infrastructure

Extend and automate workflows

Jumpstart app development

Get help from solution partners

Platform Engineers

Automate away repetition

Design Engineers

Deploy for every idea