Reliable Programming at Scale

Make your code reliable—from LLM calls to complex workflows. PlanLlama provides automatic retries, workflow orchestration, and real-time monitoring. Start with just a few lines of code, no infrastructure required.

View Documentation

Powerful Features

Everything you need for reliable programming in the cloud

AI Reliability Layer

Make LLM calls and AI workflows reliable with automatic retries

Workflow Orchestration

Multi-step workflows with dependency resolution and error recovery

Real-time Events

WebSocket-based job lifecycle notifications for instant feedback

Multi-Language Support

Native libraries for JavaScript, Python, Ruby, and Go

Zero Infrastructure

Cloud-based reliable programming with no database setup

Cron Scheduling

Built-in recurring job support with standard cron syntax

🦙

pg-boss, supercharged.

Built on pg-boss — now cross-platform

PlanLlama is built on pg-boss, the rock-solid Postgres job engine developers already trust — now reimagined for the cloud.

If you love pg-boss, you'll feel right at home. PlanLlama takes everything great about it and adds orchestration, monitoring, retries, and team collaboration — all in a fully managed platform.

Connect multiple environments, apps, or clouds. Run queues, cron jobs, and workflows anywhere, all from one dashboard. No rewrites, no new runtime — just the power of pg-boss, everywhere.

🧩

Built on pg-boss

Same schema and API foundations you know

☁️

Cross-platform orchestration

Link multiple Postgres instances and clouds

📊

Dashboards & alerts

Real-time visibility for every job and workflow

🚀

Zero ops

We manage scaling, retries, and failures for you

Learn how PlanLlama extends pg-boss →

Simple Integration

Get started with just a few lines of code in your favorite language

JavaScript

import { PlanLlama } from 'planllama';

const client = new PlanLlama('your-api-token');
await client.start();

// Publish a job
const jobId = await client.publish('send-email', { 
  to: 'user@example.com',
  subject: 'Welcome!'
});

// Request-response pattern
const result = await client.request('calculate', { 
  x: 5, 
  y: 10 
});
console.log(result); // { sum: 15 }

Python

from planllama import PlanLlama

client = PlanLlama("your-api-token")
await client.start()

# Publish a job
job_id = await client.publish("send-email", {
    "to": "user@example.com",
    "subject": "Welcome!"
})

# Request-response pattern
result = await client.request("calculate", {
    "x": 5,
    "y": 10
})
print(result)  # {"sum": 15}

Ruby

require 'planllama'

client = PlanLlama::Client.new(api_token: 'your-api-token')
client.start

# Publish a job
job_id = client.publish('send-email', {
  to: 'user@example.com',
  subject: 'Welcome!'
})

# Request-response pattern
result = client.request('calculate', { 
  x: 5, 
  y: 10 
})
puts result  # { sum: 15 }

package main

import (
    "context"
    "fmt"
    planllama "github.com/BaudehloBiz/planllama-go"
)

client := planllama.NewClient("your-api-token")
ctx := context.Background()
client.Start(ctx)

// Publish a job
jobID, _ := client.Publish(ctx, "send-email", map[string]interface{}{
    "to": "user@example.com",
    "subject": "Welcome!",
}, nil)

// Request-response pattern
result, _ := client.Request(ctx, "calculate", map[string]interface{}{
    "x": 5,
    "y": 10,
}, nil)
fmt.Println(result) // map[sum:15]

Quick Installation

Get started with your preferred language in seconds

JavaScript/TypeScript

npm install planllama

Also works with yarn and pnpm

Python

pip install planllama

Supports async/await interface

Ruby

gem install planllama

Idiomatic Ruby patterns

Go

go get github.com/BaudehloBiz/planllama-go

Type-safe with context support

Powerful Job Configuration

Fine-tune job behavior with comprehensive options

JavaScript

await client.publish('process-order', orderData, {
  priority: 10,              // Higher priority jobs run first
  retryLimit: 3,             // Retry up to 3 times on failure
  retryDelay: 60,            // Wait 60s between retries
  retryBackoff: true,        // Exponential backoff
  expireInMinutes: 30,       // Job expires after 30 minutes
  startAfter: 5,             // Start after 5 seconds
  singletonKey: 'order-123'  // Ensure only one job with this key
});

Real-Time Job Events

Listen to job lifecycle events via WebSocket

Event Listeners

client.on('active', (job) => {
  console.log('Job started:', job.id);
});

client.on('completed', (job, result) => {
  console.log('Job completed:', result);
});

client.on('failed', (job, error) => {
  console.log('Job failed:', error);
});

client.on('retrying', (job) => {
  console.log('Job retrying:', job.id);
});

client.on('expired', (job) => {
  console.log('Job expired:', job.id);
});

client.on('cancelled', (job) => {
  console.log('Job cancelled:', job.id);
});

Built for Modern Development

From AI reliability to complex workflows

AI & LLM Reliability

Wrap AI SDK calls with automatic retries and error recovery

Agent Orchestration

Coordinate multi-agent workflows with dependency resolution

Data Processing Pipelines

Multi-step workflows with automatic error handling

Background Jobs

Offload heavy processing from web requests reliably

Scheduled Reports

Generate daily/weekly reports with cron syntax

Webhook Delivery

Retry failed webhooks with exponential backoff

Powerful Analytics

Monitor your jobs with real-time dashboards and alerts

PlanLlama analytics dashboard showing job execution metrics

Ready to Make Your Code Reliable?

Start building reliable applications in minutes with our free tier.