Continuous Agent Engineering
Wololo pipelines turn GitHub issues into merged PRs — autonomously. Issues go in, PRs come out. Humans merge. Everything between is handled by coordinated AI agents following a deterministic state machine.
This isn't a chatbot with tools. It's a closed-loop engineering system where agents research, build, review, fix, test, and learn — continuously improving with every cycle.
The Pattern
Each stage has clear entry conditions, a defined executor (agent or automation), and explicit exit criteria. Labels on GitHub issues and PRs drive the state machine — no external orchestration database required.
Core Principles
1. Labels Are the Source of Truth
Pipeline state lives on GitHub labels, not in a database. Every stage transition is a label change. Any engineer (human or agent) can inspect the pipeline state by reading labels. No hidden state, no sync issues.
2. Agents Orchestrate, Never Code Directly
The orchestrator agent (PM) dispatches work to coding agents. It never writes code itself. This separation means the PM can monitor multiple pipelines simultaneously while coding agents focus on implementation.
3. Human Gate at Merge Only
The entire pipeline — from research through testing — runs without human intervention. Humans review and merge the final PR. This is the only mandatory human touchpoint.
4. Circuit Breakers Prevent Infinite Loops
After N failed attempts at any stage (default: 3), the pipeline halts with an agent-stuck label. No infinite retries. No wasted compute. A human triages when the agent can't proceed.
5. Everything Runs in Isolation
Each task gets its own git worktree, its own agent session, and its own branch. No agent ever modifies the main branch directly. Concurrent pipelines can't interfere with each other.
Pipeline Stages
| Stage | What Happens | Who Does It | Exit Criteria |
|---|---|---|---|
| Intake | Issue created, triaged, added to backlog | Human or PM agent | Issue in backlog column |
| Research | Analyze issue, classify complexity, determine if automatable | Cloud coding agent | Classification label applied (agent or human) |
| Build | Implement the fix in an isolated worktree, create PR | Local coding agent | PR opened with Closes #N |
| Review | Automated code review via GitHub Action | CI automation | Review label applied |
| Fix | Address review comments, push fixes | Local coding agent | Comments addressed label applied |
| Test | E2E testing with browser automation | Local coding agent | Test result label applied |
| Deliver | Human reviews and merges PR | Human | PR merged, issue closed |
| Learn | Log corrections, update patterns, improve future cycles | All agents | Corrections logged, patterns promoted |
Why This Works
Traditional CI/CD automates the delivery of code. Continuous Agent Engineering automates the creation of code. The pipeline handles the entire lifecycle — from understanding what needs to be built, to building it, to verifying it works, to learning from mistakes.
The result: a team of AI agents that gets measurably better at shipping code over time, with human oversight concentrated where it matters most — the final merge decision.
Sections
- Intake → Delivery Flow — the full lifecycle, stage by stage
- Agent Dispatch & Monitoring — how agents are assigned and tracked
- Quality Gates — review, QA, and security gates
- Closed-Loop Learning — how agents improve over time
- Building Your Own Pipeline — template and configuration guide