Migrate from Heroku and get up to $10k in credits

Product

April 07, 2026

Product

Durability as code: Introducing Render Workflows

Vivek Ravishankar

April 07, 2026

Vivek Ravishankar

Build durable, long-running AI workflows and background jobs with an SDK. Now in beta for TypeScript and Python.

Deploying background workloads for your agents and apps should be as simple as pushing the code.

Instead, running them reliably still means standing up your own queues, workers, state management, and retry infrastructure.

We’re launching Render Workflows to help you build reliable, long-running processes like agent logic, data pipelines, and billing flows without making distributed systems your full-time job.

Define tasks and chained logic in your TypeScript or Python code using the Render SDK, and trigger them from anywhere. Render handles the infrastructure to make your workflows low-latency, stateful, and resilient.

A Workflow service in Render is an all-in-one package of queuing, worker pools, state management, retry logic, and observability. You define processes as a collection of tasks in your code using the Render SDK, deploy your code as a Workflow service in Render, and Render handles execution whenever you trigger a task.

For you, that means:

Just write code. Use the Render SDK to turn any function into a durable task with its own retry behavior. Like regular functions, you can chain tasks to define multi-step logic and parallel execution.

Automatic infrastructure. When you trigger a task, Render spins it up in its own isolated container within milliseconds and automatically serializes and transports args to containers for chained tasks.

Parallel execution. Parallelize heavy workloads across hundreds of concurrent containers. Render automatically handles scheduling and provisioning for tasks that are invoked in parallel.

Cost scales to zero. You only pay for the compute your tasks run on, prorated to the second. If you aren’t running any tasks, you aren’t paying anything. You can also define the compute plan for each task independently to optimize your spend for lighter and heavier tasks.

Run, observe, and debug in one place. Your tasks run on a private network alongside your other Render services. You can see a unified view of metrics and logs for every task run in the Render dashboard. No glue code. No jumping between dashboards to debug a failed run.

Your workflow is a collection of tasks. Tasks are just as flexible as regular functions, but each can have its own retry logic, timeout, and compute plan.

In TypeScript, you define tasks using the task() wrapper function. In Python, use the @app.task decorator:

typescript

import { task } from '@renderinc/sdk/workflows'

const generateCode = task({
  name: 'generateCode',
 }, async function (plan: AppPlan, model: string) {
  // generate code based on AppPlan with selected model, parse response into files
})

python

from render_sdk import Workflows 
app = Workflows()

@app.task  # Python SDK infers task name from function name
async def generate_code(plan: dict, model: str):
    # generate code based on AppPlan with selected model, parse response into files

To configure retry behavior, timeout, and compute for your task, add them directly to the task definition:

typescript

import { task } from '@renderinc/sdk/workflows'

const generateCode = task({
  name: 'generateCode',
  retry: {
    maxRetries: 3, // retry up to 3 times
    waitDurationMs: 1000, // wait 1s before first retry
    backoffScaling: 1.5 // exponential backoff for subsequent retries
  },
  timeoutSeconds: 60, // configurable up to 24 hours
  plan: 'starter' // configurable up to 'Pro Ultra' (8 CPU / 32GB RAM)
 }, async function (plan: AppPlan, model: string) {
  // generate code based on AppPlan with selected model, parse response into files
})

python

from render_sdk import Workflows, Retry
app = Workflows()
@app.task(  # Python SDK infers task name from function name
    retry=Retry(
        max_retries=3, # retry up to 3 times
        wait_duration_ms=1000, # wait 1s before first retry
        backoff_scaling=1.5 # exponential backoff for subsequent retries
    ),
    timeout_seconds=60, # configurable up to 24 hours
    plan="standard" # configurable up to 'Pro Ultra' (8 CPU / 32GB RAM)
)
async def generate_code(plan: dict, model: str):
    # generate code based on AppPlan with selected model, parse response into files

Workflows are most useful when you need to run complex processes made up of many sequential and parallel tasks. You can build that logic by chaining tasks just like you would normal functions.

For example, an agent that generates code for a web app may need a loop that chains multiple LLM calls and sandboxes to generate, validate, and display a preview to the user after a prompt:

typescript

const generationLoop = task({ name: 'generationLoop' },
  async function (prompt: string, userId: string, startingSnapshotId?: string) {
    // create a plan from the prompt (or modify existing plan if iterating)
    let plan = await planStructure(prompt, startingSnapshotId)
    let code = await generateCode(plan)
    let sandboxId = plan.sandboxId
    const errors: BuildError[] = []

    // build → check → revise until it works (max 3 attempts)
    while (errors.length < 3) {
      const build = await buildInSandbox(code, sandboxId)
      sandboxId = build.sandboxId
      if (build.success) {
        // deliver preview to user and save state in parallel
        await Promise.all([
          pushPreview(userId, build.previewUrl),
          saveSnapshot(sandboxId, code)
        ])
        return
      }
      // build failed: revise plan and fix code
      errors.push(build.errors)
      plan = await revisePlan(plan, errors)
      code = await fixCode(code, plan, build.errors)
    }
    // all attempts failed: explain what went wrong
    return diagnoseFailure(prompt, errors)
  }
)

