Skip to main content

​
The Problem

AI coding assistants are powerful, but they struggle with complex features:
  • Context overload — Long conversations lead to compression, lost details, hallucinations
  • No structure — “Build me dark mode” produces unpredictable results
  • No review gate — Code gets written before anyone agrees on what to build
  • No memory — Specs live in chat history that vanishes

​
The Solution

Agent Teams Lite is an agent-team orchestration pattern where a lightweight coordinator delegates all real work to specialized sub-agents. Each sub-agent starts with fresh context, executes one focused task, and returns a structured result.
The key insight: the orchestrator NEVER does phase work directly. It only coordinates sub-agents, tracks state, and synthesizes summaries. This keeps the main thread small and stable.

​
How It Works

YOU: "I want to add CSV export to the app"

ORCHESTRATOR (delegate-only, minimal context):
  → launches EXPLORER sub-agent     → returns: codebase analysis
  → shows you summary, you approve
  → launches PROPOSER sub-agent     → returns: proposal artifact
  → launches SPEC WRITER sub-agent  → returns: spec artifact
  → launches DESIGNER sub-agent     → returns: design artifact
  → launches TASK PLANNER sub-agent → returns: tasks artifact
  → shows you everything, you approve
  → launches IMPLEMENTER sub-agent  → returns: code written, tasks checked off
  → launches VERIFIER sub-agent     → returns: verification artifact
  → launches ARCHIVER sub-agent     → returns: change closed

​
Where Agent Teams Lite Fits

Agent Teams Lite sits between basic sub-agent patterns and full Agent Teams runtimes:

Level 1: Basic Subagents

Fire-and-forget sub-agents with no state management or coordination

Level 2: Agent Teams Lite ⭐

Delegate-only orchestrator with DAG-based phases and pluggable storage

Level 3: Full Agent Teams

Shared task queue with claim/heartbeat and peer-to-peer communication

​
Capability Comparison

CapabilityBasic SubagentsAgent Teams LiteFull Agent Teams
Delegate-only lead—✅✅
DAG-based phase orchestration—✅✅
Parallel phases (spec ∥ design)—✅✅
Structured result envelope—✅✅
Pluggable artifact store—✅✅
Shared task queue with claim/heartbeat——✅
Teammate ↔ teammate communication——✅
Dynamic work stealing——✅

​
Key Features

Zero Dependencies

Pure Markdown skills. No npm packages, no build steps, no runtime dependencies.

Fresh Context Per Phase

Each sub-agent starts with clean context, reducing hallucinations and improving output quality.

Pluggable Persistence

Choose between Engram (recommended), OpenSpec (file-based), or none (ephemeral).

Works Everywhere

Any AI assistant that can read Markdown files can use these skills.

Structured Workflow

DAG-based dependency graph ensures phases execute in the right order.

TDD Support

v2.0 skills include optional Test-Driven Development workflow.

​
Persistence Is Pluggable

The workflow engine is storage-agnostic. Artifacts can be persisted in:
Default policy is conservative:
  • If Engram is available, persist to Engram (recommended)
  • If user explicitly asks for file artifacts, use openspec
  • Otherwise use none (no writes)
  • openspec is NEVER chosen automatically — only when the user explicitly asks

​
Quick Modes

Choose the right mode for your use case: 
# Agent-team storage policy
artifact_store:
  mode: engram      # Persistent, repo-clean

​
The Sub-Agents

Each sub-agent is a SKILL.md file — pure Markdown instructions that any AI assistant can follow.

Init

Detects project stack and bootstraps persistence backend

Explorer

Investigates codebase, compares approaches, identifies risks

Proposer

Creates proposal with intent, scope, and rollback plan

Spec Writer

Writes delta specs with Given/When/Then scenarios

Designer

Creates architecture decisions with rationale

Task Planner

Breaks down into phased, numbered task checklist

Implementer

Writes code following specs and design. v2.0: TDD workflow support

Verifier

Validates implementation against specs. v2.0: real test execution

Archiver

Merges delta specs into main specs, moves to archive

​
Why Not Just Use OpenSpec?

OpenSpec is great. We took heavy inspiration from it. But:
OpenSpecAgent Teams Lite
DependenciesRequires npm install -g @fission-ai/openspecZero. Pure Markdown files.
Sub-agentsRuns inline (one context window)True sub-agent delegation (fresh context per phase)
Context usageEverything in one conversationOrchestrator stays lightweight, sub-agents get fresh context
CustomizationEdit YAML schemas + rebuildEdit Markdown files, instant effect
Tool support20+ tools via CLIAny tool that can read Markdown (infinite)
SetupCLI init + slash commandsCopy files + go
The key difference is the sub-agent architecture. OpenSpec runs everything in a single conversation context. Agent Teams Lite uses the Task tool to spawn fresh-context sub-agents, keeping the orchestrator’s context window clean.
This means:
  • Less context compression = fewer hallucinations
  • Each sub-agent gets focused instructions = better output quality
  • Orchestrator stays lightweight = can handle longer feature development sessions

​
Next Steps

Quick Start

Get Agent Teams Lite running in 5 minutes

How It Works

Deep dive into the architecture and workflow

Installation

Setup guides for all supported AI tools

Commands

Learn all the SDD commands

Build docs developers (and LLMs) love

Get started for freeTalk to us