DEV Community: Dickson Kanyingi

ClawFlow — The Deterministic Execution Backend OpenClaw Agents Need

Dickson Kanyingi — Fri, 24 Apr 2026 00:04:55 +0000

(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.

From Chatbots to Coworkers: How Google Cloud NEXT ’26 Redefined Software as Agent Systems

Dickson Kanyingi — Thu, 23 Apr 2026 23:28:44 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

I expected Google Cloud NEXT '26 to be about better AI models and more powerful APIs. Instead, it quietly introduced something bigger: software that no longer waits to be used—it acts on its own. I didn’t expect a complete rewrite of how we build software. And once you see it through an agent system, you can’t unsee what software is becoming next.

For this challenge, I focused on the Developer Keynote—specifically the shift toward the Agentic Enterprise and systems designed to coordinate thousands of AI agents.

Instead of just analyzing it, I tried to answer a more practical question:

What happens if you actually build something using this mindset today?

This triggered me into building an agent system that coordinates multiple AI agents to handle complex tasks. The result was a system that not only processes requests but also learns from them, adapts its behavior, and operates with a level of autonomy that feels almost like having a team of coworkers as we will see in the following sections.

🧠 The Shift: From Features → Systems That Act

The biggest idea wasn’t a tool. It was a mental model shift.

We’re moving from:

Request → Response (user asks, system replies) to:
Goal → Execution (user defines outcome, system figures out how)

This sounds subtle—but it changes everything.

Software is no longer just something you use. It’s something that acts on your behalf.

Key Shift: We’re moving from stateless requests to systems that persist, plan, and execute.

⚠️ The Real Problem: The “Integration Tax”

Before this keynote, AI already felt powerful—but fragmented. If you wanted to automate something like invoice processing, you still had to:

parse emails
connect to your ERP
trigger workflows
handle approvals

Every step required glue code.
What Google is really solving: Orchestration at scale. Not smarter chatbots—but systems that:

maintain context
coordinate actions
operate across tools

🧩 Why “Many Agents” Changes the Game

One large AI system sounds powerful—but it’s fragile.

Problems:

hard to debug
hard to trust
fails all at once

The alternative introduced at NEXT: Modular intelligence (multi-agent systems)

Instead of one brain, you build a team:

Finance Agent
Ops Agent
Communication Agent

Each:

has a clear role
can be tested independently
can fail safely

This is essentially: Microservices… but for reasoning

🛠️ I Tried It: Building My First Multi-Agent System After Google Cloud NEXT '26

A Practical Implementation of a Simple Multi-Agent Workflow.

To ground this idea, I designed a small but realistic system:

“Meeting → Action” Pipeline

Goal: Turn a meeting into structured execution automatically.

Architecture

[Google Meet Transcript]
        ↓
[Scribe Agent]
  - Summarizes discussion
  - Extracts key decisions
        ↓
[Task Agent]
  - Converts decisions → tasks
  - Assigns owners + deadlines
        ↓
[Manager Agent]
  - Reviews tasks
  - Requests human approval
        ↓
[Execution Layer]
  - Creates Jira tickets
  - Sends emails
  - Updates calendar

While this is a conceptual build, mapping it out exposed something quickly:

Coordination—not intelligence—becomes the bottleneck.

How This Maps to NEXT ’26 Concepts

1. Persistent Context (Memory Bank)

Each agent retains:

meeting history
past decisions
previous tasks

👉 No need to resend context every time.

2. Agent Identity

Each agent has:

a unique identity
defined permissions

Example:

Task Agent → can suggest tasks
Manager Agent → can approve execution

This is critical. Without identity, automation becomes unsafe.

3. Agent-to-Agent Communication

Instead of APIs like:

POST /create-task

We move toward:

TaskAgent.handle("Generate tasks from this summary")

👉 Communication is based on intent, not just data.

More importantly, this is where emerging standards like Model Context Protocol (MCP) come in—allowing agents to consistently access tools, data, and context across systems.

If MCP (or something like it) wins, it could become the foundation for cross-platform agent interoperability.

What Changed for Me as a Developer

This experiment exposed something important:

I wasn’t writing logic anymore.
I was designing behavior.

Instead of:

functions
endpoints
workflows

I was defining:

roles
goals
constraints

⚡ Infrastructure Insight: Always-On Systems

One of the most overlooked announcements was the split between training and inference infrastructure.

Training systems → build intelligence
Inference systems → run it continuously

The real shift:

Compute is becoming continuous, not event-driven.

This shift is reinforced by hardware like TPU 8i, which is optimized for low-latency reasoning loops—making always-on agents economically viable.

In my system:

agents don’t wait for input
they monitor for triggers
they act proactively

The Hidden Power Move: Workspace as a Knowledge Layer

Another subtle—but huge—idea:

Your productivity tools are becoming structured memory for agents.

Think about it:

Docs → decisions
Gmail → intent
Calendar → commitments

When connected, this becomes: a living graph of organizational knowledge

In my pipeline:

the Scribe Agent isn’t just summarizing
it’s linking context across tools

🔐 Reality Check: What Breaks First

Let’s be honest—this model isn’t production-ready at scale yet.

1. Orchestration Debt

With many agents:

responsibilities overlap
actions conflict
systems become unpredictable

Example:

one agent schedules a task
another cancels it due to “priority changes”

Key Risk: Scaling agents without structure creates orchestration debt faster than teams can manage it.

2. Debugging Complexity

When something fails:

there’s no clear stack trace
decisions are distributed

You’re debugging:

interactions, not code

3. Security Risks

New attack surface:

malicious inputs
indirect prompt injection
unintended execution

Example:

An agent reads a message that contains hidden instructions and executes them.

⚠️ The Missing Piece: Interoperability

One thing the keynote didn’t fully address:

What happens when agents from different ecosystems need to collaborate?

Right now:

systems are platform-specific
protocols are not standardized

This suggests something inevitable: A future Agent Protocol War

🧨 The Big Realization

After building even a small system, one thing became clear:

We’re not scaling AI anymore.
We’re scaling behavior.

And behavior is much harder to control.

Most teams adopting agents today will fail—not because of AI limitations, but because they underestimate orchestration complexity.

Final Take: The Trust Model Must Change

Would I trust a single autonomous agent with critical decisions? No.

Would I trust a system of agents? Yes—with structure.

Example:

Agent A proposes
Agent B validates
Human approves

Trust emerges from coordination, not intelligence.

🏁 Conclusion: A New Role for Developers

This is the real takeaway from Google Cloud NEXT '26:

We are no longer just building applications.

We are designing systems that act, collaborate, and decide.

The developer’s job is shifting from writing instructions, to:

defining intent
setting boundaries
orchestrating behavior

If this direction holds, debugging production systems may look less like reading logs—and more like auditing decisions made by autonomous actors.

We’re not just writing software anymore.
We’re programming organizations.

#googlecloud #ai #machinelearning #cloudcomputing #softwarearchitecture #systemdesign #devops #futureofwork #artificialintelligence

EcoOS Intelligence: Reimagining Sustainability with AI

Dickson Kanyingi — Mon, 20 Apr 2026 03:21:21 +0000

This is a submission for Weekend Challenge: Earth Day Edition

What I Built

What if every daily decision showed its carbon cost before you made it?

Built for the DEV Earth Day Challenge, EcoOS Intelligence is a real-time, AI-powered system that transforms sustainability from abstract awareness into clear, measurable action.

Instead of static calculators, EcoOS acts as a behavioral operating system for climate action—helping users understand, simulate, and improve their impact across everyday life.

⚡ What Makes This Different?

Most climate tools tell you what happened.

EcoOS shows you what will happen before you act.

🧠 AI reasoning engine → breaks down lifestyle into real CO₂ impact
🎯 What-if simulator → test decisions before committing
💬 Personal AI coach → adapts to your behavior over time
♻️ Image-based waste analysis → classify real-world waste instantly
🏆 Gamified system → turns sustainability into daily action

👉 This is not a tracker. It's a decision-making system.

🧩 The Problem

People care about sustainability—but don't act consistently.

Why?

Data is complex and hard to interpret
Tools are passive (no feedback loop)
Advice is generic and not personalized
Impact is invisible in daily decisions

👉 The gap isn't awareness—it's actionability.

💡 The Solution: EcoOS Intelligence

EcoOS is a modular ecosystem focused on turning intention into action across the most impactful areas of personal sustainability:

🌱 Carbon Mirror — The Intelligence Engine

Describe your lifestyle in plain English. Gemini performs multi-step reasoning:

Decomposition — Parse activities into discrete categories
Category Scoring — Estimate CO₂ using established emission factors
Synthesis — Compute confidence-weighted totals
Recommendations — Generate prioritized, quantified action plans
JSON Schema Validation — 6 custom validators ensure structured, type-safe responses
Multi-Platform Sharing — Share results to X/Twitter, Facebook, LinkedIn, or copy for Instagram & TikTok

🎯 What-If Simulator — The "Wow" Feature

Ask "What if I stop using Uber for a month?" and get:

Timeline projections (1 month, 6 months, 1 year)
Money saved alongside CO₂ saved
Tangible equivalences (trees, flights, driving distance)
Community scale — "If 10,000 people did this..."

💬 Carbon Coach — Your AI Advisor

A conversational AI that remembers your history:

Knows your eco-score, past analyses, completed quests
Gives realistic, specific advice — not generic platitudes
Persists conversations across sessions
Adjusts your eco-score based on engagement

🏆 Eco-Quest — The Behavior Engine

AI-generated daily challenges that adapt to what you've already done:

Never repeats previously completed quests
Every mission includes quantified impact metrics
Points system feeds into your overall sustainability grade

♻️ WasteWise Vision (The "WOW" Multi-Modal Feature)

Image-based waste classification powered by Gemini 2.0 Flash's visual reasoning.

Upload or drag-and-drop a photo of your waste.
Gemini visually decomposes the materials, checks for contamination, and provides the exact disposal category.

🚗 EcoRoute

Transport optimization comparing 9 modes (Car, EV, Motorcycle, Bus, Train, Bike, Walk, Plane, Boat) with annual projections and community scale impact.

Demo

Live Demo: EcoOS.vercel.app

📸 Visual Walkthrough

Feature	Screenshot
🌱 Carbon Mirror - AI-powered lifestyle analyzer (travel, home energy, diet, consumption) - Real-time emission calculations with category breakdowns - Historical trend tracking (week-over-week progress) - Smart insights highlighting biggest impact areas
🎯 What-If Simulator - Scenario modeling before making decisions - Side-by-side comparison (CO2, cost, time) - Visualize savings from lifestyle changes - Save scenarios + track predicted vs actual outcomes
♻️ WasteWise - Image-based waste classification (on-device) - Categorizes: recycle, compost, landfill, special disposal - Location-aware recycling guidance - Preparation tips (rinse, labels, flatten, etc.)
🚗 EcoRoute - 9-mode transport comparison (walk, cycle, EV, transit, etc.) - CO2, cost, duration, calorie metrics - Route optimization (lowest emissions or fastest) - Multi-leg trip builder
💬 Carbon Coach - Personalized AI sustainability advisor - Weekly challenges with tracking + reminders - Milestones, badges, and impact stats - Adaptive recommendations as habits improve
📊 Dashboard - Centralized sustainability overview - Interactive charts (carbon, water, waste) - Goal tracking with custom targets - Quick actions + recent activity widgets

🎥 Quick Demo Flow (2 minutes)

Carbon Mirror → Describe your lifestyle → watch real-time breakdown
What-If Simulator → "What if I stop using Uber for a month?" → see yearly impact
Carbon Coach → Ask anything → get personalized advice
WasteWise → Upload an image → get disposal guidance
Dashboard → See your eco-score evolve

👉 Full flow takes under 2 minutes.

Code

GitHub: github.com/kanyingidickson-dev/EcoOS

How I Built It

🧠 Best Use of Google Gemini: Built for Reliability

For a tool like EcoOS, speed and reliability are everything. We built a production-grade AI reasoning engine with multi-layered resilience — not just a chat wrapper.

1. Structured JSON Mode

Every response uses responseMimeType: "application/json" for 100% reliable UI rendering:

{
  "estimate": 245,
  "confidence": "medium",
  "breakdown": [
    { "category": "Transport", "value": 120, "detail": "Daily 20km commute" },
    { "category": "Food", "value": 75, "detail": "Occasional meat consumption" }
  ],
  "suggestions": [
    "Switch to public transit 3 days/week — saves ~48kg CO2/month",
    "Adopt plant-based meals on weekdays — saves ~35kg CO2/month"
  ]
}

2. Multi-Step Reasoning (Chain-of-Thought)

Every prompt follows a structured pipeline, not a simple "input → output":

STEP 1 — DECOMPOSITION: Parse input into categories
STEP 2 — SCORING: Estimate using emission factors
STEP 3 — SYNTHESIS: Confidence-weighted totals
STEP 4 — RECOMMENDATIONS: Prioritized by impact

3. Response Validation & Reliability

6 custom validators ensure every response has correct structure
Numeric sanitization prevents NaN/undefined from reaching the UI
Retry with exponential backoff before graceful mock fallback
12-second timeout prevents UI hangs on slow networks

4. Personalization Engine

The system adapts over time:

Stores carbon history, waste scans, quest completions, coach topics
Injects user context into every AI prompt
Quest generator explicitly avoids repeating past challenges
Coach references your previous analyses in conversation

5. Model Cascade with Automatic Failover

Production resilience through tiered fallback when quotas are hit:

Gemini 2.5-flash (primary) → Gemini 2.0-flash (fallback) → Intelligent Mock (offline)

6. Request Optimization

Performance optimizations for scale and cost-efficiency:

In-memory caching: 5-minute TTL eliminates redundant API calls for identical inputs
Token usage logging: Cost monitoring for every API call

7. Circuit Breaker Pattern

Quota protection prevents cascade failures:

Automatic detection of rate limit (429) errors
5-minute cooldown after 2+ quota errors
Graceful degradation to intelligent mock responses without user interruption

8. Mock Fallback System

Even without an API key, the entire app remains functional with intelligent mock data that matches the exact JSON schema — perfect for offline demos and development.

🧪 Built for Real-World Constraints

EcoOS is designed to work even under API limits:

Works without an API key (intelligent fallback system)
Handles rate limits gracefully (circuit breaker)
Prevents UI failures with strict JSON validation
Optimized for low-cost, high-efficiency AI usage

👉 This ensures reliability in real-world conditions—not just ideal demos.

🧪 Testing & Quality Assurance

10 test files with 51+ tests covering validators, sanitization, and UI components
Response validation tests ensure Gemini JSON schema compliance
Mock fallback tests verify 100% offline functionality
Vitest + React Testing Library for fast, reliable test execution

🎨 Design Strategy: Premium Sustainability

We avoided the "clinical" look of traditional carbon tools. Instead, we built a high-end, dark-mode experience:

Animated SVG Ring Score — real-time eco-grade with glow effects
Glassmorphism — translucent cards with backdrop blur
Framer Motion — spring animations, staggered reveals, page transitions
Custom Slider — gradient thumb with glow shadow
Micro-Interactions — points popup, toast notifications, pulsing badges
Outfit + Inter fonts — modern, premium typography

🎥 Demo Flow

Dashboard → See the animated ring score and live community feed
Carbon Mirror → Describe your lifestyle → Watch the breakdown animate
What-If → Try "What if I go vegetarian?" → See yearly projections
Coach → Notice it says "I already know your history" → Get personalized advice
Dashboard → Your eco-score has increased ✨

🌍 Impact

Metric	Per User	At Scale (10K users)
CO₂ Awareness	Instant footprint visibility	245,000 kg CO₂ analyzed/month
Behavior Change	Personalized action plans	10,000+ daily eco-quests
Decision Support	What-if before you commit	Collective behavior shift

🚀 Future Vision

City-level integrations — aggregate neighborhood sustainability data
Carbon credit marketplace — earn real credits from verified behavior changes
Smart home integration — automated energy tracking via IoT
Corporate partnerships — employee sustainability programs

Built with 💚 for the planet.

Prize Categories

Best use of Google Gemini
- Why Gemini 2.5 Flash? It's fast, cost-effective, and perfect for real-time interactions. The AI Magic behind the scenes makes it feel alive and responsive.

#devchallenge #earthday #gemini #sustainability #nextjs #ai

# The Useless Machine™ 🫖 - A Premium Enterprise SaaS That Solves Absolutely Nothing

Dickson Kanyingi — Sat, 04 Apr 2026 17:09:32 +0000

This is a submission for the DEV April Fools Challenge

What I Built

The Useless Machine™ is a satirical, high-fidelity, and intentionally dysfunctional web application that presents itself as a premium, hyper-optimized enterprise SaaS dashboard. But every single feature is a carefully engineered betrayal of user experience.

With 22 interconnected sub-apps and the Premium Chaos v3.0 engine, it scales its dysfunction across four distinct phases (chaos engines):

Phase	Name	Behavior
1	Pristine	Perfect Glassmorphism. Smooth animations. Looks enterprise-ready.
2	Suspicious	Subtle UI wobbles. Fake AI sentience alerts. "The Watcher" starts staring harder.
3	Unstable	Evasive buttons activate. Flashbangs happen. Teapots rain from the sky.
4	Meltdown	Screen flips 180°. Rage-click triggers Panic screens, elements teleport. Full BSOD simulated.

Key "Features"

🧠 AI Code Surgery — Reviews your code and "fixes" it by adding useless complexity and renaming every variable to teapot

🎭 Watcher v3 (3D) — A Three.js mascot with eyeballs that track your cursor and jitter nervously in chaos mode

🫖 Larry Mode — Type larry anywhere to activate a global MutationObserver that replaces ALL text with 418: I'm a teapot

☕ Teapot Server — An interactive console that violently refuses coffee requests and redirects all traffic to /dev/null

🎯 Evasive Buttons — High-stakes buttons (like "Delete Account") use spring physics to physically jump away from your cursor

🎊 Tea Rain — Type tea to trigger a canvas-confetti storm of boba and teapots

Demo

👉 Live App: The Useless Machine: https://useless-machine.vercel.app
(Warning: May cause existential debugging and high-pitched ringing)

Code

All the terrible decisions are open source: repo@github/useless-machine.git

How I Built It

Tech Stack (Over-Engineered for Nothing)

Vite + React 19 — For that "fast but useless" developer experience
Framer Motion 12.38 — Gesture-driven chaos, evasive buttons, shared layout transitions with spring physics
React Three Fiber 9.5 + @react-three/drei 10.7 — 3D cursor-tracking mascot with WebGL
Three.js 0.183 — The 3D engine powering The Watcher eyeballs
Canvas Confetti 1.9.4 — High-performance "Tea Rain" particle physics
Web Audio API — Synthesizes dramatic buzzes, panic drones, and 17+ MP3 sound effects
Vanilla CSS — Premium glassmorphism aesthetic for maximum betrayal

Animation Architecture

The chaos system uses a phased approach based on user interaction count:

// Phase detection in App.jsx
const [phase, setPhase] = useState(1);
const [interactionCount, setInteractionCount] = useState(0);

useEffect(() => {
  const newPhase = Math.min(4, Math.floor(interactionCount / 15) + 1);
  setPhase(newPhase);
}, [interactionCount]);

Phase 1 (Pristine): Clean animations, no chaos
Phase 2 (Suspicious): Subtle glitches, text wobbles
Phase 3 (Unstable): Evasive buttons activate, flashbangs trigger
Phase 4 (Meltdown): Screen rotation, UI melting effects

Key Technical Achievements

Evasive Buttons: Spring physics calculation to calculate "escape" vectors from cursor position
3D Eye Tracking: Mouse position mapped to Three.js spherical rotations in real-time
Global Larry Mode: MutationObserver intercepts ALL DOM text node changes and replaces content
Panic Mode: Click velocity detection (>10 clicks/second) triggers meltdown sequence
Tea Rain: Hardware-accelerated canvas particles with emoji sprites
MP3 Audio System: 17 royalty-free sound effects with AudioContext management

Prize Category

🫖 Best Ode to Larry Masinter (RFC 2324)

This project doesn't just reference teapots—it enforces them:

Global Teapot Mutation: The larry Easter egg trigger forces a system-wide "Teapot Only" state. A MutationObserver intercepts ALL DOM text updates and replaces them with 418: I'm a teapot.
Teapot Rain: A high-performance particle system (canvas-confetti) that rains teapots when "tea" is detected.
Bug Reports: Every Jira-style ticket is prefixed with TEA-4180.
418 Server: A dedicated terminal simulation that only returns teapot status codes.
Strict RFC 2324 Compliance: Every error is 418. Every API response is a teapot. The HTTP Server component only serves 418 I'm a teapot responses.
Hyper-Premium Hostility: The contrast between the beautiful glassmorphism UI and the aggressive dysfunction creates a unique UX comedy that honors the absurdity of HTCPCP.
The Watcher: A 3D mascot that judges your lack of productivity in real-time, staring at your cursor with judgmental red pupils.

The entire application is essentially a love letter to the most famous HTTP status code that should have been: 418 I'm a teapot.

Easter Eggs to Try

Konami Code: (↑ ↑ ↓ ↓ ← → ← → B A) — Activates "Useful Mode" only to immediately delete itself
Panic Alert: Click the background rapidly 10+ times to trigger meltdown
The Larry Truth: Type larry on your keyboard at any time
Tea Rain: Type tea anywhere to trigger confetti storm
Self-Destruct: Find the ☢️ button in the footer... if you can catch it

🧠 Best Google AI Usage

I built this entire project in collaboration with Antigravity (Google's agentic AI coding assistant). Leveraging an AI to build something intentionally "useless" turned out to be a masterclass in prompt-driven chaos. We also implemented a Simulated Gemini Hub that mimics the UI of modern AI assistants but delivers confidently wrong advice with absolute certainty.

If it breaks, that's intentional. If it works, that's a bug. Built with React and an unreasonable amount of setTimeout().

🫖 RFC 2324 Compliant | ⚠️ Not Production Ready | 🎯 Zero Purpose Achieved

Project Valkyrie: AI-Powered Crisis Logistics & Response Hub (Notion Workspace)

Dickson Kanyingi — Sat, 07 Mar 2026 17:07:35 +0000

This is a submission for the Notion MCP Challenge

What I Built

Valkyrie is an AI-powered crisis response and logistics command center that uses the Model Context Protocol (MCP) to turn Notion into a real-time operations hub.

In modern logistics, "latency kills." When a natural disaster or geopolitical event occurs, operators lose precious minutes switching between news feeds, weather maps, and internal databases. Valkyrie solves this by:

Bridging external threat data with internal asset data via MCP
Autonomously staging incident responses in Notion for human approval
Maintaining relational integrity between incidents and affected assets

Key Features

Feature	Description
🔍 Autonomous Threat Monitoring	Scans simulated global feeds for risks near tracked assets
📋 Instant Incident Staging	Creates Notion pages with threat analysis and mitigation steps
🔗 Relational Asset Resolver	Maps coordinates to Notion Page IDs for data integrity
👤 Human-in-the-Loop	AI proposes solutions; humans approve and execute

MCP Tools Exposed

analyze_global_threats  → Check asset for threats, stage incident if detected
scan_all_assets         → Batch scan all tracked assets
get_asset_details       → Retrieve full asset information
list_all_assets         → List assets with risk levels (🔴🟡🟢)
find_nearest_safe_asset → Find rerouting destination during crisis

Video Demo

[Demo video - showing threat detection, incident staging, and human approval workflow]

Demo Workflow:

Ask AI: "Valkyrie, scan all assets for threats"
AI detects tropical storm near Singapore Hub
Incident page created in Notion with status "Awaiting Approval"
Operator reviews, changes status to "In Progress"
Crisis Response Playbook triggered

[Data Flow & Human-in-the-Loop Sequence - From threat detection to human approval]

Show us the code

GitHub Repository: kanyingidickson-dev/valkyrie-mcp-server

Tech Stack

MCP Server: TypeScript with @modelcontextprotocol/sdk
Notion API: v2022-06-28 with direct HTTP queries for database operations
Threat Simulator: Python FastAPI generating realistic crisis scenarios
Deployment: Docker Compose + GitHub Actions CI/CD

Project Structure

valkyrie-mcp-server/
├── src/                              # MCP server source code
│   ├── index.ts                      # MCP server entry point
│   ├── config.ts                     # Configuration management
│   ├── lib/                          # Core libraries
│   │   ├── assets.ts                 # Asset data utilities
│   │   └── assets.d.ts               # Type definitions
│   ├── tools/                        # MCP tool implementations
│   │   ├── index.ts                  # Tool exports
│   │   ├── analyze-threats.ts        # analyze_global_threats tool
│   │   ├── scan-assets.ts            # scan_all_assets tool
│   │   ├── get-asset-details.ts      # get_asset_details tool
│   │   ├── list-assets.ts            # list_all_assets tool
│   │   └── find-nearest-safe.ts      # find_nearest_safe_asset tool
│   └── types/                        # Type definitions
├── mock-api/                         # Threat simulator API
│   ├── valkyrie_mock_api.py          # FastAPI threat simulator
│   ├── requirements.txt
│   └── Dockerfile
├── scripts/                          # Orchestration & utility scripts
│   ├── seed_assets.py                # Populate Notion logistics DB
│   ├── clean_duplicates.py           # Remove duplicate assets
│   ├── scan_and_stage.js             # Scan assets and stage incidents
│   ├── trigger_and_stage.js          # Trigger threats and stage incidents
│   ├── notion_watcher.js             # Poll Notion for status changes
│   ├── webhook_server.js             # Handle Slack actions
│   ├── scheduler.js                  # Periodic scan scheduler
│   ├── notify.js                     # Notification utilities
│   └── requirements.txt
├── tests/                            # Test files
├── docs/                             # Documentation assets
│   ├── logical-overview.png
│   ├── deployment-overview.png
│   └── demo-workflow.png
├── .github/                          # CI/CD workflows
│   └── workflows/
│       └── valkyrie-deploy.yml
├── .data/                            # Local data storage
├── .husky/                           # Git hooks
├── dist/                             # Compiled output
├── package.json                      # Dependencies & scripts
├── tsconfig.json                     # TypeScript config
├── jest.config.cjs                   # Jest test config
├── .eslintrc.json                    # ESLint config
├── .prettierrc                       # Prettier config
├── docker-compose.yml                # Docker orchestration
├── Dockerfile                        # MCP server container
├── .env.example                      # Environment template
├── MCP_INSTRUCTIONS.md               # MCP usage guide
├── LICENSE
└── README.md

Key Code: Relational Asset Resolver

From src/lib/assets.ts:

// Maps external telemetry coordinates to Notion Page IDs
export async function queryNotionDatabase(
  databaseId: string,
  filter?: Record<string, unknown>
): Promise<NotionPageObject[]> {
  const res = await fetch(`https://api.notion.com/v1/databases/${databaseId}/query`, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.NOTION_TOKEN}`,
      'Content-Type': 'application/json',
      'Notion-Version': '2022-06-28',
    },
    body: JSON.stringify(filter ? { filter } : {}),
  });
  const data = await res.json();
  return data.results || [];
}

Incident Staging with Human-in-the-Loop

From src/tools/analyze-threats.ts:

// Creates Notion page with "Awaiting Approval" status
async function createIncidentPage(params: {
  assetName: string;
  assetPageId: string | null;
  category: string;
  summary: string;
  threatLevel: number;
}): Promise<string> {
  const threatLevelText = params.threatLevel >= 8 ? 'Critical (Red)' : 'Elevated (Yellow)';

  const incidentPage = await notion.pages.create({
    parent: { database_id: DASHBOARD_DB_ID },
    properties: {
      'Incident Name': {
        title: [{ text: { content: `🚨 ALERT: ${params.category} - ${params.assetName}` } }],
      },
      Status: { status: { name: 'Awaiting Approval' } },
      'Threat Level': { select: { name: threatLevelText } },
      'Affected Assets': { relation: params.assetPageId ? [{ id: params.assetPageId }] : [] },
    },
  });
  return incidentPage.id;
}

How I Used Notion MCP

The Integration

Valkyrie uses the Model Context Protocol to give AI assistants (like Windsurf's Cascade) direct access to Notion databases as tools. This unlocks:

Autonomous Database Queries - AI can query assets without manual API calls
Intelligent Incident Creation - AI stages responses with proper relations
Contextual Awareness - AI understands asset locations and risk profiles

Notion Database Schema

Operations Dashboard (Incidents DB)

Property	Type	Description
Incident Name	Title	Auto-generated: `🚨 ALERT: {Category} - {Asset}`
Status	Status	`Draft` → `Awaiting Approval` → `In Progress` → `Resolved`
Threat Level	Select	`Critical (Red)` / `Elevated (Yellow)` / `Stable (Green)`
Affected Assets	Relation	Links to Logistics DB for relational integrity
AI Assessments	Rich Text	Threat summary from simulation engine

Global Assets & Logistics DB

Property	Type	Description
Asset Name	Title	Unique facility identifier
Coordinates	Text	Latitude, Longitude (e.g., `1.2902, 103.8519`)
Risk Sensitivity	Number	1-10 scale for prioritization
Status	Select	`Active` / `Inactive` / `Maintenance`
Facility Type	Select	`Distribution Hub` / `Transport Node` / `Data Center`
Primary Contact	Text	On-site lead name
Primary Phone	Phone	Emergency contact number
Primary Email	Email	Escalation contact
Facility Manager	Text	Responsible party
Last Audit	Date	Compliance tracking

What This Unlocks

Zero-context-switching: Operators see threats and assets in one Notion workspace
AI-assisted decisions: AI proposes actions, humans approve
Relational data integrity: Incidents automatically link to affected assets
Real-time monitoring: Continuous scanning with instant notification

[Technical Component Stack - Docker containers for MCP Server and Mock API]

Try It Yourself

# Clone and setup
git clone https://github.com/kanyingidickson-dev/valkyrie-mcp-server.git
cd valkyrie-mcp-server
npm install

# Configure Notion
cp .env.example .env
# Add your NOTION_TOKEN and database IDs

# Seed assets
pip install -r scripts/requirements.txt
python scripts/seed_assets.py

# Run mock API
python mock-api/valkyrie_mock_api.py

# Build and run MCP server
npm run build
npm start

# Run a one-off scan:
node scripts/scan_and_stage.js

# Optional scheduler:
node scripts/scheduler.js

Add to your MCP client config:

{
  "mcpServers": {
    "valkyrie": {
      "command": "node",
      "args": ["/path/to/valkyrie-mcp-server/dist/index.js"],
      "env": {
        "NOTION_TOKEN": "your-token",
        "DASHBOARD_DB_ID": "your-dashboard-id",
        "LOGISTICS_DB_ID": "your-logistics-id"
      }
    }
  }
}

Files of interest

src/index.ts — MCP server entry point and tool orchestration
src/lib/assets.ts — Relational Asset Resolver implementation
src/tools/analyze-threats.ts — Threat detection and incident staging
mock-api/valkyrie_mock_api.py — FastAPI threat simulator
scripts/seed_assets.py — Populate Notion databases with sample assets
scripts/scan_and_stage.js — Batch scan + incident staging
scripts/trigger_and_stage.js — Single-target trigger + staging
scripts/scheduler.js — Periodic scan runner
scripts/notion_watcher.js — Notion status change listener
scripts/notify.js — Slack and email notifications
scripts/webhook_server.js — Action link handler for approvals

Notes

The system is intentionally conservative: AI stages incidents as Awaiting Approval for human review.
The repo includes seeding and demo scripts to make the submission easy to reproduce.

Acknowledgments

Notion for the MCP SDK and API
Model Context Protocol for the integration framework
DEV Community for the challenge platform

Built for the Notion MCP Challenge 2026 🚀