sweteam — Autonomous Coding Agent Orchestrator

Why sweteam?

Real software isn't built by a single person typing in a terminal. It's built by teams — a tech lead breaks down the work, engineers pick up tasks, reviewers catch mistakes, and the whole thing ships through a structured process.

sweteam brings that same discipline to AI coding agents. It doesn't replace your coding agents — it gives them the same structure that makes real engineering teams ship reliable code.

1

You (PM)

Describe what you want. The planner asks questions, proposes an architecture, and breaks it into scoped tasks — just like a tech lead running a planning session.

2

Planner (Tech Lead)

Decomposes your goal into small tasks with acceptance criteria, dependency order, and file-level scope. You review and refine before anything gets built.

3

Coders (Engineers)

Each task is assigned to a coding agent on its own branch. Independent tasks run in parallel — like engineers on a team working on separate features simultaneously.

4

Reviewer (Senior Engineer)

A separate agent reviews each task's diff against its acceptance criteria. If the review fails, the coder automatically retries until the reviewer is satisfied.

5

Git + PR (CI/CD)

Approved tasks are merged, the branch is pushed, and a PR is opened. The session stays open — give feedback, agents iterate on the same PR until you're satisfied.

Features

📋 Session-based

Every interaction lives in a persistent session with full history. Crash, close the terminal, come back tomorrow — nothing is lost.

⚡ Zero config

Discovers installed CLIs automatically and uses their existing auth. No API keys to configure, no extra setup.

💬 Human-in-the-loop

Chat with the planner, refine the plan, then go hands-off. You stay in control of the strategy.

🎯 Parallel execution

Independent tasks run concurrently across multiple agents, organized into a dependency graph (DAG).

🔍 Multi-model review

Every task is reviewed by a separate agent against its acceptance criteria. Failures are retried automatically.

🔄 Feedback iterations

Session stays open after the PR. Give feedback, agents iterate on the same PR until you're satisfied.

📺 Live attach

Re-enter any session and see agent output streaming in real time. Never lose track of what's happening.

🔌 Pluggable agents

Supports Claude Code, Codex CLI, OpenCode, or any custom CLI that reads stdin and writes stdout.

🛠 Git native

All git and GitHub operations via git and gh CLI directly. No abstractions, no surprises.

How It Works

sweteam follows a structured pipeline from plan to PR.

Plan

Planner decomposes your goal into tasks with dependencies

DAG

Tasks organized into a dependency graph

Dispatch

Independent tasks run concurrently

Code

Each task assigned to a coding agent on its own branch

Review

Reviewer checks diff against acceptance criteria

Fix Loop

If review finds issues, coder retries automatically

Merge

Approved tasks squash-merged into session branch

PR

Branch pushed and GitHub PR created automatically

Session Lifecycle

                    /create
                       │
                       v
        ┌──────────────────────────┐
        │        planning          │ <── chat with planner
        └────────────┬─────────────┘
                     │ @build
                     v
        ┌──────────────────────────┐
        │        building          │ <── agents code + review
        └────────────┬─────────────┘
                     │
                     v
        ┌──────────────────────────┐
        │    awaiting_feedback     │ <── PR created, user reviews
        └────────────┬─────────────┘
                     │ @feedback
                     v
        ┌──────────────────────────┐
        │        iterating         │ <── agents apply feedback
        └────────────┬─────────────┘
                     │
                     v
              awaiting_feedback ─── (loops until satisfied)
                     │
                     │ /stop
                     v
        ┌──────────────────────────┐
        │         stopped          │
        └──────────────────────────┘

Quick Start

Prerequisites

You need at least one coding CLI installed:

CLI	Install
Claude Code	`npm install -g @anthropic-ai/claude-code`
Codex CLI	`npm install -g @openai/codex`
OpenCode	`go install github.com/opencode-ai/opencode@latest`

Plus: git, gh (GitHub CLI, authenticated), and Node.js v18+.

1. Install

npm install -g sweteam

2. Initialize

sweteam init

Auto-discovers your installed CLIs and generates ~/.sweteam/config.toml.

3. Create a session

sweteam create myrepo
# Or from the interactive REPL:
sweteam
sweteam> /create myrepo

4. Plan interactively

myrepo> Add dark theme with system preference detection and a Ctrl+T toggle

▶ Planner ─ s_a1b2c3d4: Add dark theme
────────────────────────────────────────
│ I'll break this down into 6 tasks:
│ task-001: Add ThemeConfig and color definitions
│ task-002: Implement system preference detection
│ task-003: Create dark theme preset
│ ...
│ Type @build when you're ready.

myrepo> @build

5. Watch it build

sweteam dispatches tasks to coding agents, runs reviews, and creates a PR — all autonomously.

6. Give feedback

