Give it a GitHub repo and a task. Wake up to a PR.
A self-hosted, open-source AI software factory. Fully autonomous. Runs 24/7 on your own server. No cloud lock-in. No per-seat pricing. Your code never leaves your infrastructure.
You: "Add dark mode to the settings page"
Factory: ✅ Analysing repo...
✅ Planning implementation (3 files)...
✅ Implementing changes...
✅ Running tests... (passed)
✅ Self-reviewing diff...
✅ PR opened → github.com/your/repo/pull/42
You: *wakes up* — reviews PR over coffee
┌──────────────────────────────────────────────┐
│ ACODA FACTORY │
│ │
│ Job Submitted (API or UI) │
│ ↓ │
│ ┌───────────────────┐ │
│ │ Temporal │ Durable orchestration│
│ │ (workflow engine)│ Survives crashes │
│ └────────┬──────────┘ Runs for hours/days │
│ ↓ │
│ ┌───────────────────┐ │
│ │ Pool Manager │ 3 warm FORGE slots │
│ │ (Rust + Axum) │ Instant job pickup │
│ └────────┬──────────┘ TTL auto-release │
│ ↓ │
│ ┌───────────────────┐ │
│ │ FORGE Agent │ Analyse → Plan → │
│ │ (TypeScript) │ Implement → Test → │
│ └───────────────────┘ Review → PR │
└──────────────────────────────────────────────┘
Stack:
- Temporal — durable workflow orchestration. Jobs survive server restarts, crashes, and deploys. Each coding job is a long-running Temporal workflow — pause it, resume it, cancel it at any stage.
- FORGE Agent — the AI coding agent. Clones your repo, writes code, runs tests, opens PRs.
- Pool Manager — keeps 3 FORGE workers warm and ready. Zero cold-start latency.
- Any OpenAI-compatible LLM — OpenAI, Ollama, local models, Azure, Anthropic via proxy.
# 1. Clone
git clone https://github.com/leoaicloud-source/acoda-factory
cd acoda-factory
# 2. Configure
cp factory-core/forge-agent/.env.example .env
# Fill in: GITHUB_TOKEN, LLM_API_KEY
# 3. Start
docker compose up -d
# 4. Submit a job
curl -X POST http://localhost:3020/api/forge/jobs \
-H "Content-Type: application/json" \
-d '{
"repoUrl": "https://github.com/your/repo",
"taskDescription": "Add input validation to the login form",
"targetBranch": "main"
}'Watch it work → open http://localhost:3020 for the job dashboard.
acoda-factory/
├── factory-core/
│ ├── forge-agent/ ← FORGE: the AI coding agent
│ │ ├── src/
│ │ │ ├── workflows/ ← Temporal workflow (full SDLC)
│ │ │ ├── activities/ ← Individual steps (analyse, implement, test...)
│ │ │ ├── services/ ← LLM client, GitHub client
│ │ │ └── workers/ ← Temporal worker process
│ │ └── .env.example
│ └── pool-manager/ ← Warm pool manager (Rust)
│ └── src/main.rs
├── docker-compose.yml ← One-command startup (coming soon)
└── README.md
FORGE is a Temporal workflow with 7 stages. Temporal ensures every job is durable — if your server crashes mid-implementation, the job resumes exactly where it left off when it comes back online.
| Stage | What happens |
|---|---|
| Analyse | Clones repo, reads structure, understands codebase |
| Plan | Decides which files to create/modify/delete |
| Branch | Creates a feature branch |
| Implement | Writes each file using LLM, one at a time |
| Test | Runs your test command, captures output |
| Self-review | Reviews its own diff — approves or flags issues |
| PR | Pushes branch, opens PR with summary |
Pause, resume, or cancel any job in-flight via signals.
This is the key difference from cloud coding agents:
- Your code never leaves your server — FORGE clones repos locally, LLM calls go to your chosen provider
- No per-seat pricing — run as many jobs as your server handles
- Works offline — point
LLM_BASE_URLat a local Ollama instance - Extend it — add your own agent types, custom workflows, new skills
- Docker + Docker Compose
- GitHub personal access token (repo + pull_request scope)
- An LLM API key (OpenAI, or any OpenAI-compatible endpoint)
- 2GB RAM minimum (4GB recommended for parallel jobs)
- Autonomous analyse → plan → code → commit → PR pipeline
- Two-model architecture (Claude orchestrator + DeepSeek coder)
- Docker Compose one-command startup
- Self-hosted Temporal (no account required)
- Factory UI — dark mission control dashboard
- GitHub OAuth + repo picker in dashboard UI
- Job submission form (no API knowledge needed)
- WebSocket live updates (replace 5s polling)
- PR auto-merge option with test gate
- Post-merge verifier agent (checks nothing broke)
- Incident responder agent (detects + fixes regressions)
- Weekly digest — PRs shipped, cost saved, time saved
- Webhook triggers (auto-factory on GitHub issue label)
- Multi-repo support
- Custom agent types (add your own beyond FORGE)
- AgentCore kernel sandbox integration (hardened execution)
- Visual workflow editor
- Agent relay daemon — lightweight process in each Factory container, connects outbound to relay server (no inbound ports needed)
- Self-hosted relay server — WebSocket hub routing phone ↔ agent containers
- iOS + Android app (React Native) — built in-house, no third-party SaaS dependency
- List all running agents + live session streaming
- Submit jobs from your phone
- Push notification when PR opens
- One-tap PR review + merge
- Works with Raspberry Pi / ARM64 home devices (Cotex X3, Pi 4/5)
- Raspberry Pi pre-built image (flash + go)
- USB stick distribution (plug into any machine)
- TV kiosk mode (HDMI out, mission control on big screen)
- Fully air-gapped enterprise deployment
- Pi coding agent integration (pi.dev) — replace custom LLM orchestration layer with Pi SDK/RPC mode as the coding engine; ride a maintained open-source harness instead of rolling our own. Pi's RPC mode (stdin/stdout JSONL) slots directly into forge-agent as a drop-in for
forgeLLM.ts. Also unlocks Termux on Android — submit jobs from your phone terminal with zero native app needed.
LeoAi Labs — building autonomous AI infrastructure.
This factory was built using its own tools. Meta.
Open sourced as a base for the community. Fork it. Break it. Make it yours.
PRs welcome. See CONTRIBUTING.md.
MIT — do whatever you want with it.