sweteam — Autonomous Coding Agent Orchestrator

Web Dashboard

Monitor all your sessions, tasks, and agent output from a browser-based dashboard.

$ npm run web

Session list

Browse all sessions at a glance — status badges, task progress bars, and timestamps.

Session detail

Click into any session to see the full conversation timeline, task breakdown, progress ring, and PR link.

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
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

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
`@watch`	Re-attach to live agent output
`@ask <question>`	Ask the architect agent about the dev process
`@cancel`	Cancel the current planner run (session stays active)
`@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
`/delete --all`	Delete all sessions
`/init`	Re-run CLI discovery
`/help`	Show help
`/exit`	Quit
`/quit`	Quit (alias for /exit)

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

Feature To Do

Upcoming features on the roadmap.

Autonomous agent communication via Telegram — Enable agents to send status updates, ask for feedback, and receive commands through Telegram.
Web UI — A browser-based interface for managing sessions, viewing agent progress, and interacting with the planner.