Conveyor

Generating code is easier than ever. Checking that the code matches product intent is now the bottleneck, and it is a bottleneck that gets worse as agents get faster: a queue of unsupervised agents can ship more unread code per day than a team can read.

A software factory is the answer to this shape of problem. You do not inspect every screw; you fix the process so that inspection happens at the points where mistakes can happen, and you make every unit traceable so that when something is wrong you know what else is affected.

Conveyor is a software factory for agent-written code.

It queues work from Requirements, System Design documents, and Decisions. Human operators confirm the documents, and approve plans when required. Agents on your machines plan, implement, and review that work.

Conveyor has used this process to build itself since July 2026.

Contributions go through the factory too. To start contributing, request access first by opening an issue, and you will get a workspace account to plan and pick up work from.

The knowledge graph

Conveyor links each change to the documents, task, review, and test evidence behind it.

flowchart LR
    intent["Confirmed requirements<br/>and designs"] --> task["Task"]
    task --> delivery["Delivered change"]

    intent -.-> check{"Misalignment checks"}
    delivery -.-> check
    repository["Observed repository"] -.-> check

    check -->|mismatch found| signal["Signal"]
    signal --> followup["Judgment or gated follow-up"]
    followup -->|re-enters the factory| task

Conveyor checks each delivery against confirmed requirements and governing designs. When a delivery and its confirmed intent disagree, Conveyor raises a signal. Repository drift and post-merge failures raise signals too. Conveyor never rewrites code or documents on its own. An operator can acknowledge the signal or send follow-up work through the normal gates.

Architecture

   Operators in a browser              Agents such as Codex or Claude
             |                                      |
      React dashboard                       MCP work-order server
      board, tasks, docs                    claim, plan, review
             |                                      |
             +------------------+-------------------+
                                |
                         conveyord in Go
                  REST API, dashboard, event log
                                |
                           PostgreSQL
                  events, documents, links, queue
                                |
                    conveyor worker on your machine
                       supervises your agent CLIs
                                |
                    Git worktrees, repositories, PRs

conveyord is one Go binary. PostgreSQL stores the event log, documents, lineage projection, and River queue. The worker launches agent CLIs with your local credentials.

Installation

A factory host needs PostgreSQL 15 or newer, Git, an authenticated gh CLI, an API key for an OpenAI-compatible model endpoint, and the agent CLIs you plan to run.

Install the latest conveyor and conveyord binaries into ~/.local/bin:

curl -fsSL https://raw.githubusercontent.com/kidus-tiliksew/conveyor/main/install.sh | sh

The installer verifies the release checksum before replacing either binary and does not need sudo. Pinning a reviewed version, building from source, and upgrades are covered in Installation.

From there, Getting started (solo) stands up a factory end to end on one machine, and Getting started (multiplayer) covers a shared team server.

Documentation

Full docs live in docs/. There's no docs site yet.

Getting started

• Installation: release installer, source builds, prerequisites
• Getting started (solo): one person, one machine, end to end
• Getting started (multiplayer): a shared team server

Guides

• CLI reference: every conveyor and conveyord command
• Authentication: sign-in, tokens, roles, GitHub identity
• Configuration: the three config surfaces and every environment variable
• MCP reference: the tools an agent uses to work a task

The factory

• Concepts: the software factory, the knowledge graph, light and dark factory patterns
• The document corpus: requirements, System Designs, decisions, and the propose-confirm cycle
• Tasks: how work is created, given context, executed, reviewed, and linked
• Misalignment: drift, staleness, and pending proposals

Operations

• Worker operations: durable worker enrollment, service install, recovery
• GitHub lifecycle: how issues, PRs, and review statuses are projected onto GitHub
• Known limitations: accepted boundaries of the current implementation

Playbooks (installable as agent skills with conveyor skills install)

• Planning: draft and push documents from a local agent session
• Task filing: file well-formed tasks and dependency chains
• Working a task: the claim, checkout, submit, review lifecycle

Status

Conveyor is under active development. Its event log records defects and reconciliation work alongside successful merges.

License

Conveyor is available under the MIT License.