# The Autonomous Lifecycle Protocol

> Source: <https://autonomous-lifecycle-protocol-alp.github.io/Autonomous-Lifecycle-Protocol-ALP/>
> Published: 2026-10-27 06:01:38+00:00

## Execution Engine (alp run)

Topologically sorts your dependency graph in < 2ms, compiles precise context bundles, and orchestrates agents through the full lifecycle.

The open standard & high-performance execution engine for AI-driven software engineering. Write a machine-readable spec — let your agents plan, build, verify, and remember.

**Git** standardized version control. **Docker** standardized environments. **OpenAPI** standardized APIs. **ALP** standardizes how AI builds software.

Today every AI coding assistant (Devin, Claude Code, Cursor, OpenHands) relies on unstructured prompts and brittle context-scraping. They forget decisions, overwrite each other's work, and lose track of dependencies. ALP replaces scattered `README.md`, `PRD.md`, `AGENTS.md`, and `TASKS.md` files with **one deterministic protocol stored natively in your repository** (`.alp/`).

ALP turns your repository into a **deterministic, machine-readable project specification** that any AI agent can read, understand, and act on.

``` php
flowchart LR
    ALP[.alp/ Files] --> Parser[ALP Parser]
    Parser --> Graph[Dependency Graph]
    Graph --> Engine[Execution Engine]
    Engine --> Agent[AI Agent]
    Agent --> Task[Task Execution]
    Task --> Verify[Quality Gates]
    Verify --> State[Project State]
```

`.alp/` files using the ALP protocol
Create a `.alp` file in your repository:

```
!alp-version: 80.0.0

@project
  id: my-project
  name: My Project
  version: 1.0.0
  state: active

@feature
  id: feat-auth
  name: Authentication
  description: OAuth2 + JWT authentication flow

@task
  id: task-login-ui
  name: Build login UI
  status: [ ]
  depends_on:
    - task-setup-db
  verify:
    - npm run test:login
    - npm run lint:login

@agent
  id: agent-frontend
  name: Frontend Specialist
  capabilities: [react, typescript, tailwind]
```

Then run:

```
# Validate your workspace
alp validate

# Execute the next available task
alp run

# Verify quality gates
alp verify task-login-ui
```

ALP parses your workspace into a **Directed Acyclic Graph (DAG)**. Agents only receive the exact context they need, exactly when they need it.

```
graph TD
    subgraph Repository [Your Repository .alp/]
        D[Decision: Use PostgreSQL] --> T1[Task: Setup DB Schema]
        T1 --> T2[Task: Build REST API]
        R[Rule: No Raw SQL] --> T2
        C[Contract: @contract c-api] --> T2
    end

    subgraph ExecutionEngine [Execution Engine - alp run]
        T2 -->|Context Bundle - 1.8ms| Agent[Claude / Cursor Agent]
    end

    subgraph QualityGates [Quality Gates - alp verify]
        Agent -->|npm test| V{Tests Pass?}
        V -->|Exit 0| X[Mark x Done]
        V -->|Non-Zero| B[Mark ! Blocked]
    end
flowchart LR
    subgraph SwarmNodes [Autonomous Swarm Nodes]
        A1[Agent Alpha\nCoder] <--> EM((Event Mesh\nPub/Sub))
        A2[Agent Beta\nReviewer] <--> EM
        A3[Agent Gamma\nTester] <--> EM
    end

    subgraph Marketplace [Swarm Marketplace]
        EM <--> SWM[Skill Registry\n@swarm_marketplace]
        SWM -->|Discover & Invoke| Cost[Cost & Metering Engine]
    end
```

Terminal CLI interface: `run`, `marketplace`, `event-mesh`, `policy`, `vault`, `verify`.

Parses `.alp` files and computes Kahn topological sorts over the dependency graph in sub-2ms.

Real-time MCP integration for Claude Desktop, Cursor, and any compliant client.

Language Server with IntelliSense, go-to-definition, and rich hover metadata.

Official TypeScript and Python SDKs with complete 1:1 implementation parity.

Official Go, Rust, and Java SDKs with core parsing, graph, and workspace APIs.

Autonomous skill registry, provider discovery, invocation, and cost tracking (v38.0.0).

The unified ALP desktop IDE (Mac/Windows/Linux). Faster, more secure, and error-free vs. fragmented multi-IDE setups. Native `@autonomous-lifecycle-protocol-alp/parser`, Monaco editor, agent manager, IDE Intelligence with AI suggestions/predictions/review, and Autonomous Orchestration with self-healing DAGs.

```
npm install -g @autonomous-lifecycle-protocol-alp/cli
alp init
```

This creates a `.alp/` directory with a starter `project.alp` file.

Create `.alp/features.alp`:

```
!alp-version: 80.0.0

@feature
  id: feat-auth
  name: User Authentication
  description: OAuth2 + JWT authentication flow

@task
  id: task-login-ui
  name: Build login UI
  status: [ ]
  depends_on:
    - task-setup-db
  verify:
    - npm run test:login
    - npm run lint:login
# Validate your workspace
alp validate

# Execute the next available task
alp run

# Verify quality gates
alp verify task-login-ui
```

Released versions are tracked in the [versioning spec](https://autonomous-lifecycle-protocol-alp.github.io/Autonomous-Lifecycle-Protocol-ALP/spec/10-versioning.html). This section captures active and planned focus areas.

| Era | Versions | Focus | 
|---|---|---|
| V8 — The Cognitive Era | 12.0.0–12.x | AI-native planning & reasoning: GoalDecomposer, Planner, Reflector, memory-augmented inference | 
| V9 — The Collaborative Era | 13.0.0–13.x | Multi-agent negotiation, contracts-as-protocol, reputation & trust scoring, composable agent teams | 
| V10 — The Verifiable Era | 14.0.0–14.x | End-to-end provenance, signed execution traces, zero-knowledge policy proofs, tamper-evident audit ledger | 
| V11 — The Ambient Era | 15.0.0–15.x | Fully autonomous long-running swarms, safe self-modifying workflows, edge-native runtime, live upgrade & migration | 
| V12 — The Sentinel Era | 16.0.0–16.x | Immutable execution traces, self-healing workflows, predictive governance, swarm resilience, cost optimization | 
| V13 — The Universal Era | 17.0.0–17.x | Cross-protocol interoperability (OpenAPI, GraphQL, gRPC, AsyncAPI), universal adapters, bidirectional sync | 

**V9 — Native Desktop (v80.0.0)** — SHAM IDE cross-platform release with native ALP integration, Monaco editor, agent manager, auto-updater, and Pro/Enterprise licensing.

**V10 — The Intelligence Era (v80.0.0)** — Autonomous multi-agent orchestration with self-healing DAGs, predictive governance, edge-native execution, and AI-native lifecycle management.
