I Built an MCP Server for OpenClaw — Now My AIs Talk to Each Other

Tomáš Grasl — Mon, 16 Feb 2026 07:55:39 +0000

There's been a lot of hype around OpenClaw (a.k.a. Claw bot) lately. At first, it seemed like a fun toy to play with — nothing more. But over time, I realized it could actually be useful, so I installed it on my own physical server and started experimenting.

The Problem with Chat Channels

OpenClaw supports communication through Discord and Telegram, but honestly, that felt limiting. Chatting with an AI agent through a messaging app takes away a lot of its potential. So I asked myself: what if I built an MCP server and connected it directly to Claude?

So I Built It

I created an MCP (Model Context Protocol) server for OpenClaw — check it out on GitHub — and I have to say, watching one AI communicate with another AI is both hilarious and surprisingly effective. What started as a fun experiment turned out to be incredibly powerful.

Real-World Use Cases

Here's where it gets interesting. Let me walk you through two workflows I'm actually using.

Auto-Fixing Bugs from Sentry

Imagine you have an n8n automation that reacts to bugs coming from Sentry. Here's the flow:

A bug comes in from Sentry
The n8n workflow picks it up and an AI node evaluates it — yes, this should be fixed
Via MCP, it creates a prompt for OpenClaw
Claw clones the project repository on the server
It spins up Claude Code, which fixes the bug
Claw creates a pull request on GitHub
It reports back to the automation with the PR link
You get a notification via Pushover or Slack

And yes, this actually works.

Jira Task Management with Claude Code

Here's another one. You have the OpenClaw MCP connected to Claude Code on your localhost. You have a task in Jira, but you don't want to load Claude Code with a dozen different MCP servers — that eats up your context window. Instead, you only have the OpenClaw MCP.

You ask Claw to look up the Jira task and send back what needs to be done. It returns the task as a ready-to-go prompt for Claude Code, and you can start working immediately. Once you're done, you notify Jira through Claw that the task is complete. Clean and simple.

A Word of Caution

OpenClaw is powerful, but it can also be dangerous if you don't configure it properly. It's gone off the rails on me a few times already. Make sure you set clear boundaries and review what it's doing, especially when it has access to your repositories and external services.

As an experiment and a productivity booster? Absolutely worth it. Just keep it on a leash. 🦞

I Built a Small Self-Hosted Runner for AI Coding Tasks

Tomáš Grasl — Sun, 15 Feb 2026 16:42:35 +0000

I built a small runner for self-hosted AI coding. It's similar to Claude Code but isolated in Docker and fully self-hosted.

I actually like what Anthropic did with Claude Code on the web — for small tasks it works fine. But I needed something I could hook up not just to GitHub but also to GitLab. So I said to myself: I'll just write it. And for this kind of thing, Go is the best fit.

What It Does

CodeForge receives task requests via REST API, clones your repository, runs an AI CLI tool (Claude Code) against it, streams progress via Redis Pub/Sub, and optionally creates pull requests. It supports multi-turn conversations, webhook callbacks, and workspace lifecycle management.

Client                  CodeForge                          AI CLI
  │                        │                                 │
  │  POST /api/v1/tasks    │                                 │
  ├───────────────────────▶│                                 │
  │         201 {id}       │                                 │
  │◀───────────────────────┤                                 │
  │                        │  git clone ──▶ run CLI          │
  │                        ├────────────────────────────────▶│
  │    Redis Pub/Sub       │         stream-json events      │
  │◀ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─┤◀────────────────────────────────┤
  │                        │                                 │
  │  GET /tasks/{id}       │           result + diff         │
  ├───────────────────────▶│◀────────────────────────────────┤
  │     200 {result}       │                                 │
  │◀───────────────────────┤                                 │
  │                        │                                 │
  │  POST /tasks/{id}/     │                                 │
  │       create-pr        │  git push ──▶ GitHub/GitLab API │
  ├───────────────────────▶├─────────────────────────────────▶
  │     200 {pr_url}       │                                 │
  │◀───────────────────────┤                                 │

You POST a task with a repo URL and a prompt. CodeForge clones the repo, spawns the AI CLI, streams progress events through Redis Pub/Sub, and when it's done, you can tell it to create a pull request. That's it.

Quick Start

# Start the server (requires Docker + docker-compose)
docker compose -f deployments/docker-compose.yaml \
  -f deployments/docker-compose.dev.yaml up --build

# Create a task
curl -X POST http://localhost:8080/api/v1/tasks \
  -H "Authorization: Bearer dev-token" \
  -H "Content-Type: application/json" \
  -d '{
    "repo_url": "https://github.com/user/repo.git",
    "access_token": "ghp_your_token",
    "prompt": "Fix the failing tests in the auth module"
  }'

# Check status
curl http://localhost:8080/api/v1/tasks/{id} \
  -H "Authorization: Bearer dev-token"

If you have Task installed, just run task dev instead of the docker compose command.

Why Go?

I considered Node.js (my second language after PHP) and Rust, but Go hit the sweet spot:

Single binary deployment — no runtime dependencies, no node_modules, just copy and run
Excellent concurrency — goroutines handle multiple simultaneous tasks without callback gymnastics
Low memory footprint — the service itself uses ~15MB RAM, leaving resources for the actual AI CLI
Fast startup — critical for containerized environments where pods come and go
Battle-tested HTTP/Redis libraries — net/http, go-redis, chi router — mature, stable, boring (in a good way)

Real-World Use Cases

Here are some ways I'm using CodeForge (or planning to):

Automated issue fixing — GitHub/GitLab webhook fires when an issue gets the ai-fix label. A small middleware translates it into a CodeForge task. Minutes later, a PR appears.

Nightly code maintenance — Cron job that runs prompts like "update deprecated API calls" or "improve error messages" across multiple repos.

Non-developer requests — Product managers submit tasks through a simple form: "Add a loading spinner to the dashboard page." CodeForge handles the rest.

Code review bot — After a human creates a PR, trigger CodeForge to review it with a separate AI instance and post comments.

What's on the Roadmap

CodeForge currently uses Claude Code as its AI backend, but the architecture is designed to be CLI-agnostic. Here's what's coming:

Multi-CLI support — runners for OpenCode, Codex, and other AI coding CLIs
Task sessions — cross-task memory so the AI remembers context from previous tasks on the same repo
Automated code review — a second AI pass reviews changes before creating a PR
Subscription & multi-user auth — per-user API keys and usage tracking

Try It Out

The repo is at github.com/freema/codeforge. I'd love feedback — especially on the API design and the multi-CLI architecture that's coming next.

If you have questions or ideas, open an issue or find me on GitHub.

DEV Community: Tomáš Grasl

I Built an MCP Server for OpenClaw — Now My AIs Talk to Each Other

The Problem with Chat Channels

So I Built It

Real-World Use Cases

Auto-Fixing Bugs from Sentry

Jira Task Management with Claude Code

A Word of Caution

I Built a Small Self-Hosted Runner for AI Coding Tasks

What It Does

Quick Start

Why Go?

Real-World Use Cases

What's on the Roadmap

Try It Out