TechPrufer
Get started
Vercel
Vercel logoVercel · Feature trail

Agent Product Design System

38 posts · Sep 2024 – Aug 2026

What this trail covers

Vercel's Agent Product Design System offers a marketplace for AI agents and services, supporting custom agent development and deployment with unified billing and observability. It includes pre-built agents for specialized workflows and infrastructure services for building custom agents, demonstrating high autonomous resolution rates and significant cost savings in areas like customer support.

All Vercel trails
  1. How our agents build on-brand pages with design.mdThis post details the development of `design.md`, a public file that provides AI agents with consistent brand and design guidance for generating on-brand pages and reports. It describes the three-part system: `design.md` for guidance, a public stylesheet for design primitives, and an evaluation loop for iterative improvement. The post highlights the challenges of subjective design language and the importance of context for AI models, demonstrating how `design.md` and the evaluation process led to more consistent and on-brand outputs. It also introduces the concept of naming recurring generated-design patterns to help agents avoid them.
  2. Introducing Vercel for SlackThis post introduces the integration of Vercel Agent into Slack, enabling users to interact with the AI teammate directly within conversations. The agent can now diagnose issues by investigating logs, metrics, and deployments, propose fixes, and even perform actions like rolling back deployments or updating configurations. These actions are presented as 'plans' that require user approval before execution. The integration aims to streamline the development workflow by keeping discussions and actions within a single conversation context.
  3. Building a software factory for AI SDKThis post details the creation and implementation of the `ai-sdk-factory`, a software factory designed to autonomously process issues and pull requests for the Vercel AI SDK. It describes the decision to build a factory rather than scale human maintainers, the design principles (one agent per task, security from the start, build value locally then move to cloud), and the specific agents developed (classification, bug reproduction, bug fixes, PR reviews, backports, documentation updates, feature analysis, feature implementation). It highlights the use of Vercel Sandboxes for security and the migration to Vercel's managed infrastructure (Functions, Queues, Blob, Sandbox, Postgres). The post also provides a detailed example of the factory processing a community-submitted feature request.
  4. Introducing the new Vercel AgentThis post introduces the Vercel Agent, an AI teammate that investigates production issues, reviews pull requests, traces cost increases, and fixes broken builds. It operates with its own identity ('vercel-agent') and uses a 'plan-to-permission' model where it proposes actions and requires explicit approval before execution. Actions are logged with attribution for the requester and approver. Generated code runs in Vercel Sandbox for isolation and testing. The platform's immutable deployments and rollback capabilities are highlighted as foundational for agent safety. Future capabilities will include delegating to specialized agents.
  5. Automating 90% of support tickets: How we built Vercel's support agent - Ship 26 NYCThis talk details the engineering effort behind Vercel's customer support agent, which achieves 91% autonomous ticket resolution. It covers the agent's loop: enrichment, research, and action, powered by the AI SDK. Key technical components include the AI Gateway for failover and model swapping, Vercel MCP for real-time data integration, and Upstash Search for the knowledge base. The agent was built rapidly by two engineers, demonstrating a cost-effective and highly efficient solution for customer support.
  7. Build an Agent with Eve: The Open Agent Framework - Ship 26 NYC WorkshopThis workshop demonstrates the practical application of Vercel's Eve agent framework by building an agent from scratch. It covers scaffolding an agent using `npx init` and `eve dev`, integrating communication channels like terminal and Slack via Vercel Connect, debugging within the Vercel dashboard, incorporating OpenAPI data into prompts, implementing tools with approval workflows (e.g., MongoDB), setting up evals with deterministic checks and LLM judges, and exploring WebSockets, generative UI, and framework integrations. The architecture is described as a stateless harness on the Workflow SDK. Q&A touches on extensibility, pricing, and competitive positioning.
  8. Build and deploy a Slack Agent to Vercel - Ship 26 NYC WorkshopThis workshop demonstrates the end-to-end process of building and deploying a Slack agent to Vercel. It covers agent creation using Slack's developer tools, local development with hot-reloading for prompt customization, and deployment to Vercel's platform. The session highlights Slack's role as a connective tissue for agent platforms and showcases the ease of deploying functional agents without extensive coding, emphasizing Vercel's role in hosting these agents.
  9. Building the future of fashion x AI with Alta - Ship 26 NYCThis talk showcases Alta, an AI stylist application that has achieved top rankings in app stores. Alta leverages Vercel's platform, including its edge network, serverless functions, image optimization, and preview deployments, to provide a personalized shopping experience. The integration with PUBLIC SCHOOL NYC demonstrates a real-world application of virtual try-on, pre-orders, and pop-up experiences powered by AI and Vercel's infrastructure. The discussion highlights how Vercel's platform enables agentic commerce by connecting consumers with brands through AI-driven styling and virtual try-on capabilities.
  10. CTO panel: Internal apps and agents in production - Ship 26 NYCThis panel discussion explores the practical application of internal apps and AI agents in production environments across various industries (life sciences, real estate, information services). Key themes include the evolving definition of 'who gets to build' with AI accelerators and vertical AI, the security and guardrail challenges of integrating AI agents, and the development of agent workflows that mirror human team structures. The discussion highlights how companies are leveraging AI for tasks ranging from customer support to internal analytics and code generation, emphasizing the need for robust security and thoughtful integration to avoid shadow IT.
  11. Teaching agents product design at VercelThis post introduces the 'product-design' skill for Vercel Agent, which provides coding agents with context behind product and codebase decisions. It details the skill's structure, including references for product judgment, interface quality, resilience, copy, patterns, and exemplars. The post outlines the skill's request modes (shape, implement, review, copy, harden) and the workflow for using it, emphasizing the importance of understanding the 'why' behind product decisions, not just the 'what'. It also describes how the skill routes to canonical sources and specific references based on the task and surface.
  12. 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, emphasizing programmatic and deterministic deployment surfaces like immutable deployments, preview URLs, and instant rollbacks. 2) Infrastructure for building and running agents, detailing Vercel's unified platform for AI primitives including AI SDK, Chat SDK, AI Gateway, Fluid compute, Workflows, Queues, Sandbox, and Observability. 3) Infrastructure that is itself agentic, where the platform can autonomously respond to production anomalies by investigating data, inspecting code, and performing root-cause analysis, moving towards proactive systems that act on behalf of developers.
  13. Agent responsiblyThis post discusses the risks of blindly trusting agent-generated code in production, emphasizing the gap between code that looks correct and code that is safe to ship. It introduces the concepts of 'leveraging' vs. 'relying' on agents, advocating for engineers to maintain complete ownership and understanding of the code. The post outlines Vercel's strategy for 'guarding production' by building closed-loop systems with self-driving deployments, continuous validation, and executable guardrails. It details Vercel's investments in stronger infrastructure guardrails, stricter static checks, production-mirroring staging tests, read-only agents for invariant verification, and defect-commit vs. defect-escape ratio metrics. The core message is to leverage agents while owning the risk, with a call to action for engineers to ask critical questions about their code's impact before shipping.
  14. Build knowledge agents without embeddingsThis post introduces a file-system-based approach for building knowledge agents, replacing traditional vector database and embedding model pipelines. It leverages Vercel Sandbox for executing filesystem commands (`grep`, `find`, `cat`) and the AI SDK for tool integration. The template supports multi-platform deployment via Chat SDK and includes built-in admin tools and an AI-powered admin agent for debugging. The core technical contribution is the shift from semantic similarity search to direct filesystem interaction for knowledge retrieval, improving cost and debuggability.
  15. Chat SDK brings agents to your usersIntroduces the Chat SDK, a TypeScript library that enables agents to be deployed across multiple chat platforms (Slack, Microsoft Teams, Google Chat, Discord, Telegram, GitHub, Linear, WhatsApp) from a single codebase. It abstracts platform-specific API differences through adapters, handles event routing, application logic, and provides pluggable state adapters (Redis, PostgreSQL). The SDK supports streaming AI responses directly and renders common UI elements like tables, cards, modals, and buttons in platform-native formats. It also includes specific adapters for WhatsApp with support for messages, reactions, multimedia, and location sharing.
  16. Building Slack agents can be easyThis post introduces the `vercel-labs/slack-agent-skill` and `vercel-partner-solutions/slack-agent-template` which automate the creation and deployment of Slack agents. The skill wizard guides users through project setup, Slack app creation (including manifest customization, OAuth scopes, and event subscriptions), environment configuration (signing secret, bot token, API keys), local testing, and production deployment on Vercel. It leverages the Workflow SDK for durable execution and AI Gateway for model access. The template includes pre-built tools for Slack interaction and allows for custom tool integration. The post also highlights the benefits of streaming responses, human-in-the-loop approval, and active CPU billing.
  17. Security boundaries in agentic architecturesThis post introduces a security architecture for agentic systems by defining four actors (agent, agent secrets, generated code execution, filesystem) and advocating for distinct security boundaries between them. It proposes separating agent compute from generated code execution using microVMs and credential brokering proxies to mitigate risks from prompt injection and credential theft. Architectures discussed include zero boundaries, secret injection without sandboxing, and separating agent compute from sandbox compute.
  18. Skills Night: 69,000+ ways agents are getting smarterThis post details the growth and impact of the 'skills.sh' ecosystem, which acts as a package manager for AI agent context. It highlights the rapid adoption (69,000+ skills, 2 million CLI installs) and the security measures being implemented through partnerships with Gen, Socket, and Snyk to audit skills. The post also showcases how skills are enabling agents to overcome training data cutoffs, drive full-stack development (e.g., native iOS features), and are becoming a foundational primitive for tools like Mintlify and Sentry for static analysis.
  19. How we built AEO tracking for coding agentsThis post details the engineering effort to build a system for tracking and analyzing the behavior of coding agents. Key contributions include: 1. Designing a six-step lifecycle for running agents in isolated Vercel Sandbox MicroVMs (creation, CLI installation, credential injection, execution, transcript capture, teardown). 2. Implementing a configuration-driven approach to define agents and their setup/execution commands. 3. Routing agent LLM calls through Vercel AI Gateway for unified logging, rate limiting, and cost tracking by overriding provider base URLs via environment variables. 4. Developing a four-stage normalization layer to handle diverse agent transcript formats: transcript capture (agent-specific), parsing (tool name and message shape normalization), enrichment (extracting structured metadata), and aggregation into a unified brand pipeline. Specific technical details include handling JSONL and stdout transcripts, mapping agent-specific tool names to canonical ones, and flattening varied message structures.
  20. Introducing the new v0This post details the evolution of v0 from a novelty "vibe coding" tool to a production-ready platform. Key technical contributions include: a sandbox-based runtime that imports GitHub repos to work on existing codebases, automatically pulling environment variables and configurations from Vercel; a Git panel that allows for creating branches, opening PRs, and deploying on merge, enabling non-engineers to ship production code through proper Git workflows; secure integrations with Snowflake and AWS databases for building custom reporting and data apps; and built-in enterprise-grade security features like deployment protection and access controls, leveraging Vercel's platform security.
  21. AGENTS.md outperforms skills in our agent evalsThis post introduces a new approach for providing framework-specific knowledge to AI coding agents by embedding a compressed documentation index directly into `AGENTS.md`. This method achieved a 100% pass rate in evaluations for Next.js 16 APIs, significantly outperforming the use of 'skills' which only achieved a 79% pass rate even with explicit instructions. The key advantages identified are the elimination of agent decision points for knowledge retrieval, consistent availability of context, and avoidance of ordering issues inherent in active retrieval systems. The post also details the compression techniques used to keep the `AGENTS.md` file size minimal (8KB) and provides a codemod for easy implementation.
  22. Agent skills explained: An FAQThis post introduces and explains 'agent skills,' a new open format for packaging reusable instructions, context, and decision-making logic for AI agents. It details how skills solve problems like prompt drift, lost workflow conventions, and instruction sprawl by providing a centralized, versionable, and discoverable mechanism for agent expertise. The post compares skills to MCP servers, tools, rules, and system prompts, highlighting their complementary roles. It provides examples of skills in various domains (React, Postgres, Copywriting, Remotion), explains the structure of a skill package (SKILL.md, scripts, references), and outlines installation methods (local directory, CLI) and discovery via skills.sh. It also describes how agents load and use skills, and the process for creating custom skills.
  23. Testing if "bash is all you need"This post evaluates the effectiveness of different abstractions (SQL, bash, filesystem) for AI agents querying structured data. It details an evaluation harness, compares the performance and accuracy of SQL, bash, and filesystem agents, identifies performance bottlenecks in bash tools (e.g., `stat()` calls), and proposes a hybrid approach combining SQL and bash for improved accuracy and self-verification. It also highlights the importance of robust evaluation methodologies and the iterative improvement of tools like `just-bash`.
  24. How we made v0 an effective coding agentIntroduced a multi-step agentic pipeline for the v0 coding agent, comprising a dynamic system prompt, LLM Suspense for real-time streaming manipulation, and autofixers. The dynamic system prompt injects up-to-date knowledge about SDKs and provides filesystem examples. LLM Suspense handles tasks like URL shortening and icon name resolution during streaming. Autofixers address more complex issues by analyzing ASTs and using fine-tuned models for repairs like wrapping hooks and completing dependencies.
  25. Stopping the slow death of internal toolsIntroduces the v0 AI agent, which allows business users to build and deploy internal tools by describing their requirements. These tools are built on the Vercel platform, leveraging its secure-by-default environment, automatic access control, secure integration capabilities, and guardrails against accidental exposure. The post highlights examples of internal tools built with v0, such as sales forecasting, marketing lead list import, and custom event marketing pages, and emphasizes the simplified maintenance and reversibility of changes for these applications.
  26. AI SDK 6AI SDK 6 introduces a new `Agent` abstraction for building reusable agents, including `ToolLoopAgent` for production-ready tool execution loops and `callOptionsSchema` for type-safe arguments. It enhances code organization and UI integration with end-to-end type safety. Custom agent implementations are supported via the `Agent` interface, enabling durable and resumable workflows with `DurableAgent`. Tool improvements include `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 also include DevTools for debugging agent interactions, reranking, standard JSON schema support, image editing capabilities, raw finish reason & extended usage reporting, a LangChain adapter rewrite, and new provider tools.
  27. We removed 80% of our agent’s toolsThis post details a significant architectural shift in Vercel's AI agent (d0), moving from a complex, multi-tool approach to a simplified model that directly interacts with the file system using standard Unix commands (`grep`, `cat`, `ls`). This change resulted in a 3.5x faster execution time, a 20% increase in success rate (from 80% to 100%), a 37% reduction in token usage, and a 42% decrease in steps. The core technical contribution is the demonstration that a powerful semantic layer, when made directly accessible to a capable LLM (Claude Opus 4.5), can serve as a more effective and less fragile interface than a custom-built, tool-heavy agent architecture. The post highlights the use of Vercel Sandbox for file system execution and Vercel Gateway for routing and observability.
  28. Build smarter workflows with Notion and v0This post details the integration of v0 (an AI agent for building UI) with Notion. This allows v0 to access and utilize data from Notion databases and documents to generate dashboards, prototypes, and workflows. The integration also supports write access, enabling v0 to update Notion pages with generated content or summaries. This enhances the agent's ability to ground its output in existing team context and contribute back to knowledge bases.
  29. How to prompt v0Introduces a structured prompt framework for v0, comprising three key inputs: product surface, context of use, and constraints & taste. Provides examples and test results demonstrating how this framework leads to faster generation times, smarter UX decisions, and cleaner code. This directly impacts the agent's ability to generate more accurate and efficient UI components.
  30. How we built the v0 iOS appThis post details the technical implementation of the v0 iOS app, focusing on its chat experience built with React Native and Expo. It covers composable chat architecture using context providers and custom hooks, animations for message entry and streaming using React Native Reanimated, keyboard handling with React Native Keyboard Controller, and native UI element integration. It also discusses code sharing between web and native platforms.
  31. Self-driving infrastructureThis post introduces the concept of 'self-driving infrastructure' where AI agents autonomously manage production operations, improve application code using real-world insights, and learn from production behavior. It builds upon framework-defined infrastructure and the Vercel AI Cloud, with Vercel Agent as the first step towards fully autonomous cloud operations. Agent investigates anomalies, runs observability queries, performs root-cause analyses, and conducts AI code reviews in isolated sandboxes before deployment. It aims to close the production-to-code feedback loop by generating pull requests based on production data to improve stability, security, and performance.
  32. What we learned building agents at VercelThis post details Vercel's internal methodology for identifying and building high-ROI agentic AI projects, focusing on tasks with low cognitive load and high repetition. It introduces two internal use cases: a lead processing agent that automates initial qualification and email composition, and an anti-abuse agent that analyzes URLs for phishing or copyright content and recommends actions. The post also highlights open-sourced agent templates for lead processing, data analysis, flight booking, and a Slack storybot, and mentions a hands-on program for guided agent implementation.
  33. Vercel Agent can now run AI investigationsThis post details the expansion of Vercel Agent's capabilities to include automated incident response and root cause analysis. It introduces the 'Investigations' skill, which leverages anomaly detection and correlation analysis across build and runtime data to identify issues. The agent provides impact assessments and actionable recommendations for remediation. This builds upon the existing Vercel Agent functionality for code reviews and integrates with Observability Plus for anomaly alerts.
  34. AI agents and services on the Vercel MarketplaceIntroduced a new category in the Vercel Marketplace for AI agents and services. This marketplace provides two types of offerings: pre-built agents that perform specialized tasks (e.g., CodeRabbit, Corridor, Sourcery) and infrastructure services that enable the creation of custom agents (e.g., Autonoma, Braintrust, BrowserUse, Chatbase, Descope, Kernel, Kubiks, Mixedbread). All marketplace integrations offer unified billing and observability within the Vercel platform.
  35. Introducing Vercel Agent: Your new Vercel teammateThis post introduces Vercel Agent, an AI teammate for development workflows, with two core skills: Code Review and Investigations. Code Review provides AI-powered pull request reviews by analyzing code, dependencies, and framework patterns, validating suggestions in a Vercel Sandbox before presenting them. Investigations offer AI-powered debugging for production issues by analyzing runtime data to uncover root causes and suggest actionable next steps. The agent is described as a 'teammate' that understands the stack, context, and goals, built on the same infrastructure as Vercel itself. It is positioned as the first product in the 'Agent-as-a-Service' category.
  36. Collaborating with Anthropic on Claude Sonnet 4.5 to power intelligent coding agentsThis post introduces the integration of Claude Sonnet 4.5 into Vercel's AI Gateway and AI SDK, highlighting its performance improvements for agentic coding workflows, particularly with Next.js applications. It details specific metrics for Next.js builds and linting, and improvements in v0 for frontend design and complex prompt handling. The post also announces the release of an open-source Coding Agent Platform template that defaults to Claude Code agent using Claude Sonnet 4.5, enabling agents to plan, execute, and commit changes within repositories. The template runs on Vercel Sandbox for isolated execution and Fluid Compute for scalability, with Active CPU pricing. The contribution focuses on showcasing the practical application of an advanced LLM for automated software development tasks and providing a reference implementation for developers.
  37. Addressing security & quality issues with MCP tools - VercelIntroduced `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 reliability problems (upstream drift, generic descriptions) associated with dynamic MCP tool definitions in production AI agents. The tool allows for vendoring tool definitions into the codebase, enabling version control, selective loading, customization, and improved reliability by locking schemas and descriptions.
  38. AI-powered prototyping with design systemsThis post introduces the concept of AI-native design systems and how they enable more effective AI prototyping with tools like v0. It highlights the importance of design systems providing context to AI models, focusing on `shadcn/ui` as an example of a design system built with AI in mind. Key aspects discussed include open components, composable APIs, token-based styling, and the use of registries for sharing and contextualizing design systems for both humans and machines. It also touches on how v0's design mode and the Model Context Protocol (MCP) leverage these AI-native design systems.
  39. Proposal for inline LLM instructions in HTML based on llms.txtIntroduces a new convention, `<script type="text/llms.txt">`, for embedding LLM instructions directly within HTML responses. This convention leverages the browser's behavior of ignoring unknown script types to embed LLM-specific content without affecting regular rendering. The proposal is based on the `llms.txt` standard and aims to provide agents with in-band instructions on how to access protected resources, such as Vercel preview deployments, by referencing available MCP server functions or bypass token mechanisms.
  40. v0.dev -> v0.appThis post announces the rebranding of v0.dev to v0.app and highlights its evolution into an agentic AI builder. It emphasizes the capability of v0.app to go from a single prompt to a deployed full-stack application, including UI, content, backend, and logic. Key advancements include the AI's ability to research, reason, debug, and plan, handle complexity across all aspects of an app, and maintain security. New functionalities demonstrated include automatic error checking, design inspiration generation, web searching with citations, step-by-step planning, file reading, web inspection, to-do management, and integration implementation.
  41. Introducing Vercel MCP: Connect Vercel to your AI toolsIntroduces Vercel MCP (Model Context Provider) server, a public beta feature enabling secure, OAuth-compliant interaction between AI clients and Vercel projects. MCP servers expose tools for AI models to call external systems. Vercel MCP provides tools for searching Vercel docs, retrieving deployment logs, and fetching team/project metadata. It supports the MCP specification for tools and prompts, and adheres to Authorization and Streamable HTTP specifications. Security measures include a read-only initial launch, an allowlist of approved clients, and OAuth consent screens to prevent the Confused Deputy problem. The post also outlines general MCP security guidance and Vercel MCP-specific recommendations.
  42. v0: vibe coding, securelyThis post details how v0, Vercel's AI-powered UI generation tool, incorporates security guardrails to prevent common AI-generated code vulnerabilities, such as exposed secrets and misuse of public variables, by applying automated, context-aware security checks during generation and before deployment. It also highlights Vercel's platform-level security features like the Vercel Firewall and secure inference via Vercel AI Gateway, ensuring secure defaults from prompt to deployment.
  43. Transforming customer support with AI: How Vercel decreased tickets by 31%This post details Vercel's internal implementation of an AI agent for customer support. Key technical contributions include: the use of an AI-powered agent leveraging a Large Language Model (LLM) and a multi-source knowledge base (website content, documentation, Next.js examples, help articles); integration with existing support workflows, replacing the support form with an open-ended question; the ability for the AI to engage in follow-up questions and smoothly transition to human support by pre-filling a support form; and the use of Edge Middleware for A/B testing the AI implementation, resulting in a 16% reduction in support tickets during the test period.