§ 00 / INDEX

The autonomous
engineering team
you control.

Not a tool. A colleague. Autonomous Engine maintains a living knowledge base of your codebase — its architecture, patterns, domain vocabulary, and the dependencies between every module across every repo you give it — and uses that knowledge to ship coordinated pull requests from a single ticket. On your infrastructure. With your LLMs. On your terms.

From $49/yr How it works

Codex-grounded · multi-repo by design · unlimited agent runs · unlimited repos · same software for every tier

Codex sections

repos per product

microservices

100%

self-hosted

§ 01 / PRINCIPLES

Three rules, not features.
Codified in source.

Every AI coding tool overpromises. AE is explicit about what it can and can't do — and the rules are enforced in the engine itself, not the marketing copy.

Transparency

Every agent action is visible in real time. Every tool call, every file read, every command — logged and explainable. You watch the work happen on your own dashboard.

Fail honestly

When the system knows it can't do something, it stops and tells you. No degraded fallbacks. No hallucinated success. "I can't do this" is always a valid answer.

Trust through honesty

No synthetic research. No fake metrics. No claimed commits that never happened. Every output is grounded in what actually ran — and in the Codex.

Read the full principles →

§ 02 / PIPELINE

A ticket in. A pull request out.
Everything visible in between.

┌─ intake       ──────────▶  Jira / portal / API
│
├─ prd          ──────────▶  product agent refines the ask · grounded in Codex
│
├─ research     ──────────▶  swarm queries Codex · scans affected repos
│
├─ planning     ──────────▶  ordered subtasks · cross-repo dep graph
│
├─ impl         ──────────▶  TDD · tests verified before commit
│
├─ review       ──────────▶  diff read against Codex patterns · feedback loop
│
├─ human_review ──────────▶  approval queue · real git diff
│
├─ qa           ──────────▶  real test suite on feature branch
│
└─ pr           ──────────▶  linked PRs across every affected repo

Every stage is a separate service. Every handoff is explicit. If an agent can't do its job, the pipeline stops — it doesn't hallucinate a result to keep moving.

State machine: 9 states, explicit transitions
Git: Deterministic — not LLM-controlled
Retries: 3 attempts with feedback, then escalate
LLMs: OpenAI · Anthropic · Ollama · yours

Read the architecture →

§ 03 / CODEX

A living
knowledge base.
Not a search index.

The Codex is what makes the difference between AI that guesses and AI that knows. Before any agent writes code, it queries the Codex — a structured, versioned document of your architecture, patterns, anti-patterns, module dependencies, domain vocabulary, and testing philosophy.

Agents don't hallucinate what your repo "probably" looks like. They look it up.

§ 01 codex

Architecture

System shape, infra, data stores, integrations, deployment model.

§ 02 codex

Module catalog

Purpose, public interface, dependencies, dependents, risk level, coverage gaps — for every module.

§ 03 codex

Patterns

When to use, reference impls, rationale. The canonical examples agents copy from.

§ 04 codex

Anti-patterns

What to avoid, why, and the historical incident that taught the team the lesson.

§ 05 codex

Testing philosophy

How your tests are structured, what gets mocked, what the CI pipeline expects.

§ 06 codex

Code style

Naming, error messages, logging, config — everything past what the linter enforces.

§ 07 codex

Process patterns

Branch names, PR size, commit format, Jira hierarchy, release process.

§ 08 codex

Domain knowledge

Business rules, compliance constraints, SLAs, data sensitivity.

Versioned, not static

Every change to your code is a change to the Codex.

Each Codex version is sequential and diff-able. Work items are tagged with the version they were planned against. When the Codex updates, in-flight work is evaluated: sections that didn't change continue untouched; sections that did are re-planned.

 // Codex version 847 — change summary + pattern: "Idempotent handlers via RequestID middleware" ~ module: billing — added public method ChargeRefund(...) − anti-pattern: "Direct SQL in handlers" — obsolete, pattern fully adopted  12 in-flight work items tagged v846 · 3 require re-planning 

The full Codex spec →

§ 04 / MULTI-REPO

One ticket.
Every affected repo.

A product in AE isn't a repo — it's a collection of repos indexed into a single Codex. Change a shared interface and the planner sees every dependent, scopes the work across all of them, and opens coordinated pull requests.

The rest of the industry pretends each repo is an island. AE treats your engineering org the way you do.

product:  "Payments platform"
│
├─ repo  payments-api        Go · public REST + internal gRPC
├─ repo  payments-worker     Go · async jobs
├─ repo  payments-web        TypeScript · merchant console
├─ repo  payments-sdk-js     TypeScript · published SDK
└─ repo  payments-sdk-go     Go · published SDK
    │
    ▼  one Codex · one zone graph · one knowledge base

// ticket: "Add idempotency key to /v1/charges"
├─ payments-api    → PR · accept header, validate, persist
├─ payments-worker → PR · pass-through in retry path
├─ payments-web    → PR · surface on charge form
├─ payments-sdk-js → PR · new optional arg + types
└─ payments-sdk-go → PR · new optional arg + types

Scenario · 01

Shared library

Change the public interface of a shared library → planner sees every dependent repo, opens coordinated PRs with matching updates. One ticket, one review cycle, many commits.

Scenario · 02

Cross-service feature

A new feature spans the API, the worker, and the web client. The research swarm investigates each repo; the planner produces an ordered task graph; each impl agent commits to its repo; PRs are linked.

Scenario · 03

Migration

Deprecate a pattern in one place and it has to be replaced everywhere it's used. The Codex knows every usage; the planner rolls through them in priority order.

Zones

Ownership boundaries in the Codex. Agents working in one zone don't worry about freezes in another. Teams can lock zones for planned rewrites without blocking unrelated work.

Change reconciler

External changes made outside the pipeline — direct commits, emergency fixes — are detected, indexed, and reconciled back into the Codex automatically.

Multi-org by default

Every deployment is tenant-isolated from day one. Safe for platform teams running AE for multiple product groups with independent Codexes.

§ 05 / YOUR INFRASTRUCTURE

Run it. On your terms.

Every byte runs on your infrastructure. Your code, your Codex, your LLM traffic — none of it touches our servers. No data leaves your network. The only thing we operate is the license server, and that only sees subscription state.

What runs where

▸Your infra: engine, Codex, vector store, dashboard, data, repos
▸Your LLM: OpenAI, Anthropic, self-hosted Ollama, vLLM
▸Our infra: license server only — no code, no data, no Codex

§ 06 / PRICING

Same software.
Different support.

Every tier ships identical binaries, unlimited repos, unlimited agent runs. You pay for update access and the level of help you want. No feature gates.

For small teams shipping fast

Details →

03 · Agency

$4,990