Dickson Kanyingi

Posted on Apr 24

ClawFlow — The Deterministic Execution Backend OpenClaw Agents Need

#devchallenge #openclawchallenge #typescript #cli

OpenClaw Challenge Submission 🦞

(OpenClaw = brain, ClawFlow = muscle)

The problem: AI agents are great at reasoning, but when you need something done reliably and instantly, they fall apart.

The solution: ClawFlow is a fast, deterministic execution layer that OpenClaw agents call for structured data transformation — parsing, validation, and workflow orchestration in milliseconds.

Submission for the OpenClaw Challenge

The Real-World Problem I Solved

Last week, I was building a startup idea tracker. I wanted to go from a messy voice memo to a structured product roadmap in seconds — without waiting 3-5 seconds for an LLM to "think" and possibly hallucinate.

Traditional approach: GPT-4 call → unpredictable output → retry logic → more latency → $0.02 per run.

My approach with ClawFlow: Voice memo → OpenClaw agent (decides intent) → ClawFlow deterministic pipeline → structured roadmap in < 5ms, 100% predictable, $0 cost.

This isn't about replacing AI. It's about giving AI agents a reliable execution layer for tasks that need precision, not creativity.

What I Built

ClawFlow is a production-ready execution backend that acts as the "muscle" to OpenClaw's "brain." While OpenClaw agents handle intent recognition and orchestration decisions, ClawFlow handles the deterministic work: parsing, transforming, validating, and structuring data.

Core Architecture

┌─────────────────┐     intent recognition       ┌──────────────────┐
│  OpenClaw Agent │ ───────────────────────────→ │  ClawFlow Engine │
│  (The Brain)    │  "Parse this task list"      │  (The Muscle)    │
└─────────────────┘                              └──────────────────┘
         │                                              │
         │    POST /api/webhook/openclaw                │
         │    { flow: "task", input: "..." }            │
         │←─────────────────────────────────────────────┘
         │         structured result (3-5ms)
         ▼
   ┌─────────────┐
   │   Action    │  ← agent makes next decision
   └─────────────┘

The 3 Killer Workflows

Here are the workflows that demonstrate ClawFlow's power:

Voice Memo → Structured Roadmap

Input: "Build landing page, setup auth urgently, deploy by Friday"

Pipeline: Clean-Claw → Task-Claw → Brain-Claw

Output: Structured product plan with prioritized phases
Error Log → Actionable Tasks

Input: Raw server logs

Flow: Debug-Claw

Output: Severity-classified issues with fix suggestions
Messy Data → Clean Structure

Input: Unformatted CSV, JSON, or text

Flow: CSV-Claw, JSON-Claw, or Clean-Claw

Output: Validated, normalized structured data

All 14 skills:

Flow	Icon	Description
Task-Claw	📋	Breaks input into actionable tasks with priority detection
Debug-Claw	🔍	Scans for error patterns with severity classification
Brain-Claw	🧠	Converts raw ideas into structured product plans
Clean-Claw	✨	Normalizes messy text with stats extraction
Summary-Claw	📝	Extracts key points using positional scoring
Calendar-Claw	📅	Extracts event details from natural language
Git-Claw	🐙	Parses git diffs and suggests commit messages
CSV-Claw	📊	Parses messy CSV to clean JSON
Email-Claw	📧	Drafts professional emails from bullet points
Note-Claw	📓	Formats markdown notes with keyword tagging
JSON-Claw	`{}`	Validates and formats JSON strings
Diff-Claw	↔️	Word-level text comparison
Sentiment-Claw	😊	Extracts emotional tone and sentiment score
Pipeline-Claw	⚡	Multi-stage workflow orchestration

Key Features (v2.1):

Feature	Description
OpenClaw Webhook Bridge	Native integration via `/api/webhook/openclaw` — agents send `{trigger_id, flow, input}`, receive structured results
14 Built-in Skills	Parsing, validation, and transformation without LLM unpredictability
Visual Claw Creator	Create custom claws in seconds — no coding required
11 Pre-built Templates	Task extraction, link parsing, JSON formatting, text transformation, and more
Visual Pipeline Builder	Chain skills into complex workflows at `/pipeline`
SQLite Persistence	Full execution history for agent memory and traceability
22-Test Suite	Production-ready reliability
Sub-5ms Execution	Fast enough for real-time agent loops

How I Integrated with OpenClaw

📖 Full Integration Guide: OPENCLAW_INTEGRATION.md — architecture diagrams, 3 concrete examples, routing strategies, and delegation rules.

1. The Webhook Bridge (Real Integration)

ClawFlow exposes an authenticated webhook endpoint that accepts standard OpenClaw task payloads:

# OpenClaw sends this to ClawFlow
POST /api/webhook/openclaw
Headers: { "x-api-key": "clawflow_prod_key" }
Body: {
  "trigger_id": "oc-999",
  "flow": "task",
  "input": "urgent: fix auth bug, deploy patch"
}

