Lindy Multi-Environment Setup

Overview

Isolate Lindy AI agents across development, staging, and production using separate

workspaces, dedicated API keys, and environment-specific webhook configurations.

Lindy agents live in workspaces — each environment should use its own workspace

to prevent cross-environment data leakage.

Prerequisites

• Multiple Lindy workspaces (one per environment) or Enterprise plan
• Secret management solution (env vars, Vault, AWS/GCP secrets)
• CI/CD pipeline with environment-aware deployment
• Application with environment detection logic

Environment Strategy

Instructions

Step 1: Create Separate Workspaces

1. Log in at
2. Create workspace for each environment: [company]-dev, [company]-staging, [company]-prod
3. Generate separate API keys in each workspace
4. Store each key in the appropriate secret store

Step 2: Environment Configuration

// config/lindy.ts — Environment-aware Lindy configuration
interface LindyConfig {
  apiKey: string;
  webhookUrl: string;
  webhookSecret: string;
  workspace: string;
  model: string;
}

function getLindyConfig(): LindyConfig {
  const env = process.env.NODE_ENV || 'development';

  const configs: Record<string, LindyConfig> = {
    development: {
      apiKey: process.env.LINDY_API_KEY_DEV!,
      webhookUrl: process.env.LINDY_WEBHOOK_URL_DEV!,
      webhookSecret: process.env.LINDY_WEBHOOK_SECRET_DEV!,
      workspace: 'dev',
      model: 'gemini-flash', // Cheap model for dev
    },
    staging: {
      apiKey: process.env.LINDY_API_KEY_STAGING!,
      webhookUrl: process.env.LINDY_WEBHOOK_URL_STAGING!,
      webhookSecret: process.env.LINDY_WEBHOOK_SECRET_STAGING!,
      workspace: 'staging',
      model: 'claude-sonnet', // Match prod model
    },
    production: {
      apiKey: process.env.LINDY_API_KEY_PROD!,
      webhookUrl: process.env.LINDY_WEBHOOK_URL_PROD!,
      webhookSecret: process.env.LINDY_WEBHOOK_SECRET_PROD!,
      workspace: 'production',
      model: 'claude-sonnet',
    },
  };

  const config = configs[env];
  if (!config) throw new Error(`Unknown environment: ${env}`);
  return config;
}

export const lindyConfig = getLindyCo

Lindy Production Checklist

Overview

Comprehensive go-live checklist for Lindy AI agents entering production. Covers

agent configuration, security, monitoring, error handling, and operational readiness.

Prerequisites

• Agents tested in development/staging environment
• Production Lindy workspace configured
• Team members assigned appropriate roles
• Credit budget approved for production usage

Production Checklist

Authentication & Security

• [ ] Production API keys generated (separate from dev/staging)
• [ ] API keys stored in secret manager (not environment files)
• [ ] Webhook secrets generated for all webhook triggers
• [ ] Webhook receivers verify Bearer token on every request
• [ ] .env files excluded from version control
• [ ] Key rotation schedule documented (90-day max)
• [ ] Enterprise: SSO enabled, SCIM configured

Agent Configuration

• [ ] Agent prompt reviewed for production quality
• [ ] Clear identity and role definition
• [ ] Numbered step-by-step instructions
• [ ] Explicit constraints (no unauthorized promises, data limits)
• [ ] Error handling instructions in prompt
• [ ] Few-shot examples for consistent output format
• [ ] Model selection appropriate for each step:
• [ ] Gemini Flash for simple routing/classification
• [ ] Claude Sonnet/GPT-4o-mini for standard tasks
• [ ] GPT-4/Claude Opus only where complex reasoning required
• [ ] Exit conditions defined with primary + fallback criteria
• [ ] Trigger filters configured to prevent over-firing
• [ ] Knowledge base sources current and synced

Integration Health

• [ ] All integration OAuth tokens current (not expired)
• [ ] Gmail: correct account authorized, label filters set
• [ ] Slack: bot invited to required channels
• [ ] Webhooks: endpoint URLs use production domains (not ngrok/dev)
• [ ] HTTP Request actions: target URLs are production endpoints
• [ ] Phone numbers: provisioned and tested ($10/month each)

Error Handling

