ASDLC · human-gated · audit-first

Agents ship.
Humans decide.

One platform for the complete software lifecycle: a task becomes an approved plan, a sandboxed implementation, tested changes, a pull request, and a merged outcome — with every gate recorded.

Backend
Go
Frontend
Next.js
State
Postgres + River
Sandbox
Docker / K8s
run / T-128 merged
  1. 1
    Task readyacceptance criteria attached
    ✓
  2. 2
    Plan approvedhuman gate · context frozen
    ✓
  3. 3
    Sandboxed buildno network · no caps · tmpfs
    ✓
  4. 4
    Tests & design gatesdiff policy · acceptance proof
    ✓
  5. 5
    PR approved & mergedhuman gate · audit event
    ✓
audit chain intact · 6 events
Plan before codeSandbox everythingProve acceptanceHuman mergeMeasure outcomes
10concurrent PRs merged in e2e
12 / 12 / 330orgs / projects / tasks restored in the PITR drill
cosignsigned plugin accepted; unsigned rejected
0capabilities in the agent sandbox
verified status

Why this exists

Agent speed, without losing the controls.

Most agent demos stop at a diff. A team needs approvals, isolation, reproducible context, evidence, a merge gate and a paper trail.

Gates, not vibes

Plan approval, test and design checks, acceptance proof and a separate PR approval. Merges stay human.

Isolation by default

Each run gets a disposable sandbox: read-only root, no capabilities, no network, bounded CPU and memory.

Evidence you can audit

Frozen context, diffs, test reports, approvals and an append-only audit chain — queryable, not a screenshot.

The loop

From task to merged change.

Every step is a state transition with an owner, an artifact and a gate.

01

Shape the task

Start from a blueprint, write acceptance criteria and dependencies. A task cannot become ready without a definition of ready.

blueprintsacceptancebacklog
02

Approve the plan

The planning agent inspects a frozen context — task, repository, rules, design standard — and proposes steps, files and risks. A human approves it.

context freezeplanapproval
03

Build in a sandbox

The development agent works in a disposable container. No host access, no network. Changes are diffed, scanned and checked against policy.

sandboxdiff policysecret scan
04

Prove it, then review

Unit, integration, e2e, visual and plugin checks run. Acceptance evidence is validated. A pull request is opened; a second human gate approves the merge.

checksvisual diffPR approval
05

Merge and learn

The merge queue serialises changes. DORA and outcome metrics — first-pass merge, proof validity, rework, escaped defects — feed the next decision.

merge queuemetricsaudit

Platform

Everything around the model.

The agent is one part. The product is the workflow, the guardrails and the evidence.

Blueprints & projects

Stack, repository layout, test strategy, agents and starter tasks become a repeatable project template.

Approvals & policy

Role requirements, approval rules, change windows, diff limits, forbidden paths and allowed models/tools.

Live run view

SSE events, frozen context, diff, test results, retries, artifacts and a baseline-vs-current visual compare.

Custom agents

Register a digest-pinned OCI agent per project. Allowlist, cosign verification and the same gates apply.

Identity & access

Project RBAC, OIDC, SAML SP, SCIM, API keys and per-organisation SSO. Owners never silently lose access.

Operations

Patroni Postgres, WAL/base backups, PITR, DR dashboard, audit witness, SIEM delivery and metrics.

One task, end to end

From a task to a merged change.

No hand-offs to a separate tool. The task, the approvals, the run and the outcome live in one place.

blueprintsopen ↗
Blueprint templates and project blueprints

Project setup

Start from a blueprint

A blueprint is the only entry point for creating a project. Stack, repository layout, test strategy, agents and starter tasks are defined once — then every project starts consistent.

  1. 01

    Shape the work

    A project board with acceptance criteria, dependencies and a definition of ready. The agent cannot start on a vague task.

  2. 02

    Approve the plan

    The planning agent proposes steps, files and risks against a frozen context. A human approves the plan.

  3. 03

    Build and prove

    Implementation runs in a disposable sandbox. Tests, design checks and acceptance evidence are recorded before review.

  4. 04

    Merge and measure

    A PR approval gate precedes the merge queue. The outcome updates delivery and quality metrics.

project / backlogopen ↗
Project board with task statuses and a Run agent action

Result of one run

Contextfrozen · sha256
Gatesplan · tests · design · PR
Mergehuman approved
Evidencediff · checks · audit

Inside the product

A short tour, not a gallery.

Seven screens from the running stack. Pick a step to see what the team actually works with.

Product tour · 7 steps

Every screenshot opens full size.

workspace / overviewopen ↗
Workspace overview with health metrics, projects and getting started checklist

The workspace in one screen

Health metrics, active projects and the next setup step. The team starts here, not in a chat box.

  • agent runs, success rate and measured spend
  • projects with status and owner
  • setup progress that closes the loop

Security & operations

Designed for teams that get audited.

The model is not the security boundary. The runtime, approvals and recovery path are.

Isolation

A disposable box per run

  • read-only root, tmpfs workspace
  • all capabilities dropped, no new privileges
  • no network by default, pids/CPU/memory caps
  • secret scanning and diff policy before review
Governance

Human gates, not prompt rules

  • project RBAC and approval rules
  • append-only audit chain + witness
  • legal hold and NDJSON export
  • OIDC, SAML SP, SCIM and API keys
Recovery

Backups are exercised

  • Patroni leader + streaming replica
  • WAL and base backups to object storage
  • PITR restore requests with verified counts
  • offsite mirror and restore drill

Audit trail

Every decision leaves a trace.

Append-only events, export, legal hold and witness verification — not a chat transcript.

  • who approved what, and when
  • which context was frozen for the run
  • which checks passed before the merge
settings / auditopen ↗
Audit log with export, legal hold, witness and append-only entries

Quickstart

Run it on your machine.

Docker Compose brings up the API, worker, web, Postgres, Redis and MinIO. The demo below is the local developer path.

  1. 1 Generate the JWT key and copy the env file.
  2. 2 Start the stack; migrations run in the migrate service.
  3. 3 Open the web app and create a blueprint.
  4. 4 Run a task through plan, build, PR and merge.
Need a real agent?

Set AIP_AGENT_BACKEND=tools with a provider key, or select a registered custom agent plugin. The fake command backend is for e2e only.

~/ai-engineering-platform
# 1. configure
cp .env.example .env
make keygen

# 2. start the local stack
docker compose up -d postgres redis minio mailhog
make dev

# 3. open
web   http://localhost:3000
api   http://localhost:18080/readyz
minio http://localhost:9001
API 200 · worker healthy · web 200

Architecture

Boring where it matters.

Go services, Postgres for state and queue, object storage for artifacts, and an isolated runtime for every agent run.

JWT EdDSAArgon2idRLS per orgsqlc onlyOpenTelemetryPrometheus

Engineering status

Honest by default.

The core ASDLC is verified end-to-end, including ten concurrent PRs. Production hardening is tracked in the repository — fencing, multi-region and sync RPO are explicitly not claimed yet.

Verified
check · security · e2e · 10-PR
Database
Patroni leader + streaming replica
Backups
WAL + base · PITR · offsite restore
Next
real provider key · fencing · multi-region

FAQ

Straight answers.

Can an agent merge without a human?

No. Development produces a pull request; a separate PR approval and the merge queue gate the merge. The platform never auto-merges on its own.

Which models and providers are supported?

Anthropic and OpenAI-compatible endpoints, or your own agent through the command backend or a digest-pinned custom agent plugin. BYOK lets an organisation use its own KMS key.

Where does generated code run?

In a disposable Docker or Kubernetes sandbox: read-only root, no capabilities, no network by default, bounded CPU/memory and a tmpfs workspace. The host is never mounted into the run.

How is acceptance proven?

The task carries acceptance criteria. The development agent must emit an AIP_PROOF mapping evidence to every criterion; the platform validates the tests and files in the diff. Missing proof fails the run.

Is it production-ready today?

The core ASDLC is verified end to end. Production hardening is tracked honestly: host fencing, multi-region data planes and sync RPO are not claimed yet. See the status page.

Can I self-host it?

Yes. The local path is Docker Compose; the HA path uses Patroni, HAProxy and PgBouncer. PostgreSQL, Redis, MinIO and a sandbox runtime are the main dependencies.

Documentation

Go deeper.

A product guide for the people who use the platform, plus an API reference for the people who automate it.

User documentation

15 guides and a complete API reference.

Setup, projects, tasks, runs, approvals, security, backups and every REST endpoint — written for users, generated from the source of truth.

Open user guide

Ready?

Put an agent to work.
Keep the final say.