Coding agents are becoming an everyday tool for developers. But they come with inherent limitations, and the main ones are context drift and focus dilution.
The issue is directly related to the context window - how much context the model can safely keep active. As soon as incoming information overflows the context window, the model starts behaving as if it went through unsuccessful brain surgery. Everyone working with LLMs is well aware of this issue and trying to find solutions or workarounds. For example, Claude Code tracks the context size and automatically performs context compaction. Unfortunately, compaction is not a lossless procedure, and often important information, especially infrequently mentioned but necessary rules or guidance, gets washed out.
Let's take a look at where additional context comes from when a coding agent works on some larger task. We start from the high-level context: planning, providing important details, rules, patterns, requirements, etc. But then the coding agent starts working on tasks one by one. Each task contains numerous lower-level details, which also add to context. This causes context drift towards minor details. This also causes focus dilution: instead of focusing on high-level aspects, the coding agent focuses on the actual task at hand, and high-level rules are no longer actual and important. Context compaction somewhat helps, but with each new task, context drift and focus dilution get more and more obvious.
Vibe Ensemble is my attempt to address this issue. Instead of trying to fit everything into the context window, it prevents low-level details from coming into the context window in the first place. This is done by implementing "team mode": there is a coordinator - a user-facing Claude Code instance, which performs high-level tasks like planning or coordination. It does not do individual tasks, though. Instead, it configures workers - headless coding agents (also Claude Code), which handle individual tasks. Each task is split into stages. The system maintains specialized workers for each stage. The worker handles only one stage, starts with a fresh context, and exits when the stage is finished. No low-level detail ever leaks into coordinator context. And this enables management of several projects using the single coordinator.
How Vibe Ensemble Works
The Big Picture
When you describe a project to Vibe Ensemble, here's what happens behind the scenes:
- You describe your project - The coordinator analyzes requirements and initiates planning
- Planning worker generates specifications - Creates ticket and worker type specifications as structured JSON output
- The system creates tickets and worker types - Automatically processes the planning output to set up the project structure
- Workers execute the pipeline - Each ticket moves through its stages automatically
- Progress is tracked and reported - Every step is documented with comments
Think of it like an assembly line where each worker is a specialist who does their part and passes the work to the next specialist.
The Ticket System
What is a Ticket?
A ticket represents a specific piece of work that needs to be done. Each ticket has a human-friendly ID in the format PROJECT_PREFIX-SUBSYSTEM-NUMBER (e.g., TVR-FE-001 for Todo-Vue-Rust, Frontend, ticket 001).
Examples:
- TVR-FE-001: "Create user login page"
- TVR-BE-001: "Set up database schema"
- TVR-DOC-001: "Write API documentation"
- TVR-OPS-001: "Deploy application to production"
The project prefix is automatically generated from your repository name, and the subsystem is inferred from the stage name, making tickets easy to identify and track.
What is a Pipeline?
Each ticket has a pipeline - a series of stages it goes through from start to finish:
Ticket: TVR-FE-001 "User Login Page"
Pipeline: Planning → Design → Implementation → Review → Testing → Complete
Each stage is handled by a different type of worker with specific expertise.
The Workflow Process
Step 1: Project Initialization
When you describe your project, the coordinator:
- Registers the project with the system
- Initializes worker templates in the
.claude/worker-templates/directory - Sets up the project structure and metadata
Step 2: Declarative Planning
The coordinator spawns a planning worker that analyzes your requirements and outputs structured JSON specifications containing:
- Ticket Specifications: Detailed descriptions of work items with their pipelines
- Worker Type Specifications: Definitions of specialized workers needed for each stage
- Dependencies: Relationships between tickets that must be respected
The planning worker doesn't create tickets directly. Instead, it outputs a complete specification that the system validates and processes atomically, ensuring consistency.
Step 3: Automatic Ticket Creation
The system processes the planning output and:
- Creates all tickets with human-friendly IDs
- Sets up worker types for each stage
- Establishes dependency relationships
- Initializes the execution pipeline
Step 4: Automatic Execution
Once tickets are created, Vibe Ensemble automatically:
-
Spawns the right worker for each stage using customizable templates from
.claude/worker-templates/ - Moves tickets through their pipeline as each stage completes
- Handles handoffs between different types of workers
- Tracks all progress with detailed comments
How Workers Collaborate
Worker Types and Responsibilities
Planning Worker:
- Analyzes requirements and breaks down complex tasks
- Creates structured specifications for tickets and worker types
- Designs the pipeline for the entire project
Implementation Worker:
- Writes the actual code
- Follows specifications from planning
- Documents what was implemented
Review Worker:
- Checks code quality and adherence to standards
- Identifies issues that need fixing
- Can send tickets back to implementation if problems are found
Testing Worker:
- Creates and runs tests
- Validates that everything works correctly
- Reports any bugs found
Worker Templates
Each worker type is defined by a customizable template stored in your coordinator's .claude/worker-templates/ directory. These templates define:
- The worker's expertise and focus
- Expected inputs and outputs
- Quality standards and best practices
You can customize templates to match your project's specific needs and coding standards.
The Comment Trail
Every worker leaves detailed comments on tickets, creating a complete history:
Ticket: TVR-FE-001 "User Login Page"
[Planning Worker]: "Analyzed requirements. Will implement using React components with form validation and JWT authentication. Estimated 4 hours of work."
[Implementation Worker]: "Created LoginForm component with email/password fields. Added validation for email format. Integrated with authentication API. Code is ready for review."
[Review Worker]: "Code looks good overall. Minor suggestion: add a loading state during login. No blocking issues. Approved for testing."
[Testing Worker]: "All tests passing. Verified login works with valid credentials, shows errors for invalid ones, and handles network failures gracefully. Ready for deployment."
Dependencies and Coordination
When Tickets Need Each Other
Sometimes one ticket can't start until another is finished:
Ticket TVR-BE-001: "Database Schema Setup" - Must finish first
Ticket TVR-BE-002: "User API Endpoints" - Waits for TVR-BE-001
Ticket TVR-FE-001: "Frontend Login Form" - Waits for TVR-BE-002
Vibe Ensemble automatically:
- Holds tickets that are waiting for dependencies
- Releases tickets when their dependencies are complete
- Runs independent tickets in parallel to save time
Quality Gates
Workers can send tickets backward in the pipeline when issues are found:
Implementation → Review → Issues Found → Back to Implementation
Implementation → Review → Approved → Testing
This ensures quality while allowing for iterative improvement.
What You See as the User
Real-Time Monitoring
You can track progress using coordinator commands:
-
/vibe-status- See overall project health and ticket progress -
/vibe-events- Handle any issues or worker requests for guidance -
/vibe-poll- Continuously monitor until all work is complete
Transparent Process
You can see:
- Which tickets are in which stages (with human-friendly IDs)
- What each worker accomplished
- Any blockers or issues that need attention
- Complete comment history for each ticket
Minimal Intervention Required
Most of the time, the system runs automatically. You only need to:
- Provide initial project requirements
- Answer clarifying questions from workers
- Approve major decisions when requested
- Monitor progress and address any escalated issues
The Power of Specialization
Each worker type is optimized for their specific role:
- Planning workers excel at breaking down complex requirements into structured specifications
- Implementation workers focus on writing quality code efficiently
- Review workers catch issues and maintain standards
- Testing workers ensure everything works reliably
This specialization means each piece of work gets expert attention while maintaining coordination across the entire project.
How to Use Vibe Ensemble
For convenience, Vibe Ensemble uses a simple script-based installation procedure:
Linux/macOS:
curl -fsSL https://vibeensemble.dev/install.sh | sh
Windows:
iwr -useb https://vibeensemble.dev/install.ps1 | iex
Ensure that you have ~/.local/bin in PATH (Linux/macOS) or the installation directory in PATH (Windows).
Create the Vibe Ensemble working directory:
mkdir vibe-ensemble && cd vibe-ensemble
Start Vibe Ensemble:
vibe-ensemble-mcp
Set up the coordinator working directory:
mkdir coordinator && cd coordinator
Generate Claude Code configuration files:
vibe-ensemble-mcp --configure-claude-code
Start Claude Code:
claude
Initialize the coordinator using the /vibe-ensemble slash command. Claude responds with a setup wizard that helps you configure your project scope and requirements.
From this point, use the traditional workflow: describe what you want to build, and the coordinator will handle planning and task delegation. The coordinator does not do implementation tasks itself - it delegates to specialized workers.
Monitor progress and handle events using:
/vibe-events # Handle system events and worker requests
/vibe-status # View comprehensive project status
/vibe-poll # Continuous monitoring until completion
Upgrading
To upgrade to the latest version:
vibe-ensemble-mcp --upgrade
Links:
Web: https://vibeensemble.dev/
Sources: https://github.com/siy/vibe-ensemble-mcp/
Top comments (0)