Autonomous/Engine Get started

A ticket in.
A pull request out.
Nine stages in between.

AE is a pipeline of specialised agents coordinated by a state machine and a Kafka bus. Each stage has one job. Each handoff is explicit. Nothing runs implicitly, and nothing runs in the dark.

01 stage

Intake   —   A ticket enters the pipeline.

From Jira, the customer portal, or the API. AE inspects prerequisites, checks the repo, and opens a work item.

02 stage

PRD   —   Ambiguous tickets become concrete asks.

The product agent refines the ticket into a PRD grounded in your codebase. You can review it before implementation begins.

03 stage

Research   —   The codebase is read, not guessed at.

Research agents scan relevant files, identify patterns, and summarise what the implementation actually needs to know. No hallucinated findings — only what was actually found.

04 stage

Planning   —   Work is decomposed into ordered subtasks.

The implementation planner produces code-focused tasks with dependencies. No doc tasks. No git-history tasks. Just the code.

05 stage

Implementation   —   Code is written, tested, verified, then committed.

TDD by default. Tests verified before commit. Three retries with feedback on failure. Git operations are deterministic — the LLM never commits unilaterally.

06 stage

Review   —   A separate agent reads the diff.

Approves or requests changes. Feedback loops back into implementation with three more attempts.

07 stage

Human review   —   You see the actual diff.

Syntax-highlighted, in the approval queue. Approve, request changes, or reject. No summaries standing in for the code.

08 stage

QA   —   The real test suite runs on the feature branch.

Not a mock. Not a subset. If tests fail, a bug loop routes the fix back to implementation with the failure context.

09 stage

PR   —   A pull request is opened.

The description is derived from the real diff — never a hallucinated summary.

Twenty services.
One bus. Zero shared state.

// the agents
product-agent          interprets tickets → PRD
research-coordinator   dispatches research sub-tasks
research-agent         individual research steps
implementation-planner research → task tree
implementation-agent   TDD · write · verify · commit
review-agent           automated code review
qa-agent               runs the test suite for real
pr-coordinator         opens and manages PRs

// the plumbing
gateway                HTTP / WebSocket · JWT auth
status-orchestrator    state machine · transitions
jira-sync              keeps Jira in sync
github-service         wraps GitHub API
webhook-listener       GitHub + Jira webhooks
change-reconciler      detects upstream changes
knowledge-indexer      vectorises your codebase
dashboard-backend      serves the operator UI
onboarding             new repo integration
Runtime

Go services, Kafka message bus, Postgres work graph, Redis for pub/sub. Each service is stateless — state lives in the work-item graph.

Dashboard

React SPA. Real-time subscriptions. Approval queue shows actual git diffs with syntax highlighting.

Deployment

20 containers via docker-compose or a Helm chart for Kubernetes. Scale individual agents horizontally as load demands.

Your infra

The engine, the dashboard, your data, your repos.

Your LLM

OpenAI, Anthropic, self-hosted Ollama, anything compatible. Bring your own keys.

Our infra

The license server only. No code, no data, nothing sensitive passes through us.