lindy-cost-tuning

Name: lindy-cost-tuning - Agent Skill
Rating: 5.0 (1039 reviews)
Author: jeremylongshore

1,039

MIT

Optimize Lindy AI costs and manage usage efficiently. Use when reducing costs, analyzing usage patterns, or optimizing budget allocation. Trigger with phrases like "lindy cost", "lindy billing", "reduce lindy spend", "lindy budget".

Download Folder View on GitHub

CLI Install

Recommended

Use the skills CLI to install this skill with one command. Auto-detects all installed AI assistants.

Method 1 - skills CLI

npx skills i jeremylongshore/claude-code-plugins-plus-skills/plugins/saas-packs/lindy-pack/skills/lindy-cost-tuning

Method 2 - openskills (supports sync & update)

npx openskills install jeremylongshore/claude-code-plugins-plus-skills

Auto-detects Claude Code, Cursor, Codex CLI, Gemini CLI, and more. One install, works everywhere.

Installation Path

Download and extract to one of the following locations:

~/.claude/skills/lindy-cost-tuning/

SKILL.md

Skill Instructions

Back

Run with Cloud Agent

No setup needed. Let our cloud agents run this skill for you.

Select Provider

Select Model

Claude Sonnet 4.5

$0.20/task

Best for coding tasks

No setup required

Lindy Cost Tuning

Overview

Optimize Lindy AI costs while maintaining service quality.

Prerequisites

Access to Lindy billing dashboard
Usage data available
Understanding of pricing tiers

Instructions

Step 1: Analyze Current Usage

import { Lindy } from '@lindy-ai/sdk';
 
async function analyzeUsage() {
  const lindy = new Lindy({ apiKey: process.env.LINDY_API_KEY });
 
  const usage = await lindy.usage.monthly({
    startDate: '2025-01-01',
    endDate: '2025-01-31',
  });
 
  const analysis = {
    totalRuns: usage.agentRuns.total,
    totalCost: usage.billing.total,
    costPerRun: usage.billing.total / usage.agentRuns.total,
    topAgents: usage.byAgent
      .sort((a: any, b: any) => b.cost - a.cost)
      .slice(0, 5),
    peakHours: usage.byHour
      .sort((a: any, b: any) => b.runs - a.runs)
      .slice(0, 5),
  };
 
  console.log('Usage Analysis:', analysis);
  return analysis;
}

Step 2: Implement Usage Budgets

interface Budget {
  monthly: number;
  daily: number;
  perAgent: number;
}
 
const budget: Budget = {
  monthly: 500, // $500/month
  daily: 20

Step 3: Optimize Agent Costs

// Cost-optimized agent configuration
const optimizedAgent = {
  name: 'Cost-Efficient Agent',
  instructions: 'Be brief. Answer in 1-2 sentences.',
  config: {
    model: 'gpt-3.5-turbo', // Cheaper model
    maxTokens: 100,         // Limit output
    temperature: 0.3,       // Less creative = fewer tokens
  },
};

Step 4: Implement Caching to Reduce Calls

import NodeCache from 'node-cache';
 
const cache = new NodeCache({ stdTTL: 3600 }); // 1 hour cache
 
async function cachedRun(agentId: string, input: string) {
  const cacheKey = `${agentId

Step 5: Set Up Cost Alerts

async function setupCostAlerts() {
  const lindy = new Lindy({ apiKey: process.env.LINDY_API_KEY });
 
  // Alert at 80% of budget
  await lindy.billing.alerts.create({
    threshold: 400, // $400 of $500 budget
    type: 'monthly',
    channels: ['email', 'slack'],

Cost Optimization Checklist

[ ] Usage analysis completed
[ ] Budget limits defined
[ ] Cost alerts configured
[ ] Caching implemented
[ ] Cheaper models for simple tasks
[ ] Max tokens configured
[ ] Unused agents identified and disabled
[ ] Peak usage patterns analyzed

Output

Usage analysis report
Budget enforcement
Cost-optimized agents
Caching for reduced API calls
Alert system

Error Handling

Issue	Cause	Solution
Budget exceeded	High usage	Throttle or pause
Cost spike	Anomaly	Investigate and alert
Cache ineffective	Low hit rate	Tune TTL

Examples

Monthly Cost Report

async function generateCostReport() {
  const usage = await analyzeUsage();
 
  const report = `
# Lindy Cost Report - ${new Date().toISOString().slice(0, 7)}
 
## Summary
- Total Runs: ${

Resources

Next Steps

Proceed to lindy-reference-architecture for architecture patterns.

perAgent: 50, // $50/agent/month

async function checkBudget(): Promise<boolean> {

const lindy = new Lindy({ apiKey: process.env.LINDY_API_KEY });

const usage = await lindy.usage.current();

if (usage.billing.monthly >= budget.monthly) {

console.error('Monthly budget exceeded!');

await sendAlert('Budget exceeded', { usage, budget });

if (usage.billing.today >= budget.daily) {

console.warn('Daily budget exceeded');

// Route simple queries to cheaper agents

async function routeQuery(input: string) {

const isSimple = input.length < 100 && !input.includes('analyze');

const agentId = isSimple

? 'agt_cheap_simple'

: 'agt_expensive_complex';

return lindy.agents.run(agentId, { input });

// Check cache first (free!)

const cached = cache.get(cacheKey);

console.log('Cache hit - $0');

// Only call API if cache miss

const result = await lindy.agents.run(agentId, { input });

cache.set(cacheKey, result);

console.log('Cache miss - API call made');

message: 'Approaching monthly budget limit',

// Daily anomaly detection

await lindy.billing.alerts.create({

threshold: 50, // 50% above average

channels: ['slack'],

message: 'Unusual spending detected',

- Total Cost: $${usage.totalCost.toFixed(2)}

- Cost per Run: $${usage.costPerRun.toFixed(4)}

## Top Agents by Cost

${usage.topAgents.map((a: any) => `- ${a.name}: $${a.cost.toFixed(2)}`).join('\n')}

${usage.costPerRun > 0.05 ? '- Consider cheaper models for simple tasks' : ''}

${usage.cacheHitRate < 0.3 ? '- Improve caching strategy' : ''}