Overview - Ensemble Edge

What It Is

Two open-source tools that work together:

Edgit - Git-native versioning for AI components (prompts, configs, queries, scripts)
Conductor - Edge orchestration framework that runs AI workflows on Cloudflare Workers

Plus a future managed service:

Ensemble Cloud - UI layer for managing components and workflows (Git remains the source of truth)

The Philosophy

You’re a self-respecting engineer. You know SQL. You write code. You understand infrastructure. You don’t need a “no-code AI platform” that abstracts away control. You don’t want some black box that a business analyst picked because the demo looked shiny. You want:

Full control over your AI workflows
Git as the source of truth
No vendor lock-in
Fast execution at the edge
Independent versioning for every component
The ability to A/B test anything
Instant rollbacks without redeploying everything

How It Works

1. Components (The Building Blocks)

Components are versioned artifacts that agents use during execution:

Prompts (.md) - AI instructions and templates
Configs (.json, .yaml) - Settings and parameters
Queries (.sql) - Database queries
Scripts (.js, .ts) - Reusable functions
Schemas (.json) - JSON Schema for structured AI outputs

Each component gets its own version history via Git tags. You can mix and match optimal versions from different points in time.

# Create independent versions
edgit tag create extraction-prompt v1.0.0
edgit tag create analysis-config v2.1.0
edgit tag create validation-query v0.5.0

# Tag versions to environments
edgit tag set extraction-prompt prod v1.0.0
edgit tag set analysis-config prod v2.1.0
edgit tag set validation-query prod v0.5.0

# Push tags to trigger deployment
edgit push --tags --force

2. Agents (The Workers)

Agents are executable units that perform tasks using operations and components:

agents:
  - name: analyzer
    operation: think              # AI reasoning
    component: prompt@v2.1.0      # Versioned prompt
    config:
      model: claude-3-5-sonnet-20241022
      temperature: 0.7

  - name: fetcher
    operation: http               # HTTP requests
    config:
      url: https://api.example.com/data
      cache_ttl: 3600

  - name: processor
    operation: code               # Custom logic
    script: transform@v1.5.0      # Versioned script

3. Ensembles (The Orchestration)

Ensembles are YAML files that coordinate agents into workflows:

ensemble: company-intelligence

agents:
  - name: fetch-data
    operation: http
    config:
      url: https://api.example.com/companies/${input.domain}

  - name: analyze
    operation: think
    component: analysis-prompt@v2.1.0
    input:
      data: ${fetch-data.output}

  - name: score
    agent: validator         # Use starter kit agent
    input:
      content: ${analyze.output}

Ensembles execute at the edge on Cloudflare Workers with <50ms cold starts.

Key Benefits

Independent Versioning

Version components and agents separately. Deploy optimal combinations:

# Stable agent + experimental prompt
analyzer@v1.0.0 + analysis-prompt@v3.0.0-beta

# Latest agent + proven prompt
analyzer@v2.1.0 + analysis-prompt@v1.0.0

# Run both in parallel for A/B testing

Edge Execution

Workflows run on Cloudflare’s global network:

<50ms cold starts (not seconds like traditional orchestrators)
200+ locations worldwide
Infinite scale without managing servers
Built-in caching via KV and AI Gateway

Git-Native

Everything lives in Git:

Components versioned via Git tags
Ensembles are YAML files in your repo
Agent definitions are code in your repo
No proprietary storage, no vendor database

Observable

Every execution emits structured logs and metrics:

Trace agent execution
Monitor performance
Debug issues
Track costs

What Makes This Different

vs. Traditional Orchestrators (Airflow, Temporal, Prefect)

Them: Centralized servers, slow cold starts, complex deployment Us: Edge-native, <50ms cold starts, deploy like any Cloudflare Worker

vs. AI Platforms (LangChain, LlamaIndex agents)

Them: Monolithic versioning, no independent component versions Us: Each component versions independently, mix optimal versions from history

vs. “No-Code” Tools

Them: Black box, vendor lock-in, UI-driven config in their database Us: Full control, Git as source of truth, code-first with optional UI

vs. Workflow Tools (n8n, Zapier)

Them: Visual builders, JSON config, centralized execution Us: YAML in Git, edge execution, developer-first

Architecture Overview

Components (Git Tags)
    |
    v
Agents (Operations + Components)
    |
    v
Ensembles (YAML Workflows)
    |
    v
Conductor Runtime (Cloudflare Workers)
    |
    v
Edge Execution (200+ locations)

Three layers, cleanly separated:

What you version - Components (Edgit manages this)
What executes - Agents (Conductor orchestrates this)
How it flows - Ensembles (YAML defines this)

Use Cases

Company Intelligence

Scrape company data and analyze financials and generate reports and store results. Agents: HTTP + Think (AI) + Storage

Email Processing

Parse emails and classify intent and route to handlers and send responses. Agents: Email + Think (classification) + HTTP + storage

Document Intelligence

Extract data from PDFs and validate quality and require human approval and store records. Agents: PDF + Think (extraction) + validator + HITL + storage

RAG System

Index documents and perform semantic search and generate contextualized answers. Agents: RAG (starter kit) + Think (generation) + vectorize

A/B Testing

Test prompt versions and agent implementations and model configurations in parallel. Feature: Version multiverse - run multiple variants simultaneously

Next Steps

5-Minute Quick Start

Get running in 5 minutes

Core Concepts

Deep dive into components, agents, and ensembles

Edgit Documentation

Component versioning system

Conductor Documentation

Edge orchestration framework

​What It Is

​The Philosophy

​How It Works

​1. Components (The Building Blocks)

​2. Agents (The Workers)

​3. Ensembles (The Orchestration)

​Key Benefits

​Independent Versioning

​Edge Execution

​Git-Native

​Observable

​What Makes This Different

​vs. Traditional Orchestrators (Airflow, Temporal, Prefect)

​vs. AI Platforms (LangChain, LlamaIndex agents)

​vs. “No-Code” Tools

​vs. Workflow Tools (n8n, Zapier)

​Architecture Overview

​Use Cases

​Next Steps