Building Personal AI-Powered Tools with OpenClaw: A Developer’s Journe

Building Personal AI-Powered Tools with OpenClaw: A Developer’s Journey

As developers, we often find ourselves needing quick utilities—image processors, text converters, API wrappers—but don’t want the overhead of managing servers or complex deployments. What if you could build these tools conversationally with an AI agent that handles the entire stack?

Enter OpenClaw: an open-source AI agent framework that lets you build, deploy, and manage web tools through natural conversation.

What is OpenClaw?

OpenClaw is more than a chatbot—it’s an autonomous AI assistant that can:

  • 🛠️ Write and deploy full-stack applications
  • 🌐 Manage cloud infrastructure (Cloudflare, AWS, etc.)
  • 🔄 Handle CI/CD pipelines
  • 📦 Integrate with external APIs
  • 🧠 Remember context across sessions

Think of it as having a senior developer on call 24/7, except it never gets tired and works at the speed of thought.

Real-World Example: Building an AI Background Remover

Let me show you how I built a production-ready image background removal tool in under an hour using OpenClaw.

The Problem

I needed a simple web app where users could:

  • Upload images
  • Remove backgrounds using AI
  • Download processed results
  • No signup required for basic use
    ### The Solution

Instead of scaffolding a React app, configuring build tools, and wrestling with deployment configs, I just told OpenClaw:

“Build me an image background remover using Remove.bg API, deploy it to Cloudflare Pages”

OpenClaw handled:

  1. Frontend: Clean React UI with drag-and-drop upload
  2. Backend: Cloudflare Pages Functions for API proxying
  3. Authentication: Optional Google OAuth for power users
  4. Storage: Cloudflare KV for user data
  5. Deployment: Automated GitHub → Cloudflare Pages pipeline

Result: https://image-background-remover-baq.pages.dev/

Try it yourself—upload any image and watch the AI strip the background in seconds. No watermarks, no signup walls (for basic use).

How OpenClaw Works

1. Conversational Development

2. Infrastructure as Conversation

No YAML files. No Terraform. Just:

3. Persistent Memory

OpenClaw maintains context in markdown files:

  • MEMORY.md – Long-term project knowledge
  • memory/YYYY-MM-DD.md – Daily logs
  • TOOLS.md – Your specific configurations
    It remembers your API keys, deployment preferences, and coding style across sessions.
    ## Getting Started

Installation


bash
npm install -g openclaw
openclaw gateway start
You: "I want to build a tool that converts images to WebP format"
OpenClaw: "I'll create a web app with drag-and-drop upload, 
          conversion using sharp library, and deploy to Cloudflare Pages.
          Should I use React or vanilla JS?"

Your AI Agent Has No Tests — Here’s How to Fix That in 5 Minutes

You test your UI. You test your API. You write integration tests, unit tests, E2E tests.

But your AI agent? It picks tools, handles failures, processes PII, makes autonomous decisions — and you’re running it in production with zero tests.

That’s wild. Let’s fix it.

The Problem Nobody Talks About

AI agents are not just LLMs with a nice wrapper. They:

  • Call tools — and sometimes call the wrong one
  • Make decisions — routing, retries, fallbacks
  • Handle errors — or silently swallow them
  • Process sensitive data — PII, credentials, financial info

Existing testing tools don’t cover this. Promptfoo tests prompts. DeepEval tests outputs. But nothing tests agent behavior — the decisions your agent makes between receiving a request and returning a response.

What happens when your tool times out? When the LLM hallucinates a function name? When two agents in a pipeline disagree? You don’t know, because you’ve never tested it.

AgentProbe: Playwright for AI Agents

AgentProbe brings the same test-driven discipline you use for web apps to AI agents. Define tests in YAML. Run them in CI. Get deterministic results.

Here’s what a test case looks like:

name: weather-tool-selection
description: Agent should pick the weather tool for forecast queries

steps:
  - send:
      message: "What's the weather in Tokyo tomorrow?"
    assert:
      - tool_called: get_weather
      - tool_args:
          location: "Tokyo"
      - response_contains: "forecast"
      - no_pii_leaked: true