• [ ] Agents have fallback behavior for common failures:
• [ ] Integration auth expired -> notify admin
• [ ] KB returns no results -> graceful fallback response
• [ ] Condition matching fails -> default "other" branch
• [ ] Agent step loops -> reasonable exit conditions
• [ ] Webhook receivers return 200 quickly (process async)
• [ ] HTTP Request action targets have health checks
• [ ] Credit usage alerts configured (50%, 80%, 95% thresholds)

Monitoring & Observability

• [ ] Regular review of agent Tasks tab scheduled
• [ ] Failed task alerts configured (email or Slack)
• [ ] Credit consumption tracked per agent

Lindy Rate Limits & Credits

Overview

Lindy uses a credit-based consumption model, not traditional API rate limits.

Every task (everything an agent does after being triggered) costs credits. Cost

scales with model intelligence, task complexity, premium actions, and duration.

Credit Consumption Reference

Plan Credit Limits

Important: Credit limit enforcement is not instant. Lindy can only limit usage

after the limit has been breached, not precisely when it is reached. A task that

starts before the limit may complete and push usage slightly over.

Instructions

Step 1: Monitor Credit Usage

In the Lindy dashboard:

1. Navigate to Settings > Billing
2. Review current credit consumption
3. Track per-agent credit usage
4. Set up alerts for high-consumption agents

Step 2: Reduce Per-Task Credit Cost

Choose the right model for each step:

Reduce action count per task:

• Combine multiple LLM calls into one prompt with structured output
• Use deterministic actions (Set Manually) instead of AI-powered fields where possible
• Eliminate unnecessary condition branches
• Use Run Code for data transformation instead of LLM steps

Step 3: Optimize Trigger Frequency

Prevent cr

Lindy Reference Architecture

Overview

Production-ready architecture patterns for integrating Lindy AI agents into

applications. Covers webhook integration, multi-agent societies, event-driven

pipelines, and high-availability patterns.

Prerequisites

• Understanding of Lindy agent model (triggers, actions, skills)
• Familiarity with webhook-based architectures
• Production requirements defined (throughput, latency, reliability)

Architecture 1: Simple Webhook Integration

Single agent triggered by your application, results sent via callback.

┌─────────────┐       POST (webhook)       ┌──────────────┐
│  Your App   │ ─────────────────────────→  │ Lindy Agent  │
│             │                             │              │
│  /callback  │ ←─────────────────────────  │ HTTP Request │
│             │       POST (callback)       │   Action     │
└─────────────┘                             └──────────────┘

Implementation:

• Your app sends webhook with callbackUrl field
• Lindy agent processes and responds via Send POST Request to Callback
• Your app receives results asynchronously

Best for: Simple automations (email triage, lead scoring, content generation)

Architecture 2: Event-Driven Pipeline

Multiple event sources feed agents through a central webhook router.

┌──────────┐
│ Stripe   │──webhook──┐
└──────────┘           │
                       ▼
┌──────────┐     ┌───────────┐     ┌──────────────┐
│ Shopify  │──→  │  Router   │──→  │ Lindy Agents │
└──────────┘     │  Service  │     │              │
                 └───────────┘     │ • Order Bot  │
┌──────────┐           ▲          │ • Support Bot│
│ Your App │──webhook──┘          │ • Analytics  │
└──────────┘                      └──────────────┘

Implementation:

// Event router — maps events to specific Lindy agents
const agentWebhooks: Record<string, string> = {
  'order.created': process.env.LINDY_ORDER_AGENT_WEBHOOK!,
  'customer.support_request': process.env.LINDY_SUPPORT_AGENT_WEBHOOK!,
  'analytics.daily_report': process.env.LINDY_ANALYTICS_AGENT_WEBHOOK!,
};

app.post('/events', async (req, res) => {
  const { event, data } = req.body;
  const webhookUrl = agentWebhooks[event];

  if (!webhookUrl) {
    return res.status(400).json({ error: `Unknown event: ${event}` });
  }

  await fetch(webhookUrl, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.LINDY_WEBHOOK_SECRET}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ event, data, callbackUrl: `${BASE_URL}/callback` }),
  });

  res.json({ routed: true, agent: event });
});

Best