ORBIT — Autonomous Multi-Agent SDLC Orchestrator

ORBIT is an open-source framework that runs a full software delivery pipeline autonomously — from a plain-English goal to working, tested, and documented code — using a team of AI agents powered by any LLM provider.

How It Works

You give ORBIT a goal. It runs a 6-phase pipeline:

UNDERSTAND → BRIEF → BUILD → QA → REVIEW → DELIVER

Each phase is handled by a specialist agent (Manager, TechLead, Dev × N, Tester, Reviewer, Docs). Human approval gates pause at key decision points so you stay in control.

Quickstart (5 minutes, no API key needed)

# 1. Clone and install
git clone https://github.com/blueforgeai-svg/orbit.git
cd orbit
pip install -e .

# 2. Run in stub mode (no API key required — agents use mock responses)
python orbit_cli.py sdlc run --goal "Write a REST API for user authentication" --stub

# 3. Or try the demo to verify everything works
python run_demo.py

Use with a Real LLM

Copy .env.example to .env and add one API key — ORBIT auto-detects which provider to use:

cp .env.example .env
# Edit .env and uncomment your provider key, e.g.:
# ANTHROPIC_API_KEY=sk-ant-...
# or GROQ_API_KEY=gsk_...  (free tier available)
# or OLLAMA_API_BASE=http://localhost:11434/v1  (fully local, free)

python orbit_cli.py sdlc run --goal "Add OAuth2 login with Google" --budget 2.00

Supported Providers

ORBIT works with 13 LLM providers via LiteLLM:

Provider	Free Tier	Speed	Notes
Ollama	✅ Free	Fast	Run models locally — zero cost
Groq	✅ Free tier	Very fast	LLaMA 3.3, Mixtral
OpenRouter	✅ Free models	Fast	100+ models, free Gemini Flash
Anthropic	Pay-per-token	Fast	Claude 3.7 Sonnet, Haiku
OpenAI	Pay-per-token	Fast	GPT-4o, GPT-4o-mini
Google	Pay-per-token	Fast	Gemini 2.0 Flash, 1.5 Pro
Mistral	Pay-per-token	Fast	Mistral Large/Medium/Small
DeepSeek	Very cheap	Fast	DeepSeek V3
Groq (paid)	Pay-per-token	Fastest	Sub-second latency
Together AI	Pay-per-token	Fast	LLaMA, Qwen open-source
Cohere	Pay-per-token	Fast	Command R+
Fireworks	Pay-per-token	Fast	Open-source hosting
xAI	Pay-per-token	Fast	Grok-2

Smart Cost Routing

ORBIT automatically picks the cheapest model that meets each task's quality bar — saving 50–90% vs always using your best model:

Task complexity S  →  nano tier  (e.g. Groq LLaMA 8B  — ~$0.01/task)
Task complexity M  →  nano tier  (e.g. Gemini Flash    — ~$0.02/task)
Task complexity L  →  mid  tier  (e.g. GPT-4o-mini     — ~$0.10/task)
Task complexity XL →  full tier  (e.g. Claude Sonnet   — ~$0.80/task)
Manager / Reviewer →  full tier  (always — high-stakes decisions)

CLI Reference

# Run a full SDLC pipeline
orbit sdlc run --goal "Your goal here"
orbit sdlc run --goal "Your goal" --stub              # no API key needed
orbit sdlc run --goal "Your goal" --budget 5.00       # cost cap
orbit sdlc run --goal "Your goal" --provider groq     # specific provider

# Decompose a goal into tasks (DAG preview)
orbit dag decompose --goal "Build a login system"

# List available providers and detected API keys
orbit providers

# Generate your machine's license key
orbit generate-key

Python API

import asyncio
from orbit.sdlc_pipeline import SDLCPipeline
from orbit.approval import ApprovalMode

pipeline = SDLCPipeline(
    project_id="my-app",
    goal="Add a REST endpoint for user profile updates",
    budget_usd=5.0,
    stub_mode=False,          # use real LLM
    provider="auto",          # auto-detect from env
    approval_mode=ApprovalMode.INTERACTIVE,  # pause for human review
)

result = asyncio.run(pipeline.run())
print(result.summary())

# Just decompose a goal into a task graph
import asyncio
from orbit.dag import decompose_goal

graph = asyncio.run(decompose_goal("Build a login system", stub_mode=True))
for task in graph.tasks:
    print(f"[{task.complexity_score}/10] {task.id}: {task.description}")
    print(f"  deps: {task.dependencies}")

Project Structure

orbit/
├── dag.py              # Goal → task graph (DAG) engine
├── schema.py           # All Pydantic data models
├── sdlc_pipeline.py    # 6-phase SDLC orchestrator
├── agent_pool.py       # Dynamic agent spawn/teardown
├── model_router.py     # Smart cost-based model selection
├── agents/
│   ├── base.py         # BaseAgent (all agents inherit this)
│   ├── manager.py      # Phase 0: understands goal, estimates effort
│   ├── tech_lead.py    # Phase 1: decomposes tasks, briefs engineers
│   ├── dev.py          # Phase 2: writes code (spawned in parallel)
│   ├── tester.py       # Phase 3: runs test suite, reports failures
│   ├── reviewer.py     # Phase 4: code quality review
│   └── docs.py         # Phase 5: CHANGELOG, README updates
├── comms.py            # Agent message bus
├── approval.py         # Human approval gates
├── project_memory.py   # Persistent cross-session memory
├── checkpointer.py     # Execution state snapshots
└── model_router.py     # LLM cost routing
api/
└── main.py             # FastAPI REST + SSE streaming API
tests/                  # Full test suite (pytest)
orbit_cli.py            # CLI entry point (Click)
run_demo.py             # Quick demo — no API key needed

Running Tests

# All tests (stub mode — no API key needed)
pytest

# Specific test files
pytest tests/test_dag.py tests/test_e2e.py -v

# With a real LLM (set your API key first)
ORBIT_STUB_MODE=false pytest tests/test_e2e.py -v

Approval Modes

Mode	Behaviour
INTERACTIVE	Pauses at each gate, waits for y/n in terminal
AUTO_APPROVE	Approves all gates automatically (CI/CD, testing)
AUTO_REJECT	Rejects all gates (dry-run, validation)
CALLBACK	Calls your async function for custom approval logic

Environment Variables

Variable	Default	Description
ORBIT_STUB_MODE	true	false to use real LLM
ORBIT_DEFAULT_PROVIDER	auto	Provider name or auto
ORBIT_DEFAULT_BUDGET_USD	5.00	Default session budget
ORBIT_MAX_DEV_AGENTS	4	Max parallel dev agents
ORBIT_DECOMPOSE_MODEL	(router default)	Override model for goal decomposition
OLLAMA_API_BASE	—	Ollama endpoint (e.g. http://localhost:11434/v1)
OLLAMA_MODEL	ollama/llama3.2	Ollama model name

Requirements

• Python 3.11+
• pip install -e . installs all dependencies

No API key is required to run in stub mode. For real LLM usage, set any one provider key in .env.

License

MIT