# ClawFlow returns structured result
{
  "bridge_version": "1.0",
  "trigger_id": "oc-999",
  "status": "completed",
  "execution_data": {
    "success": true,
    "duration": 3,
    "output": {
      "tasks": [
        { "title": "Fix auth bug", "priority": "high" },
        { "title": "Deploy patch", "priority": "normal" }
      ]
    }
  }
}

2. Example OpenClaw Agent Configuration

See openclaw.config.yml in the repo for a complete agent setup:

# OpenClaw agent that delegates parsing to ClawFlow
skills:
  - name: "parse_tasks"
    type: "webhook"
    endpoint: "https://clawflow.vercel.app/api/webhook/openclaw"
    headers:
      x-api-key: "${CLAWFLOW_API_KEY}"
    payload_template: |
      {
        "flow": "task",
        "input": "{{user_input}}"
      }

3. The CLI Trigger (Development Tool)

For local testing, the CLI sends OpenClaw-format payloads:

node trigger.js
# Simulates: POST /api/webhook/openclaw
# Payload: { trigger_id, flow, input }

Demo

Live: https://clawflow-engine.vercel.app/ →

Screenshots

Feature	Screenshot
Dashboard
Email-Claw
Pipeline Builder
Rich Output
CLI Trigger
Email-CLI

Quick Demo Flow:

Task-Claw → Input: "urgent: fix auth bug, deploy patch" → Structured tasks with priority
Debug-Claw → Paste error logs → Severity-classified issues with fix suggestions
Pipeline-Claw → Input messy text → Watch 3 stages execute with full trace

Simulated OpenClaw Trigger

The demo simulates an OpenClaw agent calling ClawFlow:

# Simulated webhook call (shown in demo terminal)
POST /api/webhook/openclaw
Content-Type: application/json
X-API-Key: clawflow_prod_key

{
  "trigger_id": "oc-2026-001",
  "flow": "pipeline",
  "input": "build an AI app for farmers..."
}

# Response: 3ms
{
  "status": "completed",
  "execution_data": { "tasks": [...], "plan": {...} }
}

How I Used OpenClaw

ClawFlow is designed as a complementary execution layer for OpenClaw. While OpenClaw orchestrates high-level workflows and agents, ClawFlow handles deterministic, low-latency task execution through modular "Claws."

I implemented a webhook bridge (/api/webhook/openclaw) that allows OpenClaw agents to trigger flows programmatically, effectively separating orchestration (OpenClaw) from execution (ClawFlow).

This architecture lets OpenClaw agents route simple, structured tasks to ClawFlow for fast, predictable execution (< 5ms, zero cost), while reserving LLM calls for tasks requiring reasoning and creativity.

What I Learned

AI agents need deterministic execution partners. OpenClaw agents excel at intent and orchestration, but they need reliable backends for data transformation. ClawFlow fills that gap.
Speed is a feature. At < 5ms execution, ClawFlow can run inside agent decision loops without blocking UX. LLMs take 1-5 seconds — that's unusable for real-time agent workflows.
Persistence unlocks agent memory. With SQLite, every execution is traceable. Agents can query history: "What did I parse yesterday?" → retrieve and continue workflows.
The OpenClaw skills model is elegant. Building a compatible execution engine gave me deep appreciation for the separation of concerns: agents decide what to do, skills determine how to do it.
No-code extensibility matters. By adding a visual Claw Creator with 11 pre-built templates, I made the platform accessible to non-developers while keeping the code-based extension path for power users. This "product-facing" approach makes the platform more compelling — anyone can click, create, and run immediately (from "developer-only" into "anyone can use this immediately").

🛠 QUICK Q&A's

Q: How does this actually integrate with OpenClaw?
A: ClawFlow exposes an authenticated webhook at /api/webhook/openclaw that accepts standard OpenClaw payloads. Agents send {trigger_id, flow, input} and receive structured results. See openclaw.config.yml for a complete agent configuration example.

Q: Why not just use an LLM for parsing?
A: Three reasons: (1) Speed — LLMs take 1-5 seconds, ClawFlow takes < 5ms, usable in real-time agent loops. (2) Reliability — deterministic output means agents can trust the structure. (3) Cost — zero API calls vs $0.02 per LLM invocation. It's about giving agents precision tools, not replacing AI.

Q: How extensible is it?
A: Two ways: (1) Visual Claw Creator — pick from 11 templates, name it, done. Instant, no-code. (2) Code path — create lib/flows/mySkill.ts, register in lib/flows/index.ts. The engine handles validation, timing, persistence, and webhook compatibility automatically. It's designed for both beginners and developers.

Q: Is this really using OpenClaw or just inspired by it?
A: This is a real integration. ClawFlow acts as an execution backend that OpenClaw agents can call via webhook. The CLI trigger demonstrates the exact payload format. The openclaw.config.yml shows how an agent would be configured to use ClawFlow as a skill provider.

Built with Next.js 15, TypeScript, SQLite, Drizzle ORM, and Tailwind CSS.

DEV Community