Fast, then fragile
Prompt, accept, repeat. Speed is real — but as the project runs longer, order erodes. No requirements, no tests, no memory of why anything is the way it is.
sprint-001 · active · source-available
Hand your project to an AI Scrum team.
A native Mac app — or one shell command — runs a multi-agent Scrum team on your project, powered by Claude Code Agent Teams. Stay in control as Product Owner (human-in-the-loop), or specify the end state and let the team loop on its own.
Signed & Apple-notarized · macOS 14+ · also via Homebrew or source build
macOS 14+
Swift 6
Python 3.9+
Claude Code Agent Teams
Currently free for personal/internal use · Source-available
The problem
Vibe coding decays.
Spec-driven suffocates.
Most real projects live between the two extremes. Maul Team brings Scrum's inspect-and-adapt loop to Claude Code — structured iteration without a complete spec on day one.
Ordered, but upfront-everything
SDD keeps order, but can require more upfront definition than an evolving project can provide. Real projects rarely know everything on day one.
Inspect and adapt, every Sprint
An AI team plans a Sprint, builds a working Increment, demos it to you, and adapts from your feedback. Requirements sharpen as the product grows — and you never leave the Product Owner seat.
See it run
Your whole team, one window.
Watch a real session: the Scrum Master plans, Developers build in parallel, and PBIs move across the board — while you review the working product.
Video not loading? Watch the demo on GitHub ↗
Your code, live
File tree and a syntax-highlighting code editor — double-click a file to open it in its own editor window; framework files are lock-marked so you always know what's yours.
The Scrum Master, embedded
A real terminal running the Scrum Master, plus a native Work Log streaming every agent spawn, file change, and message as it happens.
Mission-control dashboard
Native sprint overview and PBI board — click any PBI for details — plus integration test results, updating as the team works.
The lifecycle
Real Scrum. Real gates.
No hand-waving.
Every Sprint runs the full ceremony loop — with deterministic termination gates, measured coverage, and review with an optional cross-model pass. Not a prompt chain wearing a Scrum costume.
Before the loop
Release train
01
Requirements DefinitionSprint 0
A Requirements Analyst interviews you, researches similar products on the web, and writes requirements.md.
02
Backlog Refinement
Coarse ideas become sprint-ready PBIs with acceptance criteria and scoped paths.
03
Sprint Planning
You approve the Sprint Goal as Product Owner; PBIs are assigned to Developer agents.
04
Development Pipelineparallel
Each Developer builds its PBI in an isolated git worktree, in parallel. Every Round of design → implementation + black-box unit tests is cross-reviewed by Codex (Claude-based fallback), with deterministic termination gates and real C0/C1 coverage. And no PBI merges until its tests and a 5-aspect integrity gate pass — then the SM lands it with a --no-ff merge plus a regression gate; three strikes and it escalates instead of limping forward. At Sprint end, four parallel auditors sweep the whole repo for the drift per-PBI review structurally can't see; findings become next-Sprint PBIs.
Backlog
0Design
0Implement
0PBI Review
0Unit Tests
0Merge
0Cross-Review
0Done
0Open the app to follow every PBI from backlog to done.
05
Sprint Review
The team demos the working Increment to you. You inspect the product, not a diff.
06
Retrospective
The team inspects its own process and carries improvements into the next Sprint.
07
Integration Testsrelease train
Design-driven boundary and branch cases, smoke tests, and API/UI automation.
08
UAT & Releaserelease train
Story-driven UAT walkthrough, defect routing, and the go/no-go release decision.
Loop engineering
Stop prompting agents.
Engineer the loops instead.
Loop engineering means designing a system in which agents repeatedly plan, act, verify, and improve instead of relying on isolated prompts. Maul Team implements it at three levels: Development pipeline, Sprint, and autonomous execution.
prompt engineering → context engineering → loop engineering
The Development pipeline loop
Per PBI, in its own git worktree: design, implementation with black-box unit tests, and Codex cross-model review, repeated in Rounds until deterministic termination gates pass. The merge stays locked until tests and review clear — coverage measured by real tooling, not self-reported.
≈ agent loop + verification loopThe Sprint loop
Every Sprint ends with a whole-repo, four-axis audit that catches drift between the merged code and its requirements. Critical findings become draft PBIs for the next Sprint; the retrospective feeds process fixes forward the same way. Product and process both hill-climb.
≈ hill-climbing loopThe Autonomous execution loop
Specify the end state in a product brief and even the Product Owner seat becomes an agent — the agent PO and the Scrum Master keep running Scrum toward it. An outer Ralph-Loop watchdog re-launches headless sessions iteration after iteration, enforces safety valves, sleeps through API rate limits and resumes, and leaves you a morning report. The loop keeps turning while you sleep.
≈ event-driven loop“You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents.”
— Peter Steinberger, quoted in Addy Osmani, “Loop Engineering”
The risk in any loop is cognitive surrender — letting it run and quietly accepting whatever comes back. Our answer is gates, not trust: hooks enforce the rules, termination is deterministic, coverage is real, and unclear requirements escalate to the PO seat instead of being guessed.
Your seat
You set product direction.
The team runs delivery.
In the default human-in-the-loop mode, you approve goals, review working software, and make release decisions. The team handles requirements, planning, implementation, review, and testing.
Describe what you want to build
Elicit and write detailed requirements
Approve Sprint Goals
Plan Sprints and assign PBIs
Review demos in the running app
Design, implement, and cross-review the Increment
Report defects during UAT
Fix defects and re-test automatically
Make release decisions
Run automated test suites
Under the hood
Built like infrastructure,
not a demo.
Hooks enforce the process. State survives restarts. Reviews cross model families. The framework assumes agents will be confidently wrong — and catches it.
Multi-agent orchestration, native to Claude Code
The Scrum Master runs in Delegate mode — it coordinates, never writes code — orchestrating up to 6 parallel Developer agents, one per PBI, each building in an isolated git worktree. Each Developer is itself a conductor, spawning per-round specialist sub-agents.
Native Mac app
Your AI dev team in one Mac window — editor, Scrum Master terminal, Work Log, and dashboard. SwiftUI, not Electron.
19 Skills, full lifecycle
Every ceremony — from requirement definition through retrospective to UAT and release — is a versioned, inspectable Skill.
Autonomous mode (Loop Engineering)
Run --autonomous from the command line: specify the end state in a product brief, and an agent Product Owner and the Scrum Master keep running Scrum toward it — Ralph-Loop watchdog, safety valves, morning report.
Design-doc governance
An immutable document catalog with editable enablement — hooks enforce which design docs may exist and who may touch them.
Quality-enforcement hooks
Status gates, path guards, branch-ops guard, completion-flow and Definition-of-Done checks — process rules the agents cannot skip.
State persistence
All team state lives in .scrum/ JSON. Kill the session, relaunch, and the team resumes exactly where it stopped.
Automated testing
Design-driven integration tests plus story-driven UAT — boundary cases derived from the design docs, not guessed.
Retrospective-driven improvement
The team retrospects every Sprint and feeds process improvements forward — the loop applies to the team itself.
AI-native adaptations
Dynamic team sizing, mandatory requirement definition first, no work without a PBI — Scrum re-derived for how agents actually work.
Get started
Download. Drag to Applications.
Meet your team.
MaulTeam.app ships as a signed, Apple-notarized .dmg that opens with no Gatekeeper warnings — currently free for personal and internal business use, built on the MIT-licensed open-source framework. Prefer a package manager or a compiler? Homebrew and a source build are right here too.
● Recommended
Download the app
Three steps, no toolchain. Universal binary for Apple Silicon and Intel.
- Download the .dmg below
- Drag MaulTeam.app to Applications
- Open it and point the team at a project
Every release ships a .sha256 checksum — all releases & notes ↗
Requirements
- macOS 14+ (Apple Silicon or Intel)
- Claude Code CLI ≥ 2.1.172 on PATH — sub-agents spawning sub-agents was unlocked there
- Python 3.9+ — the launcher validates it
- Codex CLI (optional, recommended) — enables cross-model review; Claude-based review is the fallback
Homebrew tap
Two lines, updates with brew upgrade:
brew tap sohei56/homebrew-tap
brew install --cask maul-team
brew install --cask maul-team
Build from source
make-app.sh release produces the same universal2 build. Needs Xcode 16+ (Swift 6 toolchain); the first build fetches SwiftTerm.
$ git clone git@github.com:sohei56/maul-team.git
$ cd maul-team
$ sh macapp/scripts/make-app.sh release
$ open macapp/build/MaulTeam.app
Prefer the terminal? Skip the app and run sh scrum-start.sh in your project.
Or skip the GUI
One command. Same team.
The Mac app wraps the open-source maul-team framework — launch it from any terminal with scrum-start.sh and get the identical pipeline in tmux: the Scrum Master on the left, the live team dashboard on the right. Workflow and project state stay on your machine; model requests go through your installed Claude Code and, when configured, Codex.
Agents report facts, not vibes: status transitions, coverage numbers, merge results. When something is genuinely unclear, the team escalates to you instead of guessing.
tmux — scrum-start.sh
> Start Sprint 1 — plan the Sprint, spawn the
developers, and drive every PBI to done. Escalate to me only when a decision is
genuinely mine.
Questions
The parts people
ask about twice.
Short answers to what a "team of AI agents running Scrum" actually means in practice.
How do AI agents actually run a Scrum sprint?
A Scrum Master agent plans the Sprint and spawns Developer agents, one per backlog item. Each Developer designs, implements, and writes black-box unit tests in its own git worktree, with Codex cross-model review (Claude-based fallback). A PBI merges only after its tests and reviews pass — then a regression gate at merge. The Sprint ends with a demo to you. It's the ceremony loop, not a prompt chain.
Is this autonomous AI development, or am I babysitting prompts?
Both. In human-in-the-loop mode Sprint execution is hands-off and you make the Product-Owner decisions at the gates. In --autonomous mode you specify the end state once and an agent PO and the Scrum Master keep the loop turning unattended.
What is the license, and where does MaulTeam.app run?
The maul-team framework is MIT-licensed. The Mac app is source-available and currently free for personal and internal business use under its commercial license — a paid Enterprise plan may be introduced in the future. Workflow and project state stay on your Mac; model requests go through Claude Code and, when configured, Codex.
Do I need the Mac app, or can I use the terminal?
One shell command runs the identical pipeline in tmux. The Mac app is the friendly front door, not a requirement.
How is this different from Devin or other AI software engineers?
A whole team of agents with real Scrum gates, not a single autonomous engineer; source-available and locally operated rather than closed SaaS; and you hold the Product Owner seat.
Is the download safe to open?
Yes — the app and the .dmg are signed with an Apple Developer ID and notarized by Apple, so Gatekeeper opens them without warnings. Every release also publishes a .sha256 checksum: run shasum -a 256 MaulTeam.dmg and compare it against the value on the Releases page ↗.
Ready when you are
Hand your next project
to a team.
Download, drag to Applications, and start Sprint 1. Currently free for personal and internal business use.
or brew install --cask maul-team