Full-Time

Development Representative

Startups

Vercel

Vercel

501-1,000 employees

Cloud-based rendering platform for web apps

Compensation Overview

$100k/yr

San Francisco, CA, USA

Hybrid

In-office anchor days: Monday, Tuesday, and Friday in San Francisco.

Category
Sales & Account Management (1)
Required Skills
Sales
Marketing
Web Development
Requirements
  • Passion for web development and staying current with the latest trends and technologies
  • Familiar with the Startups culture & interested in working directly with founders
  • 1+ years of experience in a technical, sales, or customer support role for a technical product
  • Excellent communication skills — ability to explain complex technical concepts to both technical and non-technical stakeholders
  • Strong problem-solving abilities and attention to detail
  • Self-motivated and able to work independently while also collaborating effectively with cross-functional teams
Responsibilities
  • Identify and engage high-potential companies that could benefit from Vercel’s platform
  • Research prospects and tailor outreach to engineering, product, and marketing leaders
  • Generate outbound opportunities through personalized outreach
  • Partner with Account Executives to build pipeline and drive adoption in the Startups segment
  • Collaborate cross-functionally with Marketing, Sales Engineering, and Customer Success to refine messaging and improve outreach effectiveness
Desired Qualifications
  • Background in computer science, web development, or a related technical field
  • Vercel, Next.js, or any other technical background or understanding
  • Salesforce, Outreach, or similar
  • Experience as an SDR or other similar relevant positions

Vercel provides a platform for building, deploying, and managing modern web applications. It runs a managed, global rendering layer that handles serverless execution so content is delivered quickly anywhere without extra infrastructure. It also offers AI-powered media tools for automatic tagging, smart cropping, context-based transformations, and lifecycle management (auto-tagging, access control, and admin roles). The platform integrates hosting, deployment, routing, and security (automatic HTTPS, encryption, DDoS protection, firewalls) in one service. This makes Vercel different from competitors by offering a unified, globally distributed hosting and rendering stack with built-in AI-enabled media workflows, trusted by millions of developers and thousands of enterprises. The goal is to help developers and businesses ship fast, secure web apps at scale with scalable hosting and AI-assisted media management.

Company Size

501-1,000

Company Stage

Series F

Total Funding

$863M

Headquarters

San Francisco, California

Founded

2015

Your Connections

People at Vercel who can refer or advise you

Simplify Jobs

Simplify's Take

What believers are saying

  • Agent deployments already exceed half of Vercel traffic.
  • Vercel Connect and enterprise controls reduce credential and governance friction.
  • Vercel Services keeps full-stack agent apps inside one secure project.

What critics are saying

  • Open-source eve increases competition with frameworks from Anthropic, LangGraph, and LangChain.
  • Agentic automation raises approval, security, and blast-radius requirements for regulated buyers.
  • Heavy dependence on Vercel's platform deepens lock-in for durable workflows and sandboxes.

What makes Vercel unique

  • Vercel unifies AI SDK, Gateway, Sandbox, Workflows, and Chat SDK.
  • eve frames agents as directories, mapping files to tools and capabilities.
  • Vercel Agent closes the loop with production traces and approval-based fixes.

Help us improve and share your feedback! Did you find this helpful?

Benefits

Health Insurance

Stock Options

Company Equity

Professional Development Budget

Unlimited Paid Time Off

Remote Work Options

Home Office Stipend

Growth & Insights and Company News

Headcount

6 month growth

1%

1 year growth

1%

2 year growth

0%
Honra
Jun 17th, 2026
Vercel's eve: an open-source agent framework built for production.

