diraigent
the conductor for your
software orchestra
vibecoding for pros.
orchestrate your development workflow end to end —
define what you want built, agents handle the rest.
what it does
workflow pipelines
define multi-step workflows that match how your team works. agents follow the pipeline automatically, step by step.
parallel isolation
each task runs in its own isolated environment. no conflicts, no pollution. multiple agents work in parallel without stepping on each other.
knowledge & decisions
agents build up project knowledge and propose decisions as they work. your codebase learns and improves over time.
full visibility
track tasks, agents, and progress in real time. every log, every action, every decision — visible and searchable.
verification & audit
every step is logged and verified. quality checks, test results, and artifacts are recorded on each task before it moves forward.
continuous improvement
completed work gets analyzed and feeds back into new tasks — creating a self-perpetuating improvement cycle.
how it works
define the work
describe what you want built. attach a workflow to define how it gets done.
agents pick up & deliver
an available agent claims the task, works in isolation, and delivers results with full logs.
review & ship
the workflow advances through quality checks and review. nothing lands without passing your gates.
learn & improve
completed work feeds back as knowledge. the next cycle starts smarter than the last.
playbooks
standard
implement → review → merge
the default development workflow. agent implements, human reviews, code ships.
dreamer
implement → review → merge → dream
self-improving. after shipping, the agent posts follow-up task suggestions based on what it learned.
researcher
scope → gather → synthesize → document
research and documentation. scopes the problem, gathers information, synthesizes findings, and writes it up.
example: standard playbook
{
"title": "Standard Lifecycle",
"trigger_description": "implement → review → merge",
"steps": [
{
"name": "implement",
"instruction": "Implement the feature or fix described in the task spec.",
"budget": 12.0,
"allowed_tools": "full"
},
{
"name": "review",
"instruction": "Review the implementation for correctness and test coverage.",
"budget": 5.0,
"allowed_tools": "readonly"
},
{
"name": "merge",
"instruction": "Merge the working branch into main after a passing review.",
"budget": 2.5,
"allowed_tools": "merge"
}
]
}
each step configures model, budget, and tool access. post this to /api/v1/diraigent/playbooks to create it.
why diraigent
most ai coding tools are either unstructured — “just let the ai go” — or black-box saas you can’t inspect. diraigent gives you:
control
runs on your infra, your repos, your rules. your data never leaves your environment.
structure
playbooks define repeatable multi-step workflows with a validated state machine. agents follow the pipeline — no improvising.
auditability
full trail of what every agent did, why, and what it produced. every action logged and searchable.
get started
run diraigent on your own infrastructure in minutes.
works best with claude code —
the orchestra spawns claude code workers in isolated git worktrees for each task.
curl -LO https://www.diraigent.com/get/docker-compose.yml
curl -LO https://www.diraigent.com/get/.env.example
cp .env.example .env # set ANTHROPIC_API_KEY, GIT_REPO_URL
docker compose up -d # start api + web + postgres + nats
docker compose --profile agent up -d # start the orchestradocker-compose.yml
services:
postgres:
image: postgres:18-alpine
environment:
POSTGRES_DB: diraigent
POSTGRES_USER: diraigent
POSTGRES_PASSWORD: diraigent
ports:
- "5433:5432"
volumes:
- pgdata:/var/lib/postgresql/data
nats:
image: nats:latest
command: ["-js", "-sd", "/data"]
ports:
- "4222:4222"
api:
image: diraigent/api:latest
ports:
- "8082:8082"
environment:
HOST: 0.0.0.0
PORT: 8082
DATABASE_URL: postgres://diraigent:diraigent@postgres:5432/diraigent
DEV_USER_ID: ${DEV_USER_ID:-}
AUTH_JWKS_URL: ${AUTH_JWKS_URL:-}
NATS_URL: nats://nats:4222
CORS_ORIGINS: ${CORS_ORIGINS:-http://localhost:8080}
depends_on:
postgres: { condition: service_healthy }
nats: { condition: service_started }
web:
image: diraigent/web:latest
ports:
- "8080:80"
depends_on:
api: { condition: service_healthy }
orchestra:
image: diraigent/orchestra:latest
environment:
AGENT_ID: ${AGENT_ID}
ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY}
GIT_REPO_URL: ${GIT_REPO_URL}
DIRAIGENT_API: http://api:8082/api/v1/diraigent
NATS_URL: nats://nats:4222
volumes:
- orchestra-repo:/repo
depends_on:
api: { condition: service_healthy }
profiles:
- agent
volumes:
pgdata:
nats-data:
orchestra-repo: