Workers for Agents: What Notion’s Code Execution Layer Means for Builders

Anchor fact: Workers for Agents is in developer preview as of April 2026, accessible via the Notion API but not exposed through any consumer-facing UI yet. Workers run server-side JavaScript and TypeScript, sandboxed via Vercel Sandbox, with a 30-second execution timeout, 128MB memory limit, no persistent state, and outbound HTTP restricted to approved domains.

The 60-second version

Workers turn Notion AI from a text layer into a compute layer. Before Workers, Notion AI could read pages and write text. It couldn’t run code, couldn’t transform data, couldn’t reliably call external APIs. With Workers, an agent can offload computational tasks to a sandboxed JavaScript or TypeScript function — running for up to 30 seconds in 128MB of memory, with outbound HTTP restricted to approved domains. It’s the upgrade that makes Notion agents capable of real workflow automation, not just document assistance.

Why Workers matter

Three things change when agents can call code:

1. Real database queries. Before Workers, an agent could read pages but couldn’t reliably do “give me all rows where date is in the next 7 days and owner is unassigned.” With Workers, that’s a one-line query that returns structured data the agent uses in its response.

2. Approved external API calls. An agent can fetch live exchange rates, look up shipping status, query an internal CRM, or pull from any service exposed through an approved domain. The agent doesn’t make the call directly — it delegates to a Worker that does the call and returns the result.

3. Multi-step transformation chains. Read CSV → transform → enrich → write back to a database. Each step is a Worker. The agent orchestrates the chain. This is the pattern that lets agents handle real ops workflows that previously required Zapier, n8n, or custom code.

The technical constraints worth knowing

Workers are not Lambda. They have intentional limits:

• 30-second execution timeout. Anything longer needs to be split into smaller Workers or moved off-platform. No long-running batch jobs.
• 128MB memory limit. Streams and chunked processing only for large data. No loading 500MB CSVs into memory.
• No persistent state between calls. Each Worker invocation is fresh. State lives in Notion databases or external services, not in the Worker.
• Outbound HTTP restricted to approved domains. You declare which domains a Worker can reach. This is a security feature, not a limitation to fight.
• Sandboxed via Vercel Sandbox. Workers run on Vercel’s untrusted-code infrastructure. Performance is solid; cold starts exist.

What you need to use Workers

This is not a point-and-click feature. Requirements:

• A Notion developer account
• A Notion integration set up
• Familiarity with the agent configuration format
• API access — Workers are API-only as of April 2026

If you’ve never built on the Notion API, Workers aren’t your starting point. Standard agents and skills are. Workers are the next step once those don’t go far enough.

Three Worker patterns to start with

1. The data-fetch Worker. Agent says “I need the current value of X.” Worker calls an approved external API, parses the response, returns a structured value. Common pattern: looking up live data the agent doesn’t have access to natively.

2. The transform-and-write Worker. Agent passes structured input to a Worker. Worker reshapes the data — formatting dates, normalizing strings, computing derived fields — and writes the result to a Notion database row. Common pattern: cleaning incoming form submissions before they land in the CRM.

3. The chain-orchestration Worker. A Worker that calls other Workers in sequence, collecting results and returning a synthesized output. Common pattern: a multi-step intake process where each step needs different logic.

Why this is the more interesting story than May 3

The May 3 credit cliff is the news story. Workers are the strategic story. Workers are why credits exist — Notion can’t ship “an agent that calls any code you want and any API you want” on a flat fee. Credits make Workers viable as a product. The pricing news is the boring infrastructure that supports the interesting capability.

If you’re a developer or an agency building on Notion, Workers reshape what’s possible. A custom Notion deployment for a client used to mean “we set up databases and trained the team.” Now it can mean “we set up databases, trained the team, and built five Workers that handle their specific workflows.”

What’s still missing

Three gaps in the current developer preview worth tracking:

• No consumer UI. Workers are API-only. End users can’t build them in the Notion app. This will change.
• Limited debugging. Errors in Workers surface as agent errors. Better tooling for inspecting Worker execution is on the roadmap.
• Sandbox boundaries are evolving. Approved domain lists, memory limits, and timeout limits are likely to relax over time. Build with current limits; don’t bet on them staying fixed.

Sources

• Notion 3.4 part 2 release notes (April 14, 2026)
• Vercel blog — How Notion Workers run untrusted code at scale with Vercel Sandbox
• Notion API documentation — Workers for Agents (developer preview)

Continue the journey

This article is part of the May 3 Cliff Decision journey-pack on Tygart Media. Here’s where to go next:

• Read the pillar: The May 3 Custom Agents Cliff
• Custom Agents vs Basic Notion AI: When You Actually Need the Upgrade
• The ROI Math of Custom Agents: Cost Per Hour Reclaimed