Cascade Platform Documentation

Application-as-Data Platform

Define entire business systems as structured YAML. Because applications are data (not code), LLMs understand them, visual tools render them, and Git versions them meaningfully.

Built on Temporal • LLM-Native • Autonomous Agents • Production-Ready

What is Application-as-Data?

Traditional development requires imperative code. Machines can’t understand intent, AI tools can’t safely modify it, and Git diffs show syntax changes rather than business logic.

Cascade takes a different approach. Applications are defined as structured YAML data. This enables LLMs to read and generate workflows, visual tools to auto-render diagrams, and Git to track meaningful business logic changes.

Code vs. Data Comparison

Traditional Approach: Imperative Code

// 500+ lines of orchestration logic
class OrderWorkflow {
  async execute(order) {
    const validated = await this.validate(order);
    if (!validated) throw new Error();
    const charged = await this.stripe.charge(order.amount);
    if (!charged.success) await this.compensate();
    // ... 450+ more lines
  }
}

Problems with imperative code:

• Machines cannot understand intent (limits AI/LLM capabilities)
• Cannot generate visual diagrams automatically
• Git diffs show syntax changes, not business logic
• Requires deployment to change business rules
• Agents cannot read or modify safely

Cascade Approach: Structured Data

# 50 lines of structured data
workflows:
  - name: order_processing
    start: ValidateOrder
    states:
      - name: ValidateOrder
        type: Task
        action: validate
        next: ChargeCard
      
      - name: ChargeCard
        type: Task
        action: stripe.charge
        retry: {max_attempts: 3}
        catch:
          - error: PaymentFailed
            next: Compensate
        next: Complete

Benefits of structured data:

• LLMs can read it - Clear structure with explicit intent
• LLMs can generate it - From natural language descriptions
• LLMs can optimize it - Suggest improvements automatically
• Visual tools auto-render - State machine diagrams from structure
• Git diffs make sense - Business logic changes are visible
• Non-developers configure - Via UI without deployment
• Agents can orchestrate - Read, modify, and execute workflows

Three Revolutionary Capabilities

1. AI-Native Development

Because applications are data, LLMs become first-class development tools.

2. Autonomous Agent Platform

Because workflows are data, agents can read and orchestrate them autonomously.

Agent Platform SDK Capabilities (v5.1):

Read-Only (7 capabilities):

• read.workflow - Access workflow state via JSONPath
• read.memory_kv - General key-value storage
• read.memory_conversation - Dialogue history
• read.memory_semantic - Vector-based knowledge
• read.database - Execute read-only SQL
• read.secrets - Access vault secrets
• evaluate.decision - Evaluate DMN/OPA policies

Write (9 capabilities):

• write.workflow - Update workflow state
• write.memory_kv / write.memory_conversation / write.memory_semantic - Store agent insights
• write.database / write.database_batch / write.database_transaction - Database writes
• execute.action - Call platform actions
• execute.connector - Invoke external systems

High-Privilege (2 capabilities, require approval):

• execute.workflow - Start new processes
• execute.workflow_cancel - Cancel workflows

Security: All capabilities controlled via OPA policies and RBAC

Learn more about Agent Platform SDK →

3. Visual Development Platform

Because everything is structured data, visual tools work automatically.

The Complete Platform Stack

What You Define (Declarative YAML)

# ONE language (CDL) for everything
• Workflows and orchestration
• Business rules (OPA/DMN)
• AI agents and capabilities
• Tests (E2E, integration, chaos)
• UI forms and validation
• Webhooks and triggers
• Configuration and policies

What Platform Provides

Result:

• You write: 5% (business logic only)
• Platform provides: 95% (infrastructure, security, scaling)
• Time to production: Hours, not weeks

Real-World Impact

Example: Order Processing System

Traditional Approach:

5,000+ lines of code:
- Orchestration logic: 2,000 lines
- State management: 1,000 lines
- Error handling: 800 lines
- Retry logic: 500 lines
- Testing framework: 700 lines

Cascade Approach:

426 total lines:
- Workflows (CDL): 300 lines
- Business rules: 100 lines
- Tests (YAML): 50 lines
- Integration code (Go): 26 lines

Impact:

• 92% less code than traditional BPM approach
• Zero orchestration code (100% declarative)
• Declarative tests (no Jest/pytest required)
• AI can generate most workflow definitions
• Visual tools work automatically from structure

See complete example →

The “Two Primitives” Mental Model

For 90% of workflows, you only need 2 patterns:

1. TASK - Execute Work Immediately

- name: ChargeCard
  type: Task
  resource: "urn:cascade:action:stripe.charge"

Duration: Milliseconds to seconds
Examples: API calls, agent analysis, policy decisions

2. WAITFORINPUT - Pause and Resume

- name: ManagerApproval
  type: Task
  resource: "urn:cascade:waitFor:human"

Duration: Minutes to months
Examples: Human approval, webhook callback, event arrival

Learn the Two Primitives in depth →

CSL: ASL Superset with Agent Extensions

Standard ASL Features (100% Support)

All 8 state types: Task, Choice, Parallel, Map, Pass, Wait, Succeed, Fail
JSONPath expressions (RFC 9535)
Error handling (Catch, Retry)
InputPath, ResultPath, ResultSelector
Execution context ($$. references)
AWS SDK validates syntax

Cascade Extensions

Why ASL Baseline?

• Industry standard (developers know it)
• AWS tooling works (visualizers, validators)
• Portability (export to Step Functions)
• Proven at scale (billions of executions)

Full CSL syntax reference →

Platform Capabilities

Cascade provides 35+ production-ready capabilities out-of-the-box:

Current Status: 35 capabilities, 30 fully implemented (85% coverage), 78% test coverage

View all capabilities in detail →

Start Building

Why Cascade?

Application-as-Data Foundation:

• Structured YAML (not code)
• Machine-readable (LLMs understand)
• Git-versionable (meaningful diffs)
• Visually renderable (auto-diagrams)

AI-Native Capabilities:

• LLM generation (prompt to app)
• LLM optimization (auto-improve)
• Agent orchestration (autonomous)
• Declarative tests (AI-readable)

Autonomous Agent Platform:

• Agents at ANY step
• 18+ platform capabilities
• Full orchestration SDK
• OPA-based security

Developer Experience:

• 92-98% less code
• 100% declarative
• Sub-1s hot reload
• Visual tools included
• Production-ready

Compare Cascade with alternatives →

Questions? → Discord  | GitHub 

Ready to build? → Install Cascade | View Examples