Vercel's eve: an open-source agent framework built for production. Vercel just open-sourced eve, the framework it uses to run more than 100 agents internally. Its pitch is simple: an agent is a directory, tools are files, and the production plumbing comes built in. Here is what eve actually does, why it matters, and how to think about adopting it. At its Ship conference on June 17, 2026, Vercel released eve, an open-source framework for building, running, and scaling AI agents. The framing in the announcement is direct: "Agents today are where the web was before frameworks, with everyone hand-rolling the same plumbing." eve is Vercel's attempt to do for agents what Next.js did for the web, which is to standardize the repetitive infrastructure so teams can focus on what their agent actually does. That comparison is worth taking seriously, because it is the same company making it about its own most successful product. It is also worth scrutinizing, because the hardest parts of shipping an agent are rarely the parts a framework solves. This post breaks down what eve is, what comes built in, the larger bet it sits inside, and how technology leaders should think about adopting it. What eve actually is. eve is filesystem-first. An agent is a directory, and the files inside it map directly to capabilities. There is no separate wiring layer to maintain. agent/ agent.ts # model configuration instructions.md # system prompt and personality tools/ # custom capabilities (one file per tool) skills/ # markdown knowledge files subagents/ # delegated agents channels/ # Slack, Discord, HTTP, and more schedules/ # cron-style triggers The configuration surface is deliberately small. A working agent can be as little as a model declaration: import {defineAgent} from "eve"; export default defineAgent({ model: "anthropic/claude-opus-4.8",}); Tools are single TypeScript files with typed input validation and an async execute function. Skills are markdown files that teach the agent domain rules and context. Subagents are child agents the parent can delegate to, each with its own instructions and tools. The result is that an agent reads like a project rather than a tangle of glue code, and the structure is the same regardless of which team built it or what it does. eve is open source on GitHub under an Apache-2.0 license, and a project scaffolds in under a minute with npx eve@latest init. What comes built in. The configuration is the easy part. The reason eve is interesting is the set of production concerns it handles by default, the work most teams discover they need only after their prototype meets real traffic. Six capabilities stand out. * Durable execution. Conversations checkpoint at each step, so a session can survive a crash, a deploy, or a long pause and resume exactly where it stopped. This is built on Vercel's open-source Workflow SDK. * Sandboxed compute. Agent-generated code is treated as untrusted. Every agent gets its own isolated sandbox for shell commands, scripts, and file access, running on Vercel Sandbox in production and Docker locally. * Human-in-the-loop approvals. Any action can be flagged to require a human sign-off. The agent pauses there indefinitely without burning compute, which matters for anything that touches money, customer data, or production systems. * Subagents. A parent agent can hand work to specialized child agents, each scoped to its own tools and instructions, instead of stuffing every capability into one prompt. * Evals. Scored test suites validate agent behavior locally, in CI, or against a deployed agent, so a change that quietly breaks behavior gets caught before it ships. * Multi-channel deployment. One agent can run across Slack, Discord, Teams, Telegram, Twilio, GitHub, Linear, and plain HTTP without rebuilding it per surface. For observability, eve exports OpenTelemetry traces to the tools teams already run, including Datadog, Honeycomb, and Jaeger, and a local eve dev server shows every model call, tool execution, and skill load as it happens. Each of these is solvable on its own. The argument eve makes is that solving all of them, the same way, on every agent, is the part that does not carry over from one project to the next. How it connects to the rest of your Stack. An agent is only useful if it can reach real systems. eve connects through Model Context Protocol servers, any OpenAPI document, and Vercel Connect, which replaces long-lived credentials with short-lived tokens and ships with pre-built integrations for Slack, GitHub, Snowflake, Salesforce, Notion, and Linear. The model layer is configurable through Vercel's AI Gateway, with fallback providers, so the anthropic/claude-opus-4.8 in the example above is a default rather than a lock-in. The larger bet. eve did not launch alone. Vercel positioned it as the framework on top of an "Agent Stack" that bundles its existing pieces: the AI SDK, AI Gateway, Vercel Sandbox, the Workflow SDK, and the Chat SDK. CEO Guillermo Rauch used the launch to argue that the company is becoming infrastructure for the "agent era," and he brought numbers. Vercel says agent-triggered deployments grew from under 3% of commits to more than 50% in six months, and token volume through its AI Gateway rose from 2 million to 20 million. The most credible evidence is that Vercel runs eve itself. The company says it operates more than 100 agents in production on the framework, including a data analyst that fields over 30,000 Slack questions a month, a support agent it credits with resolving 92% of tickets autonomously, and a revenue-operations agent built by non-engineers in six weeks. Treat the specific figures as vendor claims, because they are. But a framework its maker depends on at that scale is a different proposition from one shipped as a demo. How to think about adopting it. eve is a strong piece of engineering, and for teams already on Vercel it lowers the cost of getting an agent to production in a real way. The decision to use it, though, sits downstream of harder questions that no framework answers for you. The first is whether the agent should exist at all. The documented failure mode for agentic AI is not bad plumbing. It is automating a workflow that was never worth automating, or handing autonomy to a process that needed a form. eve makes building faster, which makes building the wrong thing faster too. The second is lock-in, and it cuts both ways. The framework is open source and the model layer is portable, both genuine. But the production story, durable execution, sandboxing, and the dashboard, is most seamless on Vercel's own platform. That is a reasonable trade for many teams and a dealbreaker for a few. It is a decision to make deliberately, with eyes open, not one to back into because the scaffolding was convenient. The third is governance. The approval gates, eval suites, and OpenTelemetry traces eve provides are the right primitives. They are not a policy. Who approves what, what an agent is allowed to touch, and how you prove after the fact that it behaved are organizational decisions the framework can enforce but cannot make. How this maps to how Honra works. At Honra Honra Llc. sit on the client's side of these decisions. Honra Llc. do not resell frameworks or take a margin on the tools a client adopts, so its read on eve is the same one Honra Llc. would give privately: it is a serious option, well suited to teams already invested in Vercel, and the framework choice is the smallest of the choices in front of you. The work Honra Llc. care about is the work eve does not do. Deciding which processes deserve an agent and which deserve a fix elsewhere. Setting the governance and approval model before the first agent ships, not after an incident. Building the thing directly when that is the right call, with the same judgment Honra Llc. bring to advising on it, and working alongside the implementers a client already has when it is not. eve removes a real category of busywork from that build. It does not remove the judgment, and that is the part worth getting right. Key takeaway. eve is Vercel making a credible claim that the production infrastructure of AI agents can be standardized the way web infrastructure was, backed by a framework it runs at scale on itself. For teams building agents, especially on Vercel, it is worth a serious look. Just keep the order of operations straight: decide whether the agent should exist, how it will be governed, and what you are willing to depend on, and only then decide which framework builds it.

