Orchestral AI is a multi-agent orchestration platform that turns project requirements into executable workflows. It combines a visual workflow builder, agent execution simulation, GitHub publishing, and Streamlit deployment automation in one interface — powered by LangGraph and Mistral AI for multi-agent orchestration, planning, and execution.
Orchestral AI automates the software development lifecycle by orchestrating a team of specialized AI agents — from product planning to deployment. Instead of manually breaking down requirements, writing boilerplate, running tests, and configuring infrastructure, Orchestral AI handles the entire pipeline through an interactive, visual workflow canvas.
Users describe their project once during onboarding. The platform generates a team of AI agents (Product Manager, Architect, Developer, QA Engineer, Compliance Engineer, DevOps), assigns tasks with dependencies, and executes them in sequence — with full observability via real-time logs and status tracking.
The workflow is fully visual and interactive:
- Onboard your project with a description and configuration
- Generate an agent plan and workflow graph automatically
- Customize agents, tasks, and execution order on a drag-and-drop canvas
- Execute tasks with live status updates and runtime logs
- Commit outputs directly to GitHub
- Deploy to Streamlit with a single trigger
- Next.js 16 — web application framework
- React 19 — UI library
- TypeScript — type-safe development
- Tailwind CSS — utility-first styling
- React Flow — visual workflow canvas with drag-and-drop nodes and edges
- Framer Motion — animations and transitions
- Recharts — data visualization and analytics
- WorkOS AuthKit — authentication and identity
- Supabase JS — client-side database access
- FastAPI — backend API framework for MCP service integrations
- LangGraph — multi-agent orchestration and stateful workflow execution
- Mistral AI — agent planning, task generation, and execution
- ElevenLabs — voice agent sessions for pitch simulation
- Anam SDK — avatar-based voice playback
- Supabase Postgres — projects, sessions, agent memory, and execution state
- Google Cloud Storage — file uploads and artifact storage
- Vercel — frontend deployment
- Docker — containerized backend
- GitHub REST API — automated repository creation and file commits
- Streamlit MCP — deployment trigger for generated applications
Orchestral AI is split into two runtime layers:
orchestral-ai/— Next.js application (deployed on Vercel)backend/— FastAPI integration layer for MCP services
flowchart LR
user["User (Onboard / Workflow UI)"] --> nextjs["Next.js App (Vercel)"]
nextjs --> plan_api["Agent Planning API"]
nextjs --> run_api["Agent Run API"]
nextjs --> commit_api["Agent Commit API"]
commit_api --> mcp_backend["FastAPI MCP Backend"]
mcp_backend --> github_api["GitHub API"]
mcp_backend --> streamlit_api["Streamlit API"]
nextjs --> supabase["Supabase (projects + memory)"]
nextjs --> mistral["Mistral API"]
run_api --> ai_pm["AI Product Manager"]
run_api --> ai_architect["AI Architect"]
run_api --> ai_developer["AI Developer"]
run_api --> ai_qa["AI QA Engineer"]
run_api --> ai_compliance["AI Compliance Engineer"]
run_api --> ai_devops["AI DevOps"]
Orchestral AI assembles a virtual engineering team of six specialized agents, each responsible for a distinct phase of the software development lifecycle:
| Agent | Role |
|---|---|
| AI Product Manager | Translates requirements into structured specs and acceptance criteria |
| AI Architect | Designs system architecture, data models, and integration points |
| AI Developer | Generates application code, components, and business logic |
| AI QA Engineer | Writes test cases, validates outputs, and identifies edge cases |
| AI Compliance Engineer | Reviews for security, licensing, and regulatory considerations |
| AI DevOps | Configures deployment pipelines, Dockerfiles, and infrastructure |
- Interactive drag-and-drop workflow builder powered by React Flow
- Agent and task node editing with edge-based execution order
- Real-time status tracking across all agents and tasks
- Execution simulation with runtime logs and error-aware retries
- Execution errors are stored in Supabase as agent memory entries
- Failed tasks can be retried with context from previous failures
- Agents learn from prior errors to improve subsequent runs
- Automatic GitHub repository creation from workflow outputs
- File-by-file commits via the MCP backend
- Optional Streamlit deployment trigger after successful push
- MCP-style app connection flow from onboarding
- Voice-first pitch simulation powered by ElevenLabs Agents
- Avatar-based voice playback via Anam SDK
- Structured feedback sessions with AI coaching
- Onboard — User enters project details (description, tech stack, integrations) in
/dashboard/onboard - Plan — App generates an agent plan with tasks, dependencies, and execution order
- Customize — User edits agents, tasks, and workflow edges on the visual canvas
- Execute — Tasks run sequentially with live logs, status updates, and retry logic
- Commit — Generated outputs are committed to a new or existing GitHub repository
- Deploy — Streamlit deployment can be triggered directly from the workflow
| Route | Method | Description |
|---|---|---|
/api/agents/plan |
POST | Generates workflow agents and tasks from project input |
/api/agents/run |
POST | Executes a task with the assigned agent |
/api/agents/commit |
POST | Pushes generated files to GitHub and handles deploy handoff |
/api/agents/memory |
POST | Stores execution error memory entries |
/api/pitch |
GET | Returns config for investor simulation session |
/api/feedback |
GET | Returns config for coach feedback session |
| Route | Method | Description |
|---|---|---|
/mcp/github/connect |
POST | Register GitHub credentials |
/mcp/github/contents/{owner}/{repo} |
PUT | Create or update repository files |
/mcp/streamlit/connect |
POST | Register Streamlit/GitHub deployment credentials |
/mcp/streamlit/apps/{owner}/{repo}/deploy |
POST | Trigger Streamlit redeploy |
- UI static assets:
orchestral-ai/public/ - Pixel agent sprites:
orchestral-ai/public/pixel-agents/ - SQL setup scripts:
orchestral-ai/supabase/
- Node.js 20+
- npm
- Python 3.10+
- pip
git clone https://github.com/binaryshrey/Orchestral-AI.git
cd Orchestral-AIcd orchestral-ai
npm install
npm run devFrontend runs on http://localhost:3000.
cd backend
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
uvicorn app.main:app --reload --port 8000Backend runs on http://localhost:8000.
Create a .env.local file under orchestral-ai/ with the following keys:
NEXT_PUBLIC_SUPABASE_URL=XXXXX
NEXT_PUBLIC_SUPABASE_ANON_KEY=XXXXX
SUPABASE_SERVICE_ROLE_KEY=XXXXX
MISTRAL_API_KEY=XXXXX
NEXT_PUBLIC_API_URL=XXXXX
WORKOS_CLIENT_ID=XXXXX
WORKOS_API_KEY=XXXXX
WORKOS_COOKIE_PASSWORD=XXXXX
NEXT_PUBLIC_WORKOS_REDIRECT_URI=XXXXX
ANAM_API_KEY=XXXXX
ANAM_AVATAR_ID=XXXXX
ELEVENLABS_AGENT_ID=XXXXX
- Frontend — deployed on Vercel at orchestral-ai.vercel.app
- Backend — deploy
backend/as a containerized FastAPI service (Render, GCP Cloud Run, or similar) - Ensure CORS and environment variables are configured for production domains
Apache License 2.0