Sprints were designed for humans. AI agents work in waves.
AI agents compress what used to take 6 months into days. 2-week sprints no longer reflect how work actually happens. Waves is a free framework that replaces fixed-cadence sprints with organic, variable-length delivery cycles — guiding AI agents through the entire product lifecycle, from the first idea to production code.
AI agents compress months of work into days. Fixed 2-week sprints create artificial boundaries around work that flows at a completely different speed. Ceremonies become overhead, not rhythm.
Your AI agent forgets everything between sessions. You re-explain your architecture, your conventions, your decisions. It invents its own patterns. You fix it. Repeat. Every single day.
You have an idea but no structured way to validate it, define the product, plan the roadmap, and track implementation — all with the same AI agent keeping full context.
Waves replaces fixed sprints with organic delivery cycles. Each wave carries a product increment from validation to production — lasting as long as it needs. No timeboxes. No artificial ceremonies.
"Can we build this? Should we?"
/waves:feasibility-analyzeThe AI acts as a business consultant: market analysis, competitors, buyer personas, Monte Carlo revenue projections, and Bayesian risk assessment. If the numbers don't add up, you pivot or discard before investing time. Real data, not opinions.
This is the wave most teams skip — and it's the most important one. Business stakeholders often want to jump straight to "the feature that sells." But without horizontal foundations, every vertical feature is built on sand.
"What did we learn?"
/waves:foundation-createCompacts thousands of feasibility simulations into an executive summary: validated problem with evidence, refined target users, revenue model with unit economics, financial benchmarks, SWOT analysis, capabilities re-classified by operational criticality, and a readiness gate.
"What are we building, and why?"
/waves:blueprint-createConsumes the foundation and produces complete product architecture: hypothesis, mission, vision, design principles that generate traceable product rules, capabilities with scope boundaries and acceptance criteria, user flows, system flows, success metrics with dual signal (success + failure), and tech stack.
"What infrastructure do we need before business features?"
/waves:roadmap-createPlans the horizontal infrastructure every product needs before building verticals: authentication, database, CI/CD, base architecture — the essential capabilities that aren't business features but without which no business feature works.
"How do we implement each piece?"
/waves:logbook-createEach task in the W0 roadmap gets its own logbook: objectives, completion guides referencing actual code, progress tracked across sessions. The agent implements continuously, preserving full context. Come back tomorrow and pick up exactly where you left off.
Once W0 laid the foundations, each business wave builds vertical features on that base. Waves can overlap if they work on independent areas. A wave ends when its roadmap is complete and everything is in production.
"What features go in this wave?"
/waves:roadmap-createTakes capabilities from the blueprint and organizes them into phases for this specific wave. Each roadmap is numbered: roadmap_w1.json, roadmap_w2.json, etc. What goes in this wave? What can wait? What blocks what?
"How do we implement each ticket?"
/waves:logbook-createSame logbook system as W0. For each ticket, the agent breaks work into objectives with completion guides, implements with automatic code auditing, and preserves context between sessions. Code passes review on the first try.
feasibility → foundation → blueprint → roadmap_w0 → logbooks → roadmap_w1 → logbooks
Start at any level. If you already have a product, jump straight to a business wave. The full pipeline is for building from scratch.
Each wave carries a product increment from validation to production. A wave lasts as long as it needs — sometimes 3 days, sometimes 3 weeks. No artificial ceremonies, no arbitrary time boxes.
Most frameworks start at code. Waves starts at the business case. Monte Carlo simulations, market analysis, and Bayesian projections — so you know your idea can work before you write a line.
Same structured files work across Claude Code, Claude Desktop, Codex, and Gemini CLI. Switch agents, switch tools — the context follows. No vendor lock-in.
Academic research, creative projects, business planning — Waves adapts. Different schemas for different project types, same structured workflow.
Waves retains only what matters. No bloated context, no verbose summaries. Structured files keep objectives precise and context lean — so your agents stay fast and accurate across sessions.
In production since December 2024 across new and ongoing projects. Not a prototype, not an experiment — a framework refined through 15+ months of daily use on real products.
In Waves, AI agents are not tools — they are team members with defined responsibilities within each role.
Owns the product blueprint. Validates wave outputs. Gives go/no-go at gates. AI agents assist with market analysis, feasibility simulations, competitive research, and data-driven decision support.
Convenes meetings, tracks roadmap progress, identifies blockers, and ensures wave flow. AI agents assist with progress reporting, dependency detection, and meeting preparation.
Translates business requirements into technical reality. Manages AI agent output quality. AI agents implement features, write code, analyze architecture, audit quality, and execute objectives from logbooks.
Every meeting in Waves has a clear purpose, defined inputs, defined outputs, and a responsible convener. No calendar-driven rituals.
Frequent and lightweight. Plan, track progress, resolve doubts and blockers. Convened by the Coordinator as often as needed. Every CM has a stated objective before it begins.
Change control for the product. Evaluates and approves changes to the product blueprint. Infrequent but high-impact. Requires PO approval. Every change is recorded with reasons in the decision trail.
The wave gate. Validates completed work and gets PO approval for production. Test plan defined before the meeting, not improvised. If rejected, observations become logbook entries for the next iteration.
Team wellbeing assessment adapted from the Spotify Squad Health Check model. 8 dimensions: product quality, participation, work-life balance, learning, clarity, tooling, team support, and delivery confidence.
Positive closure at the end of each wave. Recognize achievements, document improvements constructively, and confirm production launch. Not a retrospective — the tone is celebratory, not forensic.
Information flows downward. Detail is never duplicated upward. The structure enforces coherence without bureaucracy.
The Golden Rule: Nothing exists in the project that is not supported in the product blueprint.
If a logbook cannot trace to the blueprint, either the blueprint needs updating (via Blueprint Refinement) or the work should not exist.
Scrum was designed for human-speed development. Waves is designed for teams working with AI agents.
Meetings happen when they're needed, not when the calendar says.
Feasibility uses Monte Carlo simulations, not gut feelings. Decisions are recorded with reasons.
Every piece of work traces to the blueprint. The structure enforces coherence without bureaucracy.
Agents are not tools — they have defined responsibilities within each role.
A wave lasts as long as it needs. No artificial boundaries, no wasted ceremony.
Wave closures recognize achievement first, then note improvements constructively.
The product evolves through controlled change, not frozen specs or uncontrolled drift.
Each command supports fast mode (pass arguments) or interactive mode (guided discovery). These are the ones you'll use every day.
/waves:feasibility-analyze
Sub-Zero
Data-backed go/no-go signals. Monte Carlo simulations, market analysis, Bayesian projections. Know if your idea works before you invest.
/waves:foundation-create
Wave 0
Compacts feasibility into an executive summary: validated problem, unit economics, SWOT, capabilities ranked by criticality. The bridge to product definition.
/waves:blueprint-create
Wave 0
Complete product architecture from the foundation: capabilities with acceptance criteria, user flows, design principles, traceable rules, success metrics, tech stack.
/waves:roadmap-create
Any Wave
Organizes capabilities into phases with milestones and dependencies. W0 plans foundations; W1+ plans business features. Each wave gets its own roadmap.
/waves:logbook-create
Any Wave
Breaks each task into objectives with completion guides referencing actual code. The agent implements, tracks progress, and preserves context across sessions.
/waves:objectives-implement
Any Wave
The agent implements the next objective with automatic code auditing against your project rules. Code passes review on the first try.
Plus 10 more commands for setup, updates, rules, manifests, and resolutions. Install and explore all commands →
These aren't projections. This is what we've measured after 15+ months of daily production use.
No more re-explaining architecture, conventions, or previous decisions. The logbook has it all.
Enforced coding rules eliminate style inconsistencies. Code passes review on the first try.
Same structured files work across Claude Code, Claude Desktop, Codex, and Gemini CLI. Switch tools, keep context.
Feasibility analysis catches bad ideas before you invest. Foundation and blueprint ensure you build the right thing, not just build it right.
Heavy analysis runs in subagents, keeping your conversation lean and fast.
Full GUI experience. Install the plugin, and Waves auto-loads your project context on session start. 17 consolidated agents handle everything behind the scenes.
Interactive commands for Claude Code. Type /waves: and autocomplete does the rest. 16 commands with fast and interactive modes.
Copy/paste prompts that work with any AI agent. Codex, Gemini CLI, or any LLM that reads structured schemas. No plugin required.
brew tap exovian-developments/waves
brew install waves
# Initialize in your project
cd your-project
waves init
# Then in Claude Code:
/waves:project-init
Download waves.plugin from GitHub Releases and double-click to install in Claude Desktop. The plugin auto-loads your project context on session start.
waves.plugin from GitHub Releases
/waves:project-init to configure your project
git clone https://github.com/exovian-developments/waves.git
# Copy commands to your project
mkdir -p your-project/.claude/commands
cp -r waves/.claude/commands/* your-project/.claude/commands/
# Copy schemas to your project
mkdir -p your-project/ai_files/schemas
cp waves/schemas/*.json your-project/ai_files/schemas/
Run these two commands to get your project fully configured:
/waves:project-init
Sets up your preferences and project context
/waves:manifest-create
Analyzes your codebase and creates the project manifest
From this point on, every AI agent that reads your project will understand its architecture, conventions, and history.
/waves:logbook-update FEAT-42.json
The AI reads your logbook, shows what was completed yesterday, what's blocked, and what's next. No context re-establishment needed.
/waves:objectives-implement FEAT-42.json
The agent implements the next objective following your project rules. The code auditor checks compliance automatically. Code passes review on the first try.
/waves:logbook-update FEAT-42.json
Saves progress, decisions, and findings. History auto-compacts when entries exceed 20. Tomorrow's session starts with full context.
/waves:resolution-create FEAT-42
Auto-generates a ticket resolution document from your logbook. What was done, why, and how — ready for your team or your future self.
Not a prototype. In production since December 2024. Install in 60 seconds. Free forever. Open source. Apache 2.0.