AI Weekly
Jun 7th, 2026
OpenAI, Vercel hit in dev tool supply-chain breach.

OpenAI, Vercel hit in dev tool supply-chain breach. Key insights. * DOGE uploaded a live Social Security database to an unsecured third-party server, potentially affecting most living Americans' Social Security numbers. * ShinyHunters breached Instructure's Canvas (30+ million students), Charter Communications (40 million records), and Carnival Cruises (6 million records) in a single campaign. * Compromised dev tools Trivy, Bitwarden, and Checkmarx served as the supply-chain route to breach OpenAI and Vercel via stolen credentials. Why this matters. The supply-chain breach reaching OpenAI and Vercel via compromised developer tools Trivy, Bitwarden, and Checkmarx shows that AI companies' attack surfaces now run through every tool in the dev workflow, not just their own perimeter. The DOGE/Social Security incident demonstrates what happens when government data initiatives operate outside standard security review: an unsecured third-party server becomes the single point of failure for most living Americans' Social Security numbers. Iranian hackers' ability to remotely wipe tens of thousands of devices at Stryker Medical in a single March operation signals that destructive attacks on enterprise infrastructure are now viable at the scale AI companies operate. Summary. Six months into 2026, the year's security incidents have crossed from embarrassing to structurally alarming. DOGE uploaded a live Social Security database to an unsecured third-party server, what two House Democrats said 'could very well be the largest data breach in its nation's history.' Attackers also compromised dev tools Trivy, Bitwarden, and Checkmarx to reach OpenAI and Vercel downstream via harvested credentials. Essentially: (DOGE, ShinyHunters, Iranian state actors) each found a different gap in 2026's first half. - ShinyHunters hit Canvas (30+ million students), Charter (40 million records), and Carnival (6 million records). - Iranian hackers remotely wiped tens of thousands of devices at Stryker Medical in March. Developer tooling is now a primary attack surface for reaching AI infrastructure, not a secondary one. Potential risks and opportunities. Risks. * OpenAI and Vercel face regulatory scrutiny and customer trust damage if the supply-chain credential exposure is confirmed to have reached customer data or internal model infrastructure. * ShinyHunters' 40 million Charter Communications records and 6 million Carnival records create a large downstream pool for phishing, SIM-swap, and identity fraud campaigns. * The DOGE/SSA database exposure may trigger congressional investigations that freeze or complicate broader government AI and data-sharing initiatives well into 2026. Opportunities. * Developer security toolchain vendors (Snyk, Chainguard, Endor Labs) stand to see budget unlocked at enterprises reassessing trust in open source security tools like Trivy and Checkmarx after this supply-chain breach. * Identity verification companies can pitch increased rigor to hotels, money transfer apps, and government visa portals following the exposure of over two million passport and driver's license scans across those channels. * Cyber insurers with AI infrastructure and developer-toolchain coverage (Coalition, At-Bay) can reprice policies upward given demonstrated supply-chain reach into major AI vendors like OpenAI and Vercel. What Aiweekly don't know yet. * Whether credentials harvested from Trivy, Bitwarden, and Checkmarx have been fully rotated across all affected downstream companies beyond OpenAI and Vercel. * What data was actually exfiltrated from OpenAI via the supply-chain route, and whether any model weights or training data were accessed. * Whether U.S. water utilities have acted on the Iranian targeting warnings, given the article mentions no enforcement mechanism tied to the advisory. Shared on Bluesky by 1 AI expert. Originally reported by techcrunch.com Original headline: TechCrunch Mid-Year Security Roundup: DOGE/SSA, Instructure Canvas (30M Students), and OpenAI Supply-Chain Compromise Among 2026's Worst Breaches

