Appearance

What is Groove? ​

Groove is an agent orchestration layer that turns isolated AI coding agents into a coordinated engineering team. It spawns, scopes, coordinates, and monitors multiple agents working on the same codebase — with the same organizational structure a real dev team uses: roles, file ownership, leadership, quality control, and cross-team communication.

Download the desktop app and open a project folder — or install via terminal with npm i -g groove-dev and run groove start. Either way, a full GUI dashboard opens for spawning and managing your agent team.

It works with Claude Code, Codex, Gemini CLI, and any local model via a built-in agentic runtime. Download GGUF models from HuggingFace, run them through Ollama or llama-server, and get the same tool calling and orchestration as cloud providers -- fully offline, zero cloud tokens.

Why This Matters ​

Every AI coding tool on the market today — Cursor, Windsurf, Devin, Aider, Claude Code standalone — gives you one agent with one context window. That works for small tasks. It completely breaks down the moment you try to build anything real.

What happens when one agent isn't enough ​

You're building a marketplace. It has a frontend, a backend API, a payment flow, user auth, and an admin panel. You spawn an agent and tell it to build the frontend. It works for a while. Then you need the backend built simultaneously. So you spawn a second agent.

Now you have two agents that:

  • Don't know the other exists. Agent A builds a frontend that calls /api/products. Agent B builds an API with /api/items. Nobody catches the mismatch until runtime.
  • Edit the same files. Both agents touch package.json, the shared config, or the database schema. You get merge conflicts.
  • Can't coordinate. Agent A needs to know what data shape Agent B's API returns. There's no protocol for them to ask.
  • Degrade independently. Each agent fills its context window. Quality drops. You don't notice until the output is wrong.
  • Lose context on restart. You kill a degraded agent, spawn a fresh one. The new agent knows nothing about what was already built.

This isn't a Claude problem or a GPT problem. It's an architecture problem. No single-agent tool can solve it because the problem is coordination, not intelligence.

The 7-Layer Coordination Stack ​

Groove solves this with seven systems working together. Each layer prevents a specific failure mode that every multi-agent attempt runs into.

1. Introduction Protocol ​

When a new agent spawns, Groove runs a formal introduction:

  • The new agent receives a full briefing: who else is on the team, what each agent owns, what they're working on, and what decisions have been made
  • Every existing agent is notified about the new arrival, its role, and its file scope
  • An AGENTS_REGISTRY.md file is maintained in your project root so agents can reference each other at any time

What this prevents: Agents working in isolation. Cross-contamination. Duplicate work. Conflicting assumptions.

2. File Lock Manager ​

