Dreamware / Work / Anvil: An Autonomous Task Execution Engine
Anvil: An Autonomous Task Execution Engine
Open-source Go daemon for scheduled AI agent work — Anvil built itself in 467 commits through spec-driven autonomous development with human checkpoints.
The Challenge
As AI-powered development tools matured, a gap emerged between what language models could do in a single session and what was needed for sustained, autonomous work. Tools like Claude Code and OpenClaw excel at interactive, human-in-the-loop sessions, but the engineering world increasingly needs AI agents that can work independently on scheduled tasks — triaging issues, running audits, generating documentation, maintaining codebases — without someone sitting at a terminal.
The existing options had significant limitations. OpenClaw's approach of connecting AI to messaging platforms and email introduced prompt injection risks that Dreamware had analysed in detail. CI/CD systems could run scheduled scripts but weren't designed for LLM-powered tasks that need session continuity, priority queuing, and scoped tool permissions. There was no system purpose-built for the specific problem of "run this LLM task on a schedule, safely, with the right tool permissions, and maintain state between runs."
Our Approach
The project started with a deliberately minimal bootstrap: a simple execution loop and an initial specification. The hypothesis was straightforward — if you give an autonomous system a clear spec, the right tools, and distinct roles for reasoning about its own development, it should be able to build itself.
Anvil is written in Go as a single-binary daemon. But the interesting part isn't the implementation — it's how the implementation came about. After the initial bootstrap, Anvil's own development became spec-driven and autonomous. The system has distinct roles: product management (deciding what to build next), planning (breaking features into specs and tasks), and engineering (implementing and testing). These aren't different people — they're different modes of autonomous operation, each with their own context and constraints.
The security model reflects hard-won lessons about giving AI agents tool access. Rather than broad permissions, Anvil uses scoped tool permissions with pattern matching: Bash(gh:*) permits bash but only for gh subcommands, Read(.claude/commands/*) allows reads only in specific directories. The tool is available, but its scope is constrained by the task definition. This came directly from thinking about the risks that tools like OpenClaw expose when they give agents unrestricted access.
The Outcome
Anvil built itself. From the initial bootstrap, it has grown to 467 commits across features that it specified, planned, and implemented autonomously — with human review at key checkpoints. The system continues to evolve, determining its own feature roadmap through a product management role that evaluates gaps and proposes specifications.
Capabilities that emerged through this self-development process include: event-driven triggers (file watches, webhooks, AMQP subscriptions), concurrency groups, SLA tracking, task checkpointing, pre-check gating, lifecycle hooks, scoped tool permissions, and Prometheus metrics. Each was specified, broken into tasks, implemented, tested, and committed by the system itself.
Anvil now powers Dreamware's autonomous workflows — scheduled code audits, issue triage, and the content pipeline that generates and publishes posts on dreamware.nz. It's both a production tool and a living experiment in what happens when you give software the ability to determine and build its own features, constrained by specifications rather than by direct human instruction.
The project is open source at github.com/johnjansen/anvil.
Key result
Self-built from bootstrap, 467 commits, spec-driven autonomous development, open source
Tech Stack
Related Services
Interested in similar work?
Tell us about your project. We'll have an honest conversation about what's possible, what it costs, and how we'd approach it.