Accel
May 21st, 2026
Accel co-leads Vercel's Series F as AI developer platform doubles ARR

Accel has co-led Vercel's Series F funding round, five years after leading the company's Series A in 2020. Founded by CEO Guillermo Rauch, Vercel has evolved from a frontend development platform into essential AI infrastructure for enterprises. The company's AI development agent v0 transforms ideas into products with enterprise guardrails, whilst its AI Cloud provides scalable infrastructure for intelligent applications. Vercel's open-source framework Next.js powers major brands including AT&T, Nike and Walmart. Over the past year, Vercel has doubled both its annual recurring revenue and user base. Enterprise clients like Brex, MercadoLibre, Upwork and Zapier now comprise over 50% of v0 revenue. The company has successfully transitioned from product-led growth to serving large organisations whilst maintaining its thriving Next.js open-source community.

Andre Landgraf
May 20th, 2026
Two types of agents.

Two types of agents. May 20, 2026 I've noticed that when developers talk about "agents", Andre Landgraf is often talking about different things: Claude Code running in a sandbox vs. an agentic endpoint inside a web app. It's a spectrum but I think Andre Landgraf can distinguish two types of agents by now and they're running on different infra and abstraction levels. Before agents: an AI endpoint. The thing both types sit on top of is LLM API calls. Vercel AI SDK example: typescript import {generateText} from "ai"; const {text} = await generateText({ model: "openai/gpt-5", system: "You are a comedian.", prompt: "Tell me a joke.",}); Here Andre Landgraf call an LLM endpoint (OpenAI GPT-5 in this case) w/ a static prompt. Not quite an agent. How do LLM API calls turn into agents? You provide your model calls with a harness: * Dynamic input prompts so the LLM reacts to updates in the real world (e.g., user request). * Tools so the model can take real actions instead of only producing text (tools: {getWeather: ...}). * An agent loop so the model can call a tool, see the result and call another (stopWhen: isStepCount(5) or whatever stop condition you pick). * Persistent context so the model holds onto something between calls: conversation history, user preferences, prior decisions, the state of a task, etc. For this, Vercel's AI SDK introduced ToolLoopAgent - a small declarative agent abstraction on top of single-step calls like generateText. typescript import {ToolLoopAgent} from "ai"; const agent = new ToolLoopAgent({ model: "anthropic/claude-sonnet-4.5", instructions: "You are a helpful assistant.", tools: {weather: weatherTool, calculator: calculatorTool,},}); const result = await agent.generate({ prompt: "What is the weather in NYC?",}); console.log(result.text); This leads Andre Landgraf to its first agent type. Type 1: declarative agents. The first type is what the modern TypeScript and Python agent frameworks ship: a declarative Agent constructor that wraps the AI endpoint with a system prompt, a tool set and a memory/context abstraction. Mastra, the OpenAI Agents SDK (JS) and the AI SDK's ToolLoopAgent (v6+) all look similar here. Mastra example - almost identical to the AI SDK example above: typescript import {Agent} from "@mastra/core/agent"; import {Memory} from "@mastra/memory"; import {createTool} from "@mastra/core/tools"; import {z} from "zod"; const lookupCustomer = createTool({ id: "lookup-customer", description: "Look up a customer by email.", inputSchema: z.object({ email: z.string.email, execute: async ({input}) => fetchCustomer(input.email),}); export const supportAgent = new Agent({ name: "Support Agent", instructions: "You handle billing questions. Use tools to look up data.", model: "openai/gpt-5", memory: new Memory, tools: {lookupCustomer},}); You handcraft the tools to operate on the business entities that matter. You hand-tune the prompt and configure a memory system. The dev workflow looks similar to building any other type of backend service. In fact, declarative agents are usually integrated in existing (web) applications and are what makes them agentic. What defines these agents? They run inside your app or a similar JavaScript/Python platform (e.g., Mastra Platform, Next.js server endpoint, etc.) - the same way an HTTP handler does. This is how most agents looked like until end of last year. But then OpenClaw broke the internet for a few weeks... Type 2: sandbox agents. The second type sits at the other end of the spectrum. Instead of a curated set of business tools, these agents have direct access to the system they live on. That means the filesystem, bash, the network and sometimes a full browser. Coding agents are the obvious examples: Claude Code, the Cursor CLI, the Codex CLI. You interact with them through a terminal (or an IDE) and they write to the file system, write & execute code and curl the web. Of course, you can still decide how much access you want to give these agents but the tendency is full system access for maximum convenience and utility. The defining feature is that they don't have to wait for you to write a tool. They already have grep, curl, bash, sed, the package manager, etc. If a task needs a new capability, the agent often just writes itself a script and executes it ad-hoc. More extreme, these agents can be allowed to iterate on themselves and their own configuration and capabilities. Claude Code reads CLAUDE.md and skills/* and if you allow it, it can edit those files between turns. Pi takes this further by design: it's a minimal coding harness whose own primitives (extensions, skills, prompts, themes) the agent can rewrite on the fly and hot-reload. And of course, OpenClaw introduced the concept of SOUL.md that you and OpenClaw iterate on together to personalize your AI assistant. Where declarative agents running in a Bun/Node.js app runtime come with maximum control and precision over the intended use, sandboxed agents trade developer control and precision for creativity. They are ideal for generic knowledge work such as coding. Hybrids. Of course these are two ends of a spectrum. In a hybrid setup you can define a declarative agent with a tool that provisions & exposes a VM so that the agent can ssh into a sandbox on demand. The agent itself runs in an app runtime with app-like control over tracing, context and tools but a generic sandbox tool allows the agent to access a remote environment with access to bash, code execution, file system and more. It can't quite edit itself but it can still perform generic knowledge work that way. An example of such a hybrid architecture is v0, a coding agent platform by Vercel. It runs on Workflow Development Kit on Next.js (declarative agent) but each coding agent instance also has access to a sandbox to execute the code-generated code. That's also the architecture Vercel is recommending when using the AI SDK and Vercel Sandboxes together - blog post here. Conclusion. Claude Code in a sandbox vs. the agentic endpoint in my web app - You need both. I just shipped homebrewtales.com - a table-top app. Here I run Claude Code for atmospheric music generation (writes Python, uploads an MP3, done) in sandboxes on Vercel. However, I also host a few agents on Mastra for the in-game game-master and player companions (session memory, character sheet access, a handful of DnD tools like roll dice or post to session chat). You don't want your legal-review agent to override its own SOUL.md file but you also need your coding agent to be creative, compose CLIs and access a browser. Pick the type that fits the task and you'll likely find use cases for both declarative and generic agents. Happy coding!

OSBytes
May 14th, 2026
Turborepo 2.9.14 patches VS Code extension command injection.

Turborepo 2.9.14 patches VS Code extension command injection. Vercel shipped Turborepo v2.9.14 today. Under the CI and docs churn sits a blunt security note worth catching even if your monorepo never touches turbo on the CLI: the VS Code Turborepo / LSP extension carries fixes for multiple advisories, and the headline item is GHSA-5xc8-49mv-x4mm (CVE-2026-46508, rated High). Where the hole actually lived. Upstream's wording is sober. Older extension builds routed some daemon and task-runner work through string-shaped shell commands. Values that a repo can steer (workspace configuration, names of tasks surfaced from the codebase) fed into those strings. Activate the extension against a hostile clone, or run a task through the extension UI after those values loaded, and the host shell could interpret the payload as arbitrary commands running with whatever rights the VS Code process already has. This is classic "IDE extension meets untrusted workspace" territory. The precondition is simpler than chasing a zero-day broker: convincing someone to open your repo locally plus enough interaction that the extension does its job. What changed in practical terms. GitHub lists the patched band as >= 2.9.14000 for the Turborepo LSP package and summarizes the remediation as ditching brittle shell interpolation (execFile with explicit argv for daemon hooks, structured terminal launches for tasks), marking Turborepo executable knobs so machines, not workspaces, decide where binaries live, and shutting the extension down inside VS Code's untrusted-workspace mode until the user explicitly trusts the folder. If you cannot update yet, the advisory's fallback is also simple: do not run the extension against repositories you do not trust, and avoid driving Turborepo tasks from the extension until you are on a fixed build. The rest of the tag (fast). The same release line also documents two Low issues: a login-callback hardening pass (GHSA-hcf7-66rw-9f5r) and a cleanup so Yarn Berry detection does not execute surprise project-local binaries (GHSA-3qcw-2rhx-2726). Worth skimming if you manage developer laptops, but the extension command path is the one that should interrupt dinner. What to do on a team laptop. * Update the Turborepo VS Code extension to the build that ships with 2.9.14 (or newer once it exists), then verify the Marketplace / Open VSX sidebar shows that version lineage. * If you automate editor rollouts through an internal marketplace mirror, bake the patched extension artifact into whatever approval queue you already use for Chromium or Docker Desktop updates. Malicious repo input that reaches a shell inside VS Code predates Turborepo; this extension is catching up to the execution style hardened tools adopted after earlier wake-up calls in the same class of bug.