Every agent declares a scope — glob patterns for the files it owns:

  • frontend-1 owns src/components/**, src/views/**
  • backend-1 owns src/api/**, src/server/**
  • database-1 owns prisma/**, migrations/**

The lock manager enforces these boundaries. If an agent tries to modify a file outside its scope, the operation is flagged.

What this prevents: Two agents editing the same file. Merge conflicts. Silent overwrites.

3. Knock Protocol ​

When agents have overlapping concerns — a frontend agent needs to know about an API change the backend agent just made — Groove facilitates coordination:

  1. The lock manager detects the overlap
  2. Groove mediates a context exchange between the agents
  3. Agents adjust their plans based on the negotiation
  4. The outcome is logged in the decisions document

If you spawn two agents with the same role, Groove initiates task negotiation so they divide work areas instead of duplicating effort.

What this prevents: Integration failures. Mismatched contracts between frontend and backend. Wasted work.

4. Supervisor (AI Project Manager) ​

When multiple agents make changes, someone needs to review the risky ones:

  • Agents in Auto mode route destructive or cross-scope operations through an approval queue
  • You review from the GUI, CLI, or chat gateway — tap Approve or Reject
  • When 4+ agents are running, Groove auto-activates enhanced QC checks
  • A conflict log at GROOVE_CONFLICTS.md tracks every collision and resolution

What this prevents: Unchecked destructive operations. Agents overwriting each other's work without review.

5. The Journalist ​

A background synthesis engine that maintains a living picture of your entire project:

  • GROOVE_PROJECT_MAP.md — real-time map of your project: what exists, what changed, what's in progress
  • GROOVE_DECISIONS.md — log of every architectural decision agents have made and why
  • Per-agent session logs — detailed activity logs for each agent's session

When a new agent spawns or an existing agent rotates, it reads these documents and immediately has full context. No re-explanation. No wasted tokens.

What this prevents: Cold-start tax. Knowledge loss between sessions. Agents revisiting settled questions.

6. Adaptive Context Rotation ​

AI models degrade as their context window fills. Groove monitors this and acts before you notice:

  1. Tracks each agent's context consumption with adaptive thresholds tuned per provider and per role
  2. When approaching the degradation cliff, triggers the Journalist to capture the agent's current state
  3. Generates a structured handoff brief
  4. Kills the old session, spawns a fresh one with the handoff brief injected
  5. The new session picks up exactly where it left off — fresh context, peak quality

Thresholds adapt over time: good sessions push the threshold up, degraded sessions pull it down. Groove learns the optimal rotation point for your usage patterns.

Two self-healing safety triggers sit alongside degradation detection: if an agent burns more than 5M tokens in a single instance or spikes above 1.5M tokens in a 5-minute window, Groove auto-rotates with a handoff brief. No modal, no user intervention — the system just heals itself.

What this prevents: Quality degradation on long builds. The "it was working fine an hour ago" problem. Token waste from low-quality output. Stuck loops burning through your budget.

7. Persistent Agent Memory ​

Agents have always been amnesiac. Every new instance starts from scratch — even when 49 agents before it already solved the same problems. Groove's memory layer changes that.

When agents work, four things get recorded to .groove/memory/:

  • Project constraints — discovered rules like "never modify packages/daemon/index.js" or "ESM only, no CommonJS"
  • Handoff chains per role — the last 10 rotation briefs for each role, so a new backend agent sees what the last three backends struggled with and solved
  • Error→fix discoveries — when an agent hits an error and resolves it successfully, the trigger and fix are written to a shared knowledge base
  • Agent specializations — per-agent and per-role quality profiles, session counts, average scores, file-touch patterns

On spawn, the Introducer injects this accumulated memory into every new agent's context. Agent #50 on your project inherits what agents #1–49 learned. The longer you use Groove on a codebase, the smarter the agents get.

What this prevents: Rediscovering solved bugs. Re-explaining project rules. The "every new session starts from zero" tax.

Skills Marketplace: Human Expertise for AI Agents ​

LLMs are hitting a ceiling. Models are increasingly trained on AI-generated output — the training data is eating itself. The next leap in agent quality won't come from bigger models. It will come from injecting real human expertise into the loop.

Groove's Skills Marketplace is the first public knowledge base where that happens.

The problem with AI output today ​

A general-purpose coding agent knows a little about everything. Ask it to build a frontend and you get generic, AI-looking output. It doesn't know your company's design system. It doesn't know that mutation testing matters more than coverage numbers. It doesn't know the security patterns your industry requires.

That domain expertise lives in people — senior engineers, designers, security auditors, DevOps veterans. Until now, there was no way to package that knowledge and make it available to AI agents at scale.

How skills work ​

A skill is a structured instruction set — best practices, constraints, examples, and edge cases — written by a human expert and injected into an agent's context at spawn time. It turns a generalist agent into a specialist.

Examples:

  • A UI design expert creates a skill with their design tokens, component patterns, and anti-patterns. A user buys it, attaches it to their frontend agent, and instantly gets production-grade interfaces instead of generic AI output.
  • A security auditor packages their penetration testing methodology into a skill. Any agent using it now catches vulnerabilities the base model would miss.
  • A performance engineer encodes their profiling workflow and optimization patterns. Agents produce code that's fast by default.

Why monetization matters ​

Anthropic released prompt skills. Other tools have skill libraries. But nobody gave creators a reason to invest serious effort. Why would a senior engineer spend days encoding their expertise if anyone can copy it for free?

Groove's marketplace changes that:

  • Creators set their price — free or $0.01 to $99.99
  • 80% goes to the creator — 20% covers platform and processing
  • Permanent ownership — buyers own the skill forever, no subscriptions
  • Skill Studio — a guided wizard for creating, managing, and publishing skills
  • Marketplace — browse, search, filter by category, ratings, and verification status

This creates a flywheel: experts get paid, so they create high-quality skills. High-quality skills make agents dramatically better. Better agents attract more users. More users buy more skills. The marketplace becomes the world's first curated knowledge base purpose-built for AI agents — powered by human expertise, not more AI-generated training data.

The bigger picture ​

This is how LLMs evolve past the current plateau. Not by training on more AI output, but by giving agents access to structured human knowledge at runtime. Every skill in the marketplace is a direct injection of real-world expertise that no amount of pre-training can replicate — because it comes from practitioners, not datasets.

How Teams Work ​

Agents are organized into teams. A team building a marketplace might have:

AgentRoleScopePhase
frontend-1frontendsrc/components/**, src/views/**1 (builder)
backend-1backendsrc/api/**, src/server/**1 (builder)
database-1backendprisma/**, migrations/**1 (builder)
qc-1fullstack(unrestricted)2 (QC)

Phase 1 agents build in parallel, each in their own scope. When all Phase 1 agents complete, the Phase 2 QC agent auto-spawns, audits all changes, runs tests, fixes integration issues, and verifies the build.

Team Lead Routing ​

When you message a team — from the GUI, Slack, Telegram, or Discord — Groove routes your message to the team lead using role priority:

  1. QC / quality agent
  2. Fullstack agent
  3. Lead / senior agent
  4. PM agent
  5. First running agent (fallback)

You never need to remember agent names or IDs. Talk to the team, the lead handles internal routing.

Plan → Approve → Build ​

For new projects, describe what you want and let the planner design the team:

  1. /plan build me a marketplace with user accounts and payments
  2. A planner agent spawns, reads your codebase and architecture
  3. It outputs a team recommendation: roles, scopes, models, and detailed prompts for each agent
  4. You review the plan and approve, edit, or reject
  5. On approval, the full team spawns with phased execution, scoped file ownership, and auto QC

This works from the GUI dashboard or from any connected chat gateway.

What Groove Is ​

  • A process manager — spawns and manages AI tool processes on your machine
  • A local agent runtime — a built-in agentic loop for any local model, with tool calling, streaming, and context management. Download GGUF models from HuggingFace and run them fully offline.
  • A coordination layer — introduction protocol, file locks, knock protocol, and approval routing
  • A context engine — the Journalist, context rotation, and adaptive thresholds
  • A skills marketplace — human expertise packaged for AI agents, with monetization for creators
  • A visual dashboard — a React GUI at localhost:31415 for real-time monitoring and control
  • A chat interface — Telegram, Discord, and Slack gateways for remote team management
  • Open source — FSL-1.1-Apache-2.0 license

What Groove Is NOT ​

Important distinctions

  • Not a replacement for Claude Code, Codex, Gemini CLI, or any AI tool. It makes them work better together.
  • Not an API proxy — Groove never sends requests to Anthropic, OpenAI, or Google. Your AI tools talk directly to their own servers. Fully compliant with all provider terms of service.
  • Not an IDE — it works alongside your existing editor, terminal, and workflow.
  • Not another AI model — it orchestrates existing models, it doesn't replace them.

Supported Providers ​

ProviderAuthModelsHow It Works
Claude CodeSubscriptionOpus, Sonnet, HaikuCLI process with stream-json output
CodexAPI Key / LoginGPT-5.4 familyCLI process
Gemini CLIAPI KeyPro, FlashCLI process
Local ModelsNoneAny GGUF / Ollama modelBuilt-in agent loop with tool calling

The Local Models provider is Groove's built-in agentic runtime. It runs an agent loop inside the daemon that talks to any OpenAI-compatible API (Ollama, llama-server, vLLM). Local agents get the same 7 tools as Claude Code (read, write, edit, run commands, search), full context rotation, journalist synthesis, and team coordination -- all running on your machine with zero cloud tokens.

Mix providers on the same project. Run Claude Code Opus for complex backend architecture, a local Qwen 32B for free QC verification, Gemini for lightweight frontend tasks, and a local 7B model for documentation -- all coordinated through a single dashboard.

Next Steps ​

FSL-1.1-Apache-2.0

© 2026 Groove Dev