I started this as a fun personal project: put OpenClaw on a dedicated VM, connect it to Slack and GitHub, and see how far an AI-assisted engineering loop could go. It has turned into something more interesting: a small autonomous software factory.

The AI SDLC loop

The system now runs like an AI SDLC pipeline. It discovers work, triages issues, breaks large requests into implementation slices, writes code, opens pull requests, responds to review feedback, fixes CI, prepares merges, and reports its own health.

It does not replace engineering judgment, but it does automate a surprising amount of the surrounding motion.

The useful pattern is not one giant autonomous prompt. It is a secure, observable engineering loop with narrow lanes and clear gates.

What is running

The architecture is intentionally boring. OpenClaw runs on a dedicated Ubuntu VM. Slack is the conversational surface. GitHub is the system of record. User-level systemd services and timers run the 24x7 process.

The current host has 32 service units, 28 timers, 26 active timers, 11 scheduled agent lanes, 49 executable automation scripts, and 6 installed Codex skills. That gives the system enough structure to behave less like a single prompt and more like an operating model.

Secure by default

Security is part of the design, not an afterthought. The agent runtime is isolated on its own VM. The OpenClaw gateway is local-only and token-protected. Secrets stay out of public content and backup docs. Runtime configuration is separated from redacted configuration backup.

Work is scoped through branches, labels, issue state, validation gates, cooldowns, and human approval points. The important enterprise lesson is that AI autonomy needs boundaries, logs, and a rollback path.

Queue control matters

The biggest lesson is that autonomy without queue control just creates more work. A software factory that only opens new issues and PRs is not useful. This pipeline watches its own pressure: open PRs, merge velocity, fix-ready backlog, dependency blockers, failed checks, and recent agent failures.

A local dashboard makes that visible. It shows the current queue, recent merge velocity, PR health, issue bottlenecks, model usage pace, and which lanes are running or waiting. That turns the automation from a black box into something you can inspect, tune, and explain.

When the queue is healthy, it can feed more work. When PRs pile up, it shifts toward closeout and remediation. That is the difference between a toy agent and something that starts to look like an engineering system.

The output so far

The output has been real. As of June 13, 2026, the main application repository had 837 bot-labeled pull requests, with 824 merged. A broader branch-pattern count showed more than 900 automation-created PRs.

On the issue side, the pipeline had handled 1,262 issues since late February, with 1,133 closed. More than 1,000 were triaged, more than 600 were marked ready for implementation, and hundreds came from automated bug discovery, feature-gap research, and implementation slicing.

The live pipeline was also active while I was writing this: 19 merged PRs in the previous 24 hours, 9 in the previous 8 hours, 8 open bot PRs, 16 fix-ready issues, and 9 dependency-blocked issues.

Why this matters for enterprise engineering

This is a fun project, but the patterns are directly relevant to enterprise engineering. Most companies do not need a reckless autonomous agent. They need secure, observable AI SDLC automation: bounded agents, clear ownership, audit trails, test gates, queue pressure controls, and approval workflows.

I plan to publish a sanitized open-source setup later with the reusable scaffolding, systemd patterns, dashboards, and lane structure. That version will focus on how to build the factory safely without including private credentials, app-specific code, or internal details.

Related reading

The short version

OpenClaw is the agent core, the automation lanes are the orchestration layer, GitHub is the factory floor, Slack is the control room, and the AI pipeline is the production system that keeps work moving from idea to merged code.

OpenClaw Autonomous Software Factory AI SDLC GitHub Automation Secure Engineering