myrepo> @feedback The dark theme colors are too muted. Make the accent brighter (#00BFFF).

Agents pick up your feedback, iterate, and push updates to the same PR.

Commands

Top-level commands

Command	Description
`sweteam`	Launch interactive REPL
`sweteam init`	Auto-discover CLIs and generate config
`sweteam create [repo]`	Create a new session
`sweteam list`	List all sessions
`sweteam enter <id>`	Re-enter an existing session
`sweteam show <id>`	Show detailed session status
`sweteam stop <id>`	Stop a session
`sweteam delete <id>`	Delete a session

In-session commands

Command	Description
`@build`	Finalize plan and start autonomous coding
`@status`	Show task progress dashboard
`@plan`	Re-display the current plan
`@feedback <text>`	Give feedback on completed work (triggers new iteration)
`@diff`	Show cumulative diff
`@pr`	Show the PR link
`@tasks`	List all tasks with statuses and review info
`@stop`	Stop this session
`@help`	Show available commands

REPL commands

Command	Description
`/create [repo]`	Start a new session
`/list`	See all sessions
`/enter <id>`	Resume a session
`/show <id>`	Inspect a session
`/stop <id>`	Stop a session
`/delete <id>`	Delete a session
`/init`	Re-run CLI discovery
`/help`	Show help
`/exit`	Quit

CLI flags

sweteam --coder codex          # Override coder agent
sweteam --reviewer claude-code # Override reviewer agent
sweteam --parallel 5           # Override max parallel tasks
sweteam --config ./custom.toml # Use custom config file

Architecture

sweteam is built with TypeScript and uses a layered architecture with pluggable agent adapters.

┌──────────────────────────────────────────────────────────┐
│                       sweteam CLI                        │
│                                                          │
│  ┌──────────┐  ┌──────────────┐  ┌────────────────────┐  │
│  │ Session  │  │   Planner    │  │  Orchestrator      │  │
│  │ Manager  │  │  (chat mode) │  │  (autonomous)      │  │
│  └──────────┘  └──────────────┘  └────────────────────┘  │
│                                                          │
│  ┌────────────────────────────────────────────────────┐  │
│  │          Agent Adapter Layer                       │  │
│  │ ┌────────────┐ ┌──────────┐ ┌────────────────────┐ │  │
│  │ │ Claude Code│ │ Codex CLI│ │ OpenCode / Custom  │ │  │
│  │ └────────────┘ └──────────┘ └────────────────────┘ │  │
│  └────────────────────────────────────────────────────┘  │
│                                                          │
│  ┌──────────────────────┐  ┌──────────────────────────┐  │
│  │  SQLite + Drizzle    │  │  git + gh CLI (native)   │  │
│  │  (session store)     │  │  (branches, PRs, commits)│  │
│  └──────────────────────┘  └──────────────────────────┘  │
└──────────────────────────────────────────────────────────┘

Tech Stack

Component	Choice
Language	TypeScript (ESM, Node.js 18+)
ORM	Drizzle
Database	SQLite via better-sqlite3
CLI framework	Commander.js
Terminal UI	Custom (chalk, raw-mode prompt)
Git	`git` + `gh` CLI (child process)
IDs	nanoid
Config	TOML
Tests	Vitest

Project Structure

src/
├── index.ts                 # CLI entry point (Commander.js)
├── repl/                    # Interactive REPL loop
├── session/                 # Session manager, state machine, agent log
├── planner/                 # Planner agent and plan parser
├── orchestrator/            # Task runner, reviewer, build/feedback handlers
├── adapters/                # Agent adapters (claude-code, codex, opencode, custom)
├── commands/                # CLI subcommands (create, list, enter, etc.)
├── config/                  # Config loader and GitHub auth
├── git/                     # Git and GitHub CLI wrappers
├── ui/                      # Terminal UI (banner, prompt, agent panel, markdown)
├── db/                      # SQLite schema and client (Drizzle ORM)
└── __tests__/               # Test suite

Data Storage

~/.sweteam/
├── sweteam.db          # SQLite database (sessions, tasks, messages)
├── config.toml         # Global configuration
├── logs/               # Agent output logs (for live attach)
│   └── s_a1b2c3d4.jsonl
└── repos/              # Cloned repositories
    └── YourName--myrepo/

No API keys stored — coding CLIs manage their own authentication
No network calls — sweteam itself makes zero API requests
Full audit trail — every prompt, response, and system event is stored per session

Configuration

Config lives at ~/.sweteam/config.toml. Generated by sweteam init.

[roles]
planner = "claude-code"       # Which CLI generates the plan
coder = "claude-code"         # Which CLI writes code
reviewer = "claude-code"      # Which CLI reviews code

[execution]
max_parallel = 3              # Concurrent coding agents
max_review_cycles = 3         # Review/fix loops before escalating
branch_prefix = "sw/"         # Prefix for all branches

[git]
commit_style = "conventional" # conventional | simple
squash_on_merge = true

[agents.claude-code]
command = "claude"
args = ["-p"]

[agents.codex]
command = "codex"
args = ["-q"]

[agents.opencode]
command = "opencode"
args = ["--non-interactive"]

Custom Agents

Any CLI that accepts a prompt on stdin and writes output to stdout can be used as an agent:

[agents.my-agent]
command = "my-coding-tool"
args = ["--mode", "autonomous"]
prompt_via = "stdin"          # stdin | arg | file
output_from = "stdout"        # stdout | file

# Then reference it in your roles:
[roles]
coder = "my-agent"

Development

From source

git clone https://github.com/SiluPanda/sweteam.git
cd sweteam
npm install

# Run in dev mode (no build step)
npm run dev

# Run with subcommands
npm run dev -- create myrepo

# Run tests
npm test

# Build
npm run build

# Link globally for testing
npm link

Contributing

Contributions are welcome. Please open an issue first to discuss what you'd like to change.

# Fork and clone
git clone https://github.com/your-name/sweteam.git
cd sweteam
npm install

# Create a branch
git checkout -b feat/my-feature

# Make changes, run tests
npm test

# Submit a PR