const planStructure = task({ name: 'planStructure' }, ...) // prompt + optional snapshot → plan
const generateCode = task({ name: 'generateCode' }, ...) // plan → application code
const buildInSandbox = task({ name: 'buildInSandbox' }, ...) // install, compile, run
const revisePlan = task({ name: 'revisePlan' }, ...) // adjust plan from errors
const fixCode = task({ name: 'fixCode' }, ...) // targeted code edits
const pushPreview = task({ name: 'pushPreview' }, ...) // send preview URL to user
const saveSnapshot = task({ name: 'saveSnapshot' }, ...) // version current artifacts
const diagnoseFailure = task({ name: 'diagnoseFailure' }, ...) // explain failure to user

python

@app.task
async def generation_loop(prompt: str, user_id: str, starting_snapshot_id: str = None):
    # create a plan from the prompt (or modify existing plan if iterating)
    plan = await plan_structure(prompt, starting_snapshot_id)
    code = await generate_code(plan)
    sandbox_id = plan.sandbox_id
    errors = []

    # build → check → revise until it works (max 3 attempts)
    while len(errors) < 3:
        build = await build_in_sandbox(code, sandbox_id)
        sandbox_id = build.sandbox_id
        if build.success:
            # deliver preview to user and save state in parallel
            await asyncio.gather(
                push_preview(user_id, build.preview_url),
                save_snapshot(sandbox_id, code)
            )
            return
        # build failed: revise plan and fix code
        errors.append(build.errors)
        plan = await revise_plan(plan, errors)
        code = await fix_code(code, plan, build.errors)

    # all attempts failed: explain what went wrong
    return await diagnose_failure(prompt, errors)

@app.task
async def plan_structure(...): ... # prompt + optional snapshot → plan
@app.task
async def generate_code(...): ... # plan → application code
@app.task
async def build_in_sandbox(...): ... # install, compile, run
@app.task
async def revise_plan(...): ... # adjust plan from errors
@app.task
async def fix_code(...): ... # targeted code edits
@app.task
async def push_preview(...): ... # send preview URL to user
@app.task
async def save_snapshot(...): ... # version current artifacts
@app.task
async def diagnose_failure(...): ... # explain failure to user

With your tasks defined, you can deploy your code as a Workflow service on Render and start triggering tasks.

Typically, you’ll trigger tasks directly from your application code for other services on Render:

typescript

import { Render } from '@renderinc/sdk'
const render = new Render()
const run = await render.workflows.runTask(
  'my-workflow/generationLoop',
  [prompt, userId, startingSnapshotId]
)

python

from render_sdk import RenderAsync

render = RenderAsync()
run = await render.workflows.start_task(
    "my-workflow/generation_loop",
    [prompt, user_id, starting_snapshot_id]
)

You can also trigger tasks from external services using the Render API or manually through the Render Dashboard.

Because Render handles all of the infrastructure for your workflows from start to finish, it gives you a unified view of traces, metrics, and logs across every executed task without any additional setup.

You can analyze the reliability of individual tasks, monitor for opportunities to optimize compute, and debug failed runs through a single dashboard or CLI.

Observe workflows with a unified dashboard

To see some of the systems you can implement with Workflows, explore our curated examples in the Workflows Playground. You can also spin up an example workflow locally with the Render CLI:

bash

render workflows init

Workflows are defined entirely in your code using an idiomatic SDK, so Claude Code, Cursor, Codex, and other agents can reason about them and build them for you.

To teach your agents how to build and debug workflows, install the workflows agent skill:

bash

render skills install render-workflows

Workflows are designed to let you build reliable, scalable, intelligent apps by just writing code.

AI agents need infrastructure shaped for long-running, stateful workloads. They depend on complex, multi-service agent loops, data pipelines, and other orchestration patterns that allow individual tasks to fail, retry, and parallelize gracefully.

With Workflows, you define that logic in your codebase and deploy it instantly, keeping you focused on building your product rather than infrastructure.

Over the course of beta, we’ll be extending Workflows to expand the breadth of processes you can build:

Vertically autoscale task compute to optimize performance and cost
Kick off tasks via cron
Pause and resume workflows
Checkpoint state to recover from interruptions
Additional language support

You can start building workflows today with the TypeScript and Python SDKs. Read the Workflows Docs to learn more.

Durability as code: Introducing Render Workflows

Fully-managed execution

Define workflow tasks

Trigger tasks

Distributed execution, central observability

Workflow examples and agent skills

For the future of intelligent apps