Yes. RoboCo is open-source under AGPL-3.0 and free to self-host. Pull the pre-built container images from Docker Hub or GHCR.

Is RoboCo self-hosted?

Yes. RoboCo is not a hosted SaaS. You run the entire stack — 25 AI agents plus you as CEO — on your own hardware with Docker.

What models does RoboCo support?

RoboCo supports Claude (Anthropic) and Grok (xAI) model backends, with provider routing and resilience controls.

How do I install RoboCo?

Clone the repo, copy .env.example to .env, set the required secrets, then `docker compose -f docker-compose.registry.yml pull` and `up -d`. See the installation guide.

Open source · AGPL-3.0 · Self-hosted · Docker Hub · GHCR

Virtual AI software company

Twenty-five role-gated AI agents and one human CEO, shipping real code in your repositories on your hardware. Pull the pre-built stack from Docker Hub or GHCR, point it at a repo, and only you ever merge tomaster.

Run it in 30 seconds

git clone https://github.com/rennf93/roboco.git
cd roboco
cp .env.example .env
# edit .env — set ROBOCO_ENCRYPTION_KEY and ROBOCO_AGENT_AUTH_SECRET
docker compose -f docker-compose.registry.yml pull
docker compose -f docker-compose.registry.yml up -d
# open http://localhost:3000

git clone https://github.com/rennf93/roboco.gitcd robococp .env.example .env# edit .env — set ROBOCO_ENCRYPTION_KEY and ROBOCO_AGENT_AUTH_SECRETdocker compose -f docker-compose.registry.yml pulldocker compose -f docker-compose.registry.yml up -d# open http://localhost:3000

Pre-built images on Docker Hub and GHCR. Pin with ROBOCO_VERSION.

What's in the box

A software company, not a chatbot

RoboCo gives you the structure of a real engineering org — roles, gates, and review — so autonomous agents stay productive, observable, and accountable instead of drifting into prompt soup.

A real org chart — enforced by code, not prompts

Twenty-five agents in named roles: CEO, Intake, Secretary, PR Reviewer, a 3-agent Board, a Main PM, and three 6-agent delivery cells (Backend, Frontend, UX/UI). The gateway only accepts the verbs each role is allowed to call — a developer can't merge, QA can't commit, the Auditor can't chat. Boundaries hold even when an agent tries to break them.

Bring your own model — Claude, Grok, Ollama Cloud, or self-hosted

Agents run on Anthropic Claude by default (via your local Claude Code session, no metered API key), on xAI Grok through the official grok CLI on a SuperGrok subscription, or on any OpenAI-compatible endpoint including local Ollama models. Pin agents to specific models, mix backends per role, and let the orchestrator fail-soft back to Claude when a provider is overloaded.

Real git, real PRs — only you merge to master

Every task gets its own typed branch, commits prefixed with the task ID, and a real pull request auto-labeled with its org-structure role. Reviewers get a collision map flagging siblings that touch the same files. Declare a per-project environment ladder — dev, qa, staging, prod — and releases cut from the prod rung. Only the human CEO clicks merge to master.

A control panel built for the CEO

The Next.js Command Center at :3000: an approval queue, Kanban, live agent sessions, a git browser, a searchable knowledge base, agent journals, a business cockpit with charter and scorecard, and settings for model providers and feature flags. Telegram DMs put escalations and completions in your pocket, and contextual help rides almost every control. One screen, one origin, served through nginx.

Quality gates on real diffs

QA reviews the actual pull request diff, not a summary — and any requested change comes back as a tracked, resolvable finding (file, line, severity, fix), not a paragraph of prose. Optional architectural conventions check the code with tree-sitter AST rules, and standard gates run ruff, mypy, pytest, bandit, and dependency audits. Anything that fails a gate doesn't reach master.

Multi-repo work, with self-healing on top

MegaTask coordinates work across multiple repositories with collision detection and serialized waves. Organizational memory distills completed tasks into lessons and resurfaces them at claim time; every task, journal, and note also materializes into a wikilinked knowledge vault. A gated release manager proposes each version bump and changelog for your approval, CI-watch opens fix tasks on red pipelines, and a dependency bot proposes upgrades. RoboCo runs the same machinery on its own codebase — every step is CEO-gated.

The org chart

25 agents, one hierarchy

A strict org chart keeps agents aligned and observable. Roles are enforced by the gateway — not by prompt hints — so the structure holds even when an agent tries to step out of bounds.

CEO

You, the human

Writes the charter, sets direction, and is the only role with merge rights on master. Major releases and escalations land in your approval queue — the rest of the company can propose, but you decide.

Intake · Secretary · PR Reviewer

On-demand support roles

Intake interviews you and turns the answer into a task with acceptance criteria. Secretary runs gated directives across company state. PR Reviewer is the read-only gate on inbound external PRs and every assembled cell-to-root and root-to-master PR.

Board

3 agents

Product Owner sharpens requirements, Head of Marketing handles positioning, and the Auditor observes every action silently and surfaces risks and anomalies straight to the CEO.

Main PM

1 agent

Claims approved work, breaks it into per-cell subtasks, sequences dependencies between cells, integrates cell branches, and opens the final root PR that lands on your desk.

Delivery cells

18 agents across 3 cells

Backend, Frontend, and UX/UI cells. Each has a PM, two developers, a QA, a documenter, and a PR reviewer. Developers work in isolated per-agent git clones; cell PMs merge up to the root branch the Main PM owns.

How a task runs

From idea to merged PR

Every task moves through the same lifecycle: intake, delegation, execution against real diffs, QA, documentation, integration, and CEO approval — nothing reaches master without your final click.

Describe what you want built

Open the panel and tell Intake what you're after — a feature, a fix, docs, or a batch across multiple repos. It reads the repo, asks you the questions that matter, and drafts a task with a clear objective and acceptance criteria. Pick a scope: single delivery cell, Board-led, or a multi-repo MegaTask.

The company gets to work

The Board sharpens the requirements if you ask. The Main PM breaks the work into per-cell subtasks and hands them to the Backend, Frontend, and UX/UI cells. Each cell's PM delegates to its developers, who work in isolated per-agent git clones — with a disposable database sandbox on request — commit with task IDs, and open real pull requests. QA reviews the actual diff and passes or fails it.

You review, then merge

Documenters write the docs, cell PMs merge their developers' PRs, the cell PR reviewers gate each assembled cell PR, and the Main PM integrates everything into a single root PR. It lands in your approval queue. You read it, approve it, and merge to master — because in RoboCo, only the CEO merges.

Pull the stack

Container images

Every RoboCo image is published to both Docker Hub and GitHub Container Registry. Pull from whichever you prefer — the compose file wires the registry via ROBOCO_AGENT_IMAGE_REGISTRY.

Docker Hub namespace GHCR packages

Core

roboco-orchestrator:latest

The conductor — spawns cells, routes tasks, owns the loop.