Darkfab Awakens – Day One

The Blueprint

It all started with an impression video from StrongDM. Three engineers run a software factory there where no human writes code and no human reviews code. The system takes specifications in markdown, builds the software, tests it against behavioural scenarios and delivers finished artefacts.

At the centre sits Attractor – a non-interactive coding agent structured as a graph of nodes. Each node corresponds to a phase in the development process, the edges between them are described in natural language and evaluated by the LLM.

We read the specs. Then we built.

Credits to the StrongDM team – especially Dan Shapiro and the engineering team, who not only built a dark factory but open-sourced the complete specification. Without this transparency, our start would have been significantly slower.

What Happened on Day One

Here's the protocol – chronological, unfiltered:

  1. Built Attractor – Took the StrongDM specs as foundation and implemented our own variant, adapted to our GitLab setup and the Provitex Brain
  2. Created GitLab Fabric – A GitLab group as infrastructure backbone: repositories, CI/CD pipelines, runner configuration
  3. Connected base configuration – Agent connected to GitLab API, runner and brain context
  4. Integrated YOLO and MR modes – Two operating modes: YOLO for direct commits (fast, for simple tasks) and MR for merge-request-based workflows (safe, for complex changes)
  5. Tickets as gateway – GitLab issues as the entry point to the agentic loop: a ticket is created, the agent takes over
  6. Ordered Anthropic API plan – Higher rate limits to prevent autonomous operations from hitting API boundaries
  7. Integrated self-improvement loop – The agent analyses its own results, recognises patterns and adjusts its prompts and strategies
  8. Activated YOLO mode – Live. Real tickets. No human in the loop.

The Result

After 24 hours: 97 commits across all connected repositories. Darkfab wasn't just active on its own repository – the system worked in parallel across 5 GitLab repositories, including a real client project.

Of the 97 commits, 21 came from PX-AI Coder – our GitLab service account for fully autonomous agent commits. The rest was human-in-the-loop work: setup, architecture, configuration.

This isn't a benchmark and it's not a marketing claim. These are the actual numbers from the git logs of day one.

The Self-Improvement Loop in Action

The impressive part: the 10 autonomous commits weren't pre-assigned tasks. Darkfab identified its own tickets through the self-improvement loop, created them in GitLab, resolved them and closed them with the darkfab:done label. Two examples straight from GitLab:

Two GitLab tickets autonomously created and completed by Darkfab – a Vault/SOPS integration and a config test fix

Ticket #27 – a Vault/SOPS integration for secret management – the agent independently identified as a security improvement and implemented it. Ticket #28 – a config test fix – emerged from analysing its own test coverage. Both automatically closed with the darkfab:done label.

The commits come from PX-AI Coder – our GitLab service account for autonomous agent commits:

Commits by PX-AI Coder in GitLab – automatically created without human intervention

No human created these tickets. No human wrote the code. No human made the commit. The agent identified a problem, implemented a solution and shipped the change.

What We Learned

YOLO mode is impressively fast, but not suitable for everything. Some tickets need MR mode with human review. The art lies in automatically recognising which mode is appropriate.

The self-improvement loop works. 21 of 97 commits were fully autonomous – an autonomy level of 21.6% on day one. And the most exciting part: 5 of those autonomous tickets ran not on the Darkfab repository itself, but on a real client project.

The next challenge: scaling. Not more tickets per hour, but more complex tickets. The path from simple bug fixes to feature development.

Darkfab is awake. Let's see what day two brings.