AI Agents in Cadences: From Prompt to Autonomous System

"AI Agent" has become this year's buzzword, but the reality is that most implementations are simply a chatbot with a long prompt. In Cadences, agents are something else entirely. They are autonomous processes running on the cloud edge, with configurable personality, persistent memory, real tools, and the ability to communicate with each other.

A chatbot answers questions. An agent acts. The fundamental difference is that an agent has access to tools, persistent context, and the ability to execute operations in the real world — create tasks, send emails, update data, even execute other agents.

Each agent in Cadences is composed of five layers that work together. This modular design allows a support agent to work completely differently from a sales agent, while both share the same execution infrastructure:

Cadences includes a library of ready-to-use agents, organized by category. Each comes with an optimized prompt, recommended modules, and usage examples. You can use them as-is or clone them as a base to create custom agents:

Each library agent is a JavaScript object with a clear structure. This is what defines the Lead Qualifier, one of the most popular agents in the sales catalog:

{
  id: 'lead-qualifier',
  name: 'Lead Qualifier',
  category: 'sales',
  icon: '🎯',
  description: 'Qualifies leads using BANT/CHAMP framework',

  prompt: `You are an expert in B2B lead qualification.
    Use BANT framework:
    - Budget: Do they have a budget?
    - Authority: Are they a decision maker?
    - Need: Do they have a clear need?
    - Timeline: When do they need to buy?

    Scale: 🔥 HOT (90-100) | 🌟 WARM (70-89)
            🔵 COLD (50-69) | ❄️ FROZEN (<50)`,

  promptModules: {
    includeCore: true,
    includeFormOperations: true,
    includeProjectOperations: true
  },

  difficulty: 'intermediate',
  popularity: 76
}

The promptModules field is key: it defines which tools and operations the agent has access to. An agent with includeProjectOperations: true can create and modify tasks; with includeFormOperations: true, it can read CRM form data.

Agents don't live in the browser. They run on Cloudflare Workers via the AgentWorker, an execution system designed to run AI tasks in the background without user intervention:

const response = await fetch('/api/agents/execute', {
  method: 'POST',
  body: JSON.stringify({
    agentType: 'lead-qualifier',
    prompt: 'Qualify this lead: CEO, 50 employees, $10k',
    context: { projectId: 'proj_123' },
    userId: 'user_abc',
    userTier: 'premium',
    priority: 8,           // CRITICAL = 10, HIGH = 8
    operations: true,      // Allow autonomous CRUD
    aiProvider: 'auto'     // Uses user preferences
  })
});

const { executionId, status } = await response.json();
// status: 'pending' → 'running' → 'completed'

The AgentScheduler enables scheduling agents with cron expressions, timezone support, and auto-disable after consecutive failures. Some real-world examples:

// Daily report: Monday to Friday at 9:00 AM
await fetch('/api/schedules', {
  method: 'POST',
  body: JSON.stringify({
    cron: '0 9 * * 1-5',
    agentConfig: {
      agentType: 'daily-reporter',
      prompt: 'Generate summary of tasks completed yesterday',
      userId: 'user_abc',
      userTier: 'premium'
    },
    timezone: 'America/New_York',
    enabled: true
  })
});

// Auto-disable after 5 consecutive failures ✓
// Retry logic with exponential backoff ✓

Agents can communicate with each other through two patterns: sequential pipeline (one agent's output feeds the next) and parallel fan-out (one agent triggers multiple agents simultaneously).

Agents are not tied to a single model. The aiService system supports multiple AI providers: if the user configured DeepSeek as their preferred provider, their agents will use DeepSeek. If not, the system uses Gemini as a smart fallback:

Synapse Studio takes agents to the next visual level. It's a "corporate building" environment where each agent has an avatar, a desk, an emotional state, and an energy level. You can watch them work, send them on breaks, and review their performance in real time.

When an agent has completed many consecutive tasks, its energy drops. You can send it to break and its energy recovers +40 points, its mood changes to "happy" and its consecutive task counter resets. This isn't cosmetic — it's a real context management mechanic that prevents quality degradation in responses from token accumulation.

When you assign a task to an agent in Synapse Studio, this is what happens internally:

Every agent execution is persisted in Cloudflare D1 for auditing, debugging, and analytics:

CREATE TABLE agent_executions (
  execution_id  TEXT UNIQUE,      -- 'exec_a8f3c2...'
  user_id       TEXT NOT NULL,
  user_tier     TEXT DEFAULT 'free',
  agent_type    TEXT NOT NULL,     -- 'lead-qualifier'
  config        TEXT,              -- Full JSON config
  status        TEXT DEFAULT 'pending',
  priority      INTEGER DEFAULT 5,
  result        TEXT,              -- JSON with response
  logs          TEXT,              -- JSON array of logs
  parent_execution_id TEXT,        -- For pipelines
  scheduled_for DATETIME,
  started_at    DATETIME,
  completed_at  DATETIME
);

Cadences agents are not a lab experiment. They are production systems that real companies use daily to qualify leads, generate reports, classify tickets, and automate repetitive tasks. The combination of personality library + edge execution + multi-provider AI + Synapse Studio creates an ecosystem where building an autonomous agent is as easy as choosing a template and giving it a goal.

And this is just the beginning. In upcoming articles, we'll see how these same agents can talk on the phone with customers (Conversational Voice AI) and how Synapse acts as the data brain that connects the entire ecosystem.