Quick to start, harder to maintain
Repeated prompting can produce a prototype quickly. As the project grows, missing requirements, tests, and decision records make changes harder to manage.
sprint-001 · active · source-available
Run your project with an AI Scrum team.
Use the native Mac app or a single shell command to run a multi-agent Scrum team with Claude Code Agent Teams. Guide each Sprint as Product Owner, or define the intended outcome and use autonomous mode.
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
Keep moving without losing structure.
Fast experiments can become difficult to maintain, while detailed upfront specifications can be hard to write for a product that is still changing. Maul Team uses short Scrum cycles so you can refine the requirements as the product develops.
Structured, but demanding upfront
Spec-driven development adds useful structure, but an evolving project may not have enough information to define every detail at the start.
Review and adjust each Sprint
The team plans a Sprint, builds a working Increment, and demonstrates it to you. Your feedback shapes the next Sprint, so the requirements become more precise over time.
See it run
Follow the whole Sprint in one window.
This recorded session shows the Scrum Master planning, Developers working in parallel, and PBIs moving across the board as the product takes shape.
Video not loading? Watch the demo on GitHub ↗
Project files and editor
Browse the file tree and double-click a file to open it in a separate editor window with syntax highlighting. Lock icons identify framework files.
Scrum Master and activity log
Use the built-in terminal to talk to the Scrum Master. The Work Log records agent starts, file changes, and messages as they happen.
Sprint dashboard
See the current Sprint, open any PBI for details, and check integration test results as the team works.
The lifecycle
A defined process from requirements to release.
Each Sprint follows the same stages, with explicit completion rules, measured test coverage, and optional cross-model review. Select a stage below to see what happens.
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
Broad ideas become Sprint-ready PBIs with acceptance criteria and defined file paths.
03
Sprint Planning
You approve the Sprint Goal as Product Owner; PBIs are assigned to Developer agents.
04
Development Pipelineparallel
Each Developer works on one PBI in a separate git worktree. Design, implementation, and black-box unit tests repeat in Rounds and can be reviewed by Codex, with a Claude-based fallback. Coverage is measured with standard tools against the C0/C1 requirements. A PBI can merge only after its tests and five-part integrity review pass. The Scrum Master then uses a --no-ff merge and runs regression tests. After three failed attempts, the issue is escalated. Every Sprint closes with a lightweight cross-review; every third Sprint also runs a whole-repository audit, and accepted findings become PBIs for a later Sprint.
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 demonstrates the working Increment so you can review its behavior.
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
Give agents a process they can repeat.
Loop engineering gives agents a repeatable cycle for planning, acting, checking the result, and improving it. Maul Team applies this at three levels: the development pipeline, each Sprint, and autonomous execution.
prompt engineering → context engineering → loop engineering
Development pipeline
Each PBI has its own git worktree. Design, implementation, black-box unit tests, and optional Codex review repeat until the defined completion rules pass. Changes cannot merge until the tests and review pass, and standard tools measure coverage.
≈ agent loop + verification loopSprint cycle
Every Sprint ends with a lightweight cross-review. Every third Sprint also runs a four-part audit of the repository to find differences between the merged code and its requirements. The Product Owner reviews findings by severity, and accepted findings become draft PBIs. Retrospective actions carry into the next Sprint.
≈ hill-climbing loopAutonomous execution
Define the intended outcome in a product brief and assign the Product Owner role to an agent. The agent Product Owner and Scrum Master continue running Sprints toward that outcome. A Ralph-Loop watchdog restarts headless sessions, applies time and iteration limits, resumes after API rate limits, and writes a report.
≈ 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”
Autonomous work still needs review. Hooks enforce process rules, completion conditions are explicit, test tools measure coverage, and unclear requirements are sent to the Product Owner instead of being resolved by assumption.
Your role
You guide the product. The team handles the workflow.
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
Features
Controls for repeatable, reviewable work.
Hooks enforce the process, saved state lets sessions resume after a restart, and an optional second model can review the work independently.
Multi-agent coordination in Claude Code
The Scrum Master runs in Delegate mode and coordinates up to six Developer agents in parallel. Each Developer handles one PBI in an isolated git worktree and starts specialist sub-agents for each Round.
Native Mac app
The SwiftUI app combines an editor, the Scrum Master terminal, the Work Log, and the Sprint dashboard in one window.
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 and define the intended outcome in a product brief. An agent Product Owner and the Scrum Master continue the work, with a Ralph-Loop watchdog, execution limits, and a generated report.
Design document controls
A read-only catalog and editable configuration define which design documents may exist. Hooks also control which roles may edit them.
Quality checks
Status checks, path and branch guards, completion-flow checks, and the Definition of Done enforce the workflow.
State persistence
Team state is stored as JSON in .scrum/. Restart the session and the team continues from the saved state.
Automated testing
Integration tests derive boundary cases from the design documents, followed by user-story-based acceptance testing.
Retrospective-driven improvement
The team records process improvements after each Sprint and applies them to later Sprints.
Scrum adapted for agents
Team size changes with the Sprint, requirements are defined before development, and every code change must belong to a PBI.
Get started
Install MaulTeam.app on your Mac.
MaulTeam.app is distributed as a signed, Apple-notarized .dmg for macOS 14 and later. It is currently free for personal and internal business use, and the underlying framework uses the MIT License. You can also install it with Homebrew or build it from source.
● Recommended
Download the app
The universal binary supports Apple Silicon and Intel, with no build tools required.
- 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 — this version added the nested sub-agents used by the pipeline
- Python 3.9+ — checked by the launcher
- Codex CLI (optional, recommended) — enables cross-model review; otherwise, the pipeline uses Claude-based review
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 creates the universal2 build. It requires Xcode 16+ with the Swift 6 toolchain, and the first build downloads 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.
Command-line option
Run the same pipeline in tmux.
The Mac app includes the open-source maul-team framework. You can also start the framework from a terminal with scrum-start.sh. The tmux interface shows the Scrum Master on the left and the team dashboard on the right. Workflow and project state remain on your machine; model requests go through Claude Code and, when configured, Codex.
The dashboard shows status changes, test coverage, and merge results. The team asks you to resolve requirements it cannot determine from the project.
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
Frequently asked questions
What the agent team does, how much control you keep, and what runs on your machine.
How do the AI agents run a Scrum sprint?
A Scrum Master agent plans the Sprint and starts one Developer agent per backlog item. Each Developer designs, implements, and writes black-box unit tests in a separate git worktree. Codex reviews the work when available, with a Claude-based fallback. Tests and reviews must pass before merge, and the Sprint ends with a product demo.
Can Maul Team run autonomously?
Yes. In human-in-the-loop mode, the team runs the Sprint while you make Product Owner decisions at review points. In --autonomous mode, you define the intended outcome and an agent Product Owner works with the Scrum Master without waiting at each step.
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 same pipeline in tmux. The Mac app provides a visual interface but is not required.
How is this different from Devin or other AI software engineers?
Maul Team coordinates several agents through defined Scrum stages and review checks. It is source-available, runs locally, and lets you direct the work as Product Owner.
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 ↗.
Get started
Run your next project with Maul Team.
Download the app, move it to Applications, and start Sprint 1. The app is currently free for personal and internal business use.
or brew install --cask maul-team