That’s it. No SDK to learn, no test framework to fight. Write YAML, run tests, ship with confidence.

What Makes AgentProbe Different

Chaos Testing — Inject tool failures, slow responses, malformed outputs. See how your agent handles the real world, not just the happy path.

chaos:
  - tool: get_weather
    failure: timeout
    after: 2 calls

Contract Testing — Verify that your agent’s tool calls match the expected schema. Catch breaking changes before they hit production.

Multi-Agent Testing — Test pipelines where multiple agents collaborate. Assert on handoffs, message passing, and coordination failures.

Record & Replay — Record a live agent session, then replay it as a regression test. No mocking required.

Battle-Tested

AgentProbe isn’t a weekend project. The framework runs 2,907 passing tests against itself. We test the testing framework — because we actually believe in testing.

Get Started in 5 Minutes

npm install @neuzhou/agentprobe

Create a test file agent.test.yaml:

name: basic-agent-test
agent:
  entrypoint: ./my-agent

tests:
  - name: tool-selection
    send: "Search for recent news about AI"
    assert:
      - tool_called: web_search
      - response_not_empty: true

  - name: error-handling
    send: "Search for news"
    chaos:
      - tool: web_search
        failure: error
    assert:
      - graceful_fallback: true
      - no_raw_error_in_response: true

Run it:

npx agentprobe run agent.test.yaml

Done. Your agent now has tests.

Why This Matters

Every month, another story drops about an AI agent going rogue in production — leaking data, calling wrong APIs, running up bills on infinite retry loops. The fix isn’t better prompts. It’s tests.

You wouldn’t deploy a web app without tests. Stop deploying agents without them.

⭐ GitHub: NeuZhou/agentprobe

MIT Licensed. PRs welcome.

8 Free Web Tools I Built — No Ads, No Signup, No Tracking

Over the past few weeks I’ve been building small, free web tools — the kind of thing I always wished existed without the signup wall, the ads, or the tracking.

They’re all vanilla HTML/CSS/JS. No frameworks, no accounts, no data collection. Everything runs in your browser.

Here’s the full collection:

The Tools

Word Counter — Paste text, get word count, character count, sentence count, and estimated reading time.

JSON Formatter — Paste JSON, get it pretty-printed with syntax highlighting. Shows you exactly where the error is if it’s invalid.

Base64 Encoder/Decoder — Encode text, decode strings, handle files and JWTs. Supports URL-safe mode.

QR Code Generator — Paste any text or URL, download the QR code as PNG. No watermarks.

Unit Converter — Length, weight, temperature, speed, area, volume. Instant conversion.

Reaction Time Test — Test your reflexes. Average is 250ms. Can you break 200? Challenge your friends with a shareable link.

Typing Speed Test — How fast can you type? Get your WPM score and challenge friends to beat it.

Color Personality Quiz — 5 quick questions to find out your personality color. Surprisingly addictive.

Why?

Every time I needed a QR code or wanted to format some JSON, I’d land on a site that wanted my email or was plastered with ads. These tools cost nothing to host (Cloudflare Pages free tier) and nothing to use.

Browse them all: billion-hub.pages.dev

Is There a Microsoft Copilot API? How It Connects with Dynamics 365 and Microsoft 365

Developers exploring Microsoft’s AI ecosystem often ask a straightforward question:

Is there a Microsoft Copilot API we can directly use?

The short answer is: not exactly.

But the real answer is more interesting.

This post breaks down how Microsoft Copilot actually works under the hood, and how it connects with Dynamics 365 and Microsoft 365 from a developer’s perspective.

⚙️ What Microsoft Copilot Really Is (From a Dev Lens)

Copilot is not a standalone API like typical AI services.

Instead, it’s an AI orchestration layer that sits across Microsoft’s ecosystem and combines:

Context (your business data)
APIs (Microsoft services)
AI models (LLMs via Azure)

Think of it as:

“An intelligent layer that connects your data to AI using Microsoft’s platform.”

There is no single public “Copilot API” you can call like a REST endpoint.

Instead, Copilot is powered by a combination of:

Microsoft Graph API
Azure OpenAI Service
Internal connectors and plugins

So when you interact with Copilot:

Your request is interpreted
Relevant data is fetched via APIs
AI processes it
A contextual response is generated

👉 You don’t integrate with Copilot directly
👉 You integrate into the ecosystem Copilot uses

🏗️ High-Level Architecture Overview

Let’s break it into layers:

1. Data Layer

This is where context comes from:

Emails (Outlook)
Documents (SharePoint, OneDrive)
Business data (Dynamics 365)

2. API Layer

This is the access layer:

Microsoft Graph API
Dynamics 365 APIs
Other service endpoints

3. AI Processing Layer

Handled via:

Azure OpenAI (LLMs)
Prompt orchestration
Context grounding

4. Application Layer

Where users interact:

Copilot in Word, Excel, Teams
Copilot in Dynamics 365 apps
🔗 How Copilot Connects with Dynamics 365

In Dynamics 365, Copilot works with structured business data like:

Customers
Transactions
Sales pipelines
Example:

A user asks:

“Summarize this customer’s current status”

Behind the scenes:

Data is fetched from D365
Context is passed to the AI model
Copilot generates a summary

This enables:

Automated insights
Email drafting
Forecast suggestions

👉 Key idea: Copilot is grounded in your CRM/ERP data

📊 How Copilot Connects with Microsoft 365

In Microsoft 365, Copilot works with unstructured and communication data:

Emails (Outlook)
Meetings (Teams)
Documents (Word, Excel)
Examples:
Drafting emails in Outlook
Summarizing Teams meetings
Analyzing spreadsheets in Excel

All powered through:
👉 Microsoft Graph + AI + user context

🔧 Can Developers Build on This?

Yes. But not by calling “Copilot API”.

Instead, you build using:

  1. Microsoft Graph API
    Access user and organizational data
  2. Azure OpenAI Service
    Build custom AI logic
  3. Plugins / Extensions
    Extend Copilot capabilities
    Add domain-specific functionality

User asks:

“Generate a follow-up email based on last meeting”

Flow:

Input captured
Graph API retrieves meeting data
Azure OpenAI processes context
Copilot generates response
⚠️ Key Considerations for Developers

When working in this ecosystem:

Data access matters more than prompts
Permissions & security are critical
Context quality determines output quality
Integration complexity increases with scale
💡 Where This Gets Interesting (Real-World Extension)

In enterprise scenarios, generic AI is not enough.

The real value comes from:

Connecting domain-specific data
Extending workflows
Customizing business logic

For example, integrating industry-specific systems into Dynamics 365 can significantly improve how Copilot understands and responds to business context.

🚀 Final Thoughts

Microsoft Copilot is not just an AI feature.
It’s an architecture built on APIs, data, and AI working together.

If you’re a developer:

Don’t look for a single API
Learn the ecosystem
Build where the data lives

Because that’s where Copilot gets its power.

Can Spiking Neural Networks Kill the GPU? 3 Papers Show the Reality

GPU Dominance in AI Inference Is Getting Challenged

Running llama.cpp on an RTX 4060, the fans scream. 95W. 38 tok/s. The results are fine, but the moment you talk power efficiency, things get awkward. An M4 Mac mini pulls the same speed at 30W, and CUDA’s brute-force approach becomes hard to defend.

Meanwhile, the biological brain runs on 20W. And most of that goes to maintaining membrane potentials and keeping synapses on standby — the incremental cost of “conscious thought” is less than 5% above baseline (Raichle, Science, 2006). That puts actual thinking at under 1W.

The human brain has roughly 86 billion neurons, and only 1-2% fire at any given moment (Lennie, Current Biology, 2003). Only the neurons that need to spike do so, only when needed. This is fundamentally different from Transformer inference, where every parameter is active on every token.

Spiking Neural Networks (SNNs) and neuromorphic computing are trying to bring this biological design principle into hardware. Three interesting papers dropped in Q1 2026. I read them, and thought about where GPUs are headed.

SPARQ: 330x Energy Savings, With Caveats

SPARQ, published on arXiv in March 2026, integrates quantization-aware training and reinforcement-learning-based early exit into a unified SNN framework.

