Using Starter Kit Agents

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

Start with Starter Kit - Try Starter Kit agents first
Configure Don’t Customize - Use inputs before building custom
Wrap for Extensions - Create custom agents that wrap Starter Kit agents
Version Independently - Version custom wrappers separately
Test Thoroughly - Test custom integrations
Document Usage - Document how you use Starter Kit agents
Monitor Performance - Track Starter Kit agent performance
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

​Available Agents

​Starter Kit Utility Agents

scrape

validate

fetch

slug

tools

queries

autorag

​Built-in Framework Agents

rag

hitl

​Quick Usage

​Scrape Agent

​Validate Agent

​RAG Agent

​HITL Agent

​Combining Starter Kit Agents

​Scrape + Validate + Transform

​RAG + HITL

​Customizing Starter Kit Agents

​Scrape with Retry

​Validate with Custom Rules

​RAG with Custom Embeddings

​When to Use Starter Kit vs Custom

​Use Starter Kit When:

​Build Custom When:

​Extending Starter Kit Agents

​Best Practices

​Next Steps