Skip to main content

​
Available Agents

​
Starter Kit Utility Agents

These agents ship with your project—you own the source and can customize them.

scrape

Web scraping with fallbacks

validate

Data validation against schemas

fetch

Smart HTTP fetching with caching

slug

URL-safe slug generation

tools

MCP tools integration

queries

SQL query execution

autorag

Cloudflare AutoRAG (managed)

​
Built-in Framework Agents

Framework-level agents you configure but don’t modify.

rag

Manual RAG with Vectorize

hitl

Human-in-the-loop approvals

​
Quick Usage

​
Scrape Agent

ensemble: scrape-and-analyze

agents:
  - name: scrape
    agent: scrape
    inputs:
      url: ${input.url}
      extract:
        title: h1
        price: .price
        description: .description

  - name: analyze
    operation: think
    config:
      provider: openai
      model: gpt-4o-mini
      prompt: Analyze this product: ${scrape.output}

output:
  product: ${scrape.output}
  analysis: ${analyze.output}

​
Validate Agent

ensemble: validate-and-store

agents:
  - name: validate
    agent: validate
    inputs:
      data: ${input.user_data}
      schema:
        type: object
        required: [email, name]
        properties:
          email:
            type: string
            format: email
          name:
            type: string
            minLength: 1

  - name: store
    condition: ${validate.output.valid}
    operation: data
    config:
      backend: d1
      binding: DB
      operation: execute
      sql: INSERT INTO users (email, name) VALUES (?, ?)
      params:
        - ${input.user_data.email}
        - ${input.user_data.name}

output:
  valid: ${validate.output.valid}
  errors: ${validate.output.errors}
  stored: ${store.executed}

​
RAG Agent

ensemble: rag-qa

agents:
  - name: rag
    agent: rag
    inputs:
      question: ${input.question}
      index_name: docs-index
      top_k: 5

output:
  answer: ${rag.output.answer}
  sources: ${rag.output.sources}
  confidence: ${rag.output.confidence}

​
HITL Agent

ensemble: content-approval

agents:
  - name: generate
    operation: think
    config:
      provider: openai
      model: gpt-4o
      prompt: Write content about: ${input.topic}

  - name: approval
    agent: hitl
    inputs:
      prompt: Review this content for publication
      context:
        content: ${generate.output}
        topic: ${input.topic}
      timeout: 3600  # 1 hour timeout

  - name: publish
    condition: ${approval.output.approved}
    operation: data
    config:
      backend: d1
      binding: DB
      operation: execute
      sql: INSERT INTO published (content) VALUES (?)
      params: [${generate.output}]

output:
  content: ${generate.output}
  approved: ${approval.output.approved}
  feedback: ${approval.output.feedback}

​
Combining Starter Kit Agents

​
Scrape + Validate + Transform

ensemble: scrape-validate-transform

agents:
  - name: scrape
    agent: scrape
    inputs:
      url: ${input.url}

  - name: validate
    agent: validate
    inputs:
      data: ${scrape.output}
      schema: product-schema

  - name: transform
    condition: ${validate.output.valid}
    operation: code
    config:
      script: scripts/transform-product
    input:
      data: ${scrape.output}

output:
  product: ${transform.output}
  valid: ${validate.output.valid}

// scripts/transform-product.ts
import type { AgentExecutionContext } from '@ensemble-edge/conductor'

export default function transformProduct(ctx: AgentExecutionContext) {
  const { data } = ctx.input
  return {
    ...data,
    price: parseFloat(data.price_text?.replace(/[^0-9.]/g, '') || '0'),
    transformed_at: Date.now()
  }
}

​
RAG + HITL

ensemble: rag-with-review

agents:
  - name: rag
    agent: rag
    inputs:
      question: ${input.question}
      index_name: docs-index

  - name: review
    agent: hitl
    inputs:
      prompt: Review this AI-generated answer
      context:
        question: ${input.question}
        answer: ${rag.output.answer}
        sources: ${rag.output.sources}
      timeout: 1800

output:
  answer: ${rag.output.answer}
  approved: ${review.output.approved}
  sources: ${rag.output.sources}

​
Customizing Starter Kit Agents

Starter Kit agents accept configuration:

​
Scrape with Retry

agents:
  - name: scrape
    agent: scrape
    inputs:
      url: ${input.url}
      timeout: 10000
      retry:
        maxAttempts: 3
        backoff: exponential
      headers:
        User-Agent: MyApp/1.0

​
Validate with Custom Rules

agents:
  - name: validate
    agent: validate
    inputs:
      data: ${input.data}
      schema:
        type: object
        required: [email]
        properties:
          email:
            type: string
            pattern: ^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$
      strict: true  # Fail on extra properties

​
RAG with Custom Embeddings

agents:
  - name: rag
    agent: rag
    inputs:
      question: ${input.question}
      index_name: docs-index
      embedding_model: text-embedding-3-large
      top_k: 10
      score_threshold: 0.7

​
When to Use Starter Kit vs Custom

​
Use Starter Kit When:

  • Common use case (scraping, validation, RAG)
  • Need production-tested solution
  • Want to ship quickly
  • Standard functionality is sufficient

​
Build Custom When:

  • Unique business logic
  • Need specific integrations
  • Performance critical paths
  • Domain-specific requirements

​
Extending Starter Kit Agents

Wrap Starter Kit agents for custom behavior: 
# agents/custom-scraper/agent.yaml
agent: custom-scraper
description: Scraper with custom post-processing

inputs:
  url: string

operations:
  # Use Starter Kit scraper
  - name: scrape
    agent: scraper
    inputs:
      url: ${input.url}

  # Custom post-processing
  - name: enhance
    operation: code
    config:
      script: scripts/enhance-scraped-data
    input:
      scrapeData: ${scrape.output}
      url: ${input.url}

// scripts/enhance-scraped-data.ts
import type { AgentExecutionContext } from '@ensemble-edge/conductor'

export default function enhanceScrapedData(context: AgentExecutionContext) {
  const { scrapeData, url } = context.input
  return {
    ...scrapeData,
    scraped_at: Date.now(),
    url,
    processed: true
  }
}

  # Custom validation
  - name: validate
    operation: code
    config:
      script: scripts/validate-scraped-data
    input:
      data: ${enhance.output}

// scripts/validate-scraped-data.ts
import type { AgentExecutionContext } from '@ensemble-edge/conductor'

export default function validateScrapedData(context: AgentExecutionContext) {
  const { data } = context.input
  return {
    valid: data.title && data.title.length > 0,
    data
  }
}

outputs:
  data: ${validate.output.data}
  valid: ${validate.output.valid}

​
Best Practices

  1. Start with Starter Kit - Try Starter Kit agents first
  2. Configure Don’t Customize - Use inputs before building custom
  3. Wrap for Extensions - Create custom agents that wrap Starter Kit agents
  4. Version Independently - Version custom wrappers separately
  5. Test Thoroughly - Test custom integrations
  6. Document Usage - Document how you use Starter Kit agents
  7. Monitor Performance - Track Starter Kit agent performance
  8. Report Issues - Report bugs to Conductor team

​
Next Steps

Starter Kit Reference

Detailed docs for each agent

Creating Agents

Build custom agents

Writing Ensembles

Orchestrate agents

Playbooks

Real-world examples