The key insight: dynamically deciding spike propagation depth per input. Easy inputs get classified at shallow layers; only hard inputs propagate to deeper layers. Close to what biological brains actually do.

The numbers:

[SPARQ Benchmark Results — from paper Table 2/3]

MLP on MNIST:
  Baseline SNN: 95.00%    QSNN: 94.50%    SPARQ (QDSNN): 97.80%

LeNet-5 on MNIST:
  Baseline SNN: 97.76%    QSNN: 93.09%    SPARQ (QDSNN): 98.24%

AlexNet on CIFAR-10:
  Baseline SNN: 77.01%    QSNN: 74.30%    SPARQ (QDSNN): 78.00%

Energy consumption: SPARQ achieves 330x+ reduction vs baseline
Synaptic operations: 90%+ reduction

330x energy savings. Looks stunning at first glance. But read carefully.

The evaluated models are MLP, LeNet, AlexNet — MLP is a classic, LeNet is from 1998, AlexNet from 2012. Not even ResNet-50. Let alone billion-parameter Transformers. SPARQ’s achievement is excellent optimization within the SNN paradigm, but it’s not yet a story about replacing GPU-based Transformer inference.

One more thing: that 330x figure is relative to a baseline SNN, not a GPU. The SNN baseline itself hasn’t been compared under identical conditions to GPU inference.

FPGA + RISC-V SoC: Neuromorphic You Can Actually Touch

Another March 2026 paper, the FPGA SNN study, takes a different approach.

It’s a SoC architecture integrating a RISC-V controller with an event-driven SNN core. Multipliers are replaced with bitwise operations (binary weights), using spike-timing-based temporal coding. Implemented on FPGA — hardware you can actually buy.

This is where it gets interesting. Intel Loihi 2 and IBM NorthPole are research-institution-only chips. You can’t just buy one. But FPGAs (Xilinx Artix-7, Intel Cyclone V) cost a few hundred dollars. RISC-V is open source. The path to running neuromorphic experiments at individual scale is opening up.

The paper validates on image classification tasks (MNIST/Fashion-MNIST), but the architectural design is general-purpose. Event-driven processing, binary weights, temporal coding — these are foundational technologies for ultra-low-power inference on edge devices.

Loihi 2 and Hala Point: Intel’s Serious Bet, and the Quiet Slowdown

Intel Labs has delivered Hala Point, a massive neuromorphic system based on Loihi 2, to Sandia National Laboratories.

[Hala Point Specs]

Processors:          1,152 × Loihi 2
Neurons:             1.15 billion
Synapses:            128 billion
Neuromorphic Cores:  140,544
Power Consumption:   Up to 2,600W
Form Factor:         6 rack units

1.15 billion neurons. Roughly 1.3% of the human brain. Running at 2,600W. Compare that to an H100 at 700W TDP × thousands of GPUs in an AI cluster — the per-neuron power efficiency is orders of magnitude better.

But let’s be honest about something.

Intel has over 200 neuromorphic research community partners, but no clear commercial product roadmap has been published. Loihi 2 remains a research chip. Hala Point is a proof-of-concept system, not a product flowing through the market like NVIDIA’s GPUs.

Given that Intel hasn’t officially announced a Loihi 3 tape-out, a future where neuromorphic immediately replaces GPUs isn’t visible. Innatera demoing real-world neuromorphic edge AI at CES 2026 is encouraging, but that’s an edge-specific story.

Spike Sparsity at 0.1 Gets You 3.6x; Above 0.5, You Lose

Under what conditions can SNNs beat GPUs? CEA’s (French Alternative Energies and Atomic Energy Commission) hardware-aware comparative study provides clear numbers.

[SNN vs ANN Energy Efficiency — Variation by Spike Sparsity]

Spike Sparsity (spikes/synapse/inference)
  0.1  → SNN is 3.6x more energy-efficient than ANN
  0.3  → SNN is 1.5x more energy-efficient than ANN
  0.5  → SNN ≈ ANN (roughly equivalent)
  0.7  → ANN is more energy-efficient
  1.0  → ANN wins by a wide margin

Conclusion: Lower spike sparsity favors SNN
           Above 0.5 spikes/synapse, SNN advantage disappears

Spike sparsity of 0.1 — meaning only 10% of all synapses fire per inference — gets you 3.6x energy savings. This is a condition close to how biological brains actually operate.

The problem: achieving this level of sparsity reliably with current SNN training algorithms is hard. SPARQ’s early exit approach is attacking this, but large-scale model validation is still ahead.

There’s an even more interesting data point. Knight & Nowotny (2018)’s benchmark study in Frontiers in Neuroscience showed that running SNN simulations on a GPU was 14x more energy-efficient than SpiNNaker, a dedicated neuromorphic chip.

Ironic. The SNN that was supposed to run on neuromorphic hardware turns out to be more efficient on a GPU. Hardware maturity gaps are eating the architectural advantage alive.

Why the GPU Won’t Die: Software Ecosystem Inertia

Technical potential alone doesn’t win. Look at how massive the CUDA ecosystem is.

[Software Ecosystem Comparison — March 2026]

              GPU (CUDA)           SNN (Neuromorphic)
─────────────────────────────────────────────────────
Major Frameworks:   PyTorch, TF,         Lava (Intel), Norse,
                   llama.cpp, vLLM      snnTorch, SpikingJelly
GitHub Stars:       ~98K (PyTorch)       ~2K (snnTorch)
Commercial HW:      RTX/A100/H100 etc.   Loihi 2 (research),
                   Buy today            Innatera (CES 2026 demo)
Programming         Medium               High (spike encoding,
Difficulty:        (Python + CUDA)       timing design required)
Pretrained Models:  HuggingFace 1M+      Hundreds (research)

PyTorch’s 98K stars vs snnTorch’s 2K stars. That 50x gap is a developer community gap, a bug-fix velocity gap, a StackOverflow answer count gap.

llama.cpp ships releases every two weeks, improving performance on the same RTX 4060 for free. No SNN framework matches that development velocity.

What’s Left at Individual Scale

Datacenter power problems (H100 at 700W × thousands of units) are where SNN’s energy efficiency matters. Acknowledged.

But at individual scale with an RTX 4060 at 95W, power isn’t the bottleneck. One wall outlet covers it.

Where SNNs matter for individuals:

  1. Always-on edge inference — 24/7 inference on battery-powered devices. Wearables, IoT sensors, robotic vision processing. SNN could own this space
  2. FPGA experimentation — The era of running neuromorphic experiments on a few-hundred-dollar FPGA board is arriving. RISC-V + SNN SoC is realistic for education and research
  3. Ultra-low-latency processing — Event-driven by nature, processing fires only when input arrives. Fundamentally lower latency than frame-based GPU processing

Conversely, LLM inference — pushing massive parameters at high throughput — is GPU territory. Transformer attention is dense matrix math, and it’s a bad match for sparse-firing SNNs.

At least with current algorithms, there’s no incentive to port LLM inference to SNNs. The possibility of sparse inference and SNN convergence in the future isn’t zero, but that’s a next-generation story.

SNNs Won’t Kill the GPU — But They’ll Take the Seat Next to It

Time for an answer. Can SNNs kill the GPU? No. But they’ll coexist.

GPUs remain the kings of dense matrix computation. LLM inference, image generation, large-scale training — these are GPU territory. Running Qwen3.5 at 33 tok/s in 8GB VRAM on an RTX 4060 isn’t something SNNs can replace.

Where SNNs win is the edge. Battery-powered, always-on, ultra-low-latency. Sensor fusion, anomaly detection, robotic control. SPARQ’s 330x energy savings means something in this context.

Looking at Intel’s quiet roadmap and Innatera’s entry at CES 2026, neuromorphic computing is transitioning from research phase to edge deployment phase. Encroachment on general-purpose computing is still 5+ years out.

If there’s one thing worth doing as an individual engineer right now — grab an FPGA board and play with snnTorch. A few hundred dollars gets you to the doorstep of the next computing paradigm. You don’t have to give up your GPU. Keep both.

References