Building Fabrica: an OpenClaw plugin for structured software engineering workflows

I’ve been spending some time exploring a problem that keeps showing up around AI coding agents:

the models keep improving, but the engineering workflow around them is still often fragile.

A lot of current setups are good at generating momentum, but much weaker at handling the operational side of software work:

• project setup
• task breakdown
• role separation
• review flow
• testing flow
• stuck-run recovery
• observability
• onboarding for real users

That is the gap I wanted to explore with Fabrica.

MestreY0d4-Uninter / fabrica

Autonomous software engineering pipeline for OpenClaw

Fabrica

Autonomous software engineering pipeline for OpenClaw.

Fabrica turns a natural-language project description into a fully executed engineering workflow: intake, specification, issue decomposition, development, code review, testing, and merge. It orchestrates AI agents as specialized workers (developers, reviewers, testers) through a deterministic finite state machine, with repair-oriented recovery when runtime signals or stack environments are incomplete.

How it works

  Human idea (text)
        |
        v
  [ Intake & Spec ]  ←  classify → interview → generate-spec
        |
        v
  [ Issue decomposition ]  ←  GitHub issues created
        |
        v
  [ developer ]  →  opens PR
        |
        v
  [ reviewer ]   →  approves or requests changes
        |
        v
  [ tester ]     →  runs QA, posts evidence
        |
        v
  [ merge ]      →  PR merged, issue closed
        |
        v
       done

The heartbeat ticks every 60 seconds. On each tick, Fabrica alternates between a repair pass (fixes stale states, retries incomplete completion signals, and reconciles…

View on GitHub

What Fabrica is

Fabrica is an open-source plugin for OpenClaw focused on orchestrating software engineering workflows in a more structured way.

The goal is not to build “a magical agent that replaces a team”.

The goal is to experiment with a workflow layer around agents that is:

• more explicit
• more auditable
• more predictable
• more operational
• easier to test and criticize

In practice, the idea is to start from an initial input coming from Telegram or CLI and move that through a fuller pipeline.

What the workflow looks like

At a high level, Fabrica is designed around steps like:

• intake of the idea or project request
• bootstrap of the project and repository
• issue and task organization
• handoff between agents with different roles
  • developer
  • reviewer
  • tester
• GitHub PR flow
• validations when the run starts drifting
• recovery paths when the process gets stuck or loops
• doctor, metrics, and operational visibility

So the value is less about “AI writing code by itself” and more about organizing the software workflow around it.

Why I built it

What kept bothering me in many agent demos was not the generation quality itself.

It was everything around it.

A lot of workflows still feel like this:

• context gets scattered
• responsibilities are blurred
• retries happen without much discipline
• failures are hard to diagnose
• loops are easy to trigger
• setup looks easier than it really is
• onboarding often breaks for new users

That makes many agent workflows look impressive at first, but unreliable in repeated use.

I wanted to see what happens if the focus shifts from “make the agent do more” to “make the workflow easier to understand and operate”.

Current state

Fabrica is still early.

I do not want to present it as finished or polished.

But it is already functional, and a lot of recent work has gone into making it less like a demo and more like something people can actually stress:

• stronger setup and onboarding
• better post-PR convergence
• QA evidence validation
• doctor and metrics
• clean-machine validation
• fixes based on real onboarding friction

So the current phase is not “look at my idea”.

It is more:

this already works, now I need real usage, real criticism, and real feedback.

What I want feedback on

If you take a look, the feedback I’d value most is around:

• architecture
• workflow design
• UX
• onboarding
• failure handling
• observability
• where human intervention should happen
• where the system is too complex for the value it provides

I’m also very interested in hearing whether this feels genuinely useful or whether it still looks like too much machinery around a problem that should stay simpler.

That distinction matters.

What I’m explicitly not trying to claim

I’m deliberately avoiding framing this as:

• “AI replaces engineering teams”
• “fully autonomous software factory”
• “push button, get product”
• “perfect automation”

I think that framing creates the wrong expectations and attracts the wrong discussion.

The more honest description is:

an experimental but functional open-source plugin that tries to make agent-driven software workflows more structured and operational.

Repo

Repository:

github.com/MestreY0d4-Uninter/fabrica

If you want to try it, criticize it, break it, or tell me where the design is overengineered, that would be genuinely useful.