OpenASE — Summary

OpenASE (Open Auto Software Engineering) is a single Go binary that ships an API server, workflow orchestrator, and embedded SvelteKit web UI together — a complete ticket-driven platform where AI agents automatically pick up tickets, execute workflows on registered machines, and deliver results with full traceability. The central abstraction is a Harness: a hard-boundary document in the Workflow that constrains agent behavior and defines what "done" means. Lifecycle Hooks at each ticket state transition enforce quality gates (lint, tests, security scans). The platform supports multiple CLI agents via an adapter layer (Claude Code, OpenAI Codex, Gemini CLI), bound to Workflows through Providers and Agents configurations. Skills are reusable instruction documents injected into the agent's skill directories (.codex/skills/, .claude/skills/, .gemini/skills/) at runtime. The web UI covers tickets (kanban), agent monitoring, machine registration, workflow/harness editing, skill authoring, scheduled jobs, and a metrics dashboard — all accessed at localhost:2080 from a Docker Compose or single binary install.

OpenASE is the most architecturally complete ticket-to-code platform in this batch and in the corpus. It is closest to taskmaster-ai among the seeds (ticket-driven task management for agents), but operates at the infrastructure level: where taskmaster-ai is an npm tool that manages a tasks.json, OpenASE is an application server with a database, multi-machine orchestration, lifecycle hooks, and version-controlled workflow harnesses.

OpenASE — Overview

Origin

Created by Pacific Studio (GitHub: pacificstudio/openase). Written in Go 1.26+. 243 stars. Active (last push 2026-05-25). Apache 2.0 license. Available in English and Chinese (README.zh.md). Accompanied by a detailed PRD in SPEC.md (the founding design document).

Philosophy

From SPEC.md:

"OpenASE is not about 'making agents write better code,' but about 'enabling a team of agents to reliably deliver software.'"

Five core design principles:

1. Tickets are everything — tickets are the atomic unit of work and the only collaboration interface between agents and humans
2. Workflows define how work is done — each ticket type binds to a Workflow with a Harness (behavioral boundaries document)
3. Behavior is a managed asset — Workflow Harnesses and Skills are stored in the OpenASE control plane, version-controlled and auditable
4. Trust, but verify — lifecycle Hooks enforce quality checks at each state transition; Hook failures block status progression
5. Progressive automation — start with manual assignment, gradually introduce AI-based auto-assignment and auto-approval

Two AI Interaction Modes

Asynchronous AI (Ticket Agents): Requirements are clear, Harness is in place → agent executes the full ticket lifecycle autonomously.

• Fullstack Coder: one agent does everything (Todo → In Progress → In Review → Merging → Done)
• Mixed Relay: multiple specialized agents collaborate (Design → Backend → Frontend → Testing → In Review → Merging → Done)

Synchronous AI (Project AI): Requirements are vague → interactive sidebar conversation with context-aware assistant.

Security Notice

OpenASE launches CLI agents with permissive flags by default (--dangerously-skip-permissions for Claude Code, --yolo for Codex). Designed for local dev, private networks, trusted environments only — not for public-facing deployment.

OpenASE — Architecture

Distribution

• Single Go binary (frontend embedded via go:embed)
• Docker Compose
• Pre-built releases on GitHub

Required Runtime

• Go 1.26+ (for building)
• PostgreSQL (database)
• No Node.js at runtime (SvelteKit compiled and embedded)

Tech Stack

Repository Structure

openase/
├── cmd/openase/            # Go binary entry point
├── internal/               # Core Go packages
│   ├── orchestrator/       # Workflow orchestration engine
│   ├── ticket/             # Ticket management
│   ├── workflow/           # Workflow + Harness definitions
│   ├── agentplatform/      # Agent adapter layer
│   ├── provider/           # Provider configurations
│   ├── runtime/            # Agent runtime management
│   ├── scheduledjob/       # Cron-based ticket creation
│   ├── httpapi/            # REST + WebSocket API
│   ├── webui/              # Embedded SvelteKit UI
│   ├── machinechannel/     # Machine communication
│   └── ... (many more)
├── .codex/skills/          # Codex skills (commit, deploy, land, etc.)
├── web/                    # SvelteKit frontend source
├── SPEC.md                 # Full PRD (Product Requirements Document)
├── AGENTS.md               # Agent usage guide
├── atlas.hcl               # Database schema
└── docker-compose.yml

Target AI Tools

• Claude Code (--dangerously-skip-permissions)
• OpenAI Codex (--yolo)
• Gemini CLI
• Extensible adapter layer for future agents

Web Access

Default port: 2080 (from SPEC.md port configuration). Browser-based control plane.

OpenASE — Components

Core Concepts

Built-in Codex Skills (from .codex/skills/)

Web UI Modules (Control Plane)

Two Execution Patterns

OpenASE — Uniqueness

Differs from Seeds

OpenASE is the most architecturally complete AI agent orchestration platform in the corpus. Taskmaster-ai is the closest seed (ticket-driven task management for agents), but OpenASE operates at a fundamentally different level: taskmaster-ai stores tasks in a tasks.json file and exposes them via an MCP server; OpenASE is a full application server with PostgreSQL, multi-machine orchestration, versioned Workflow Harnesses, lifecycle Hooks that block status transitions, and a SvelteKit dashboard embedded in a single Go binary. The Harness concept — a hard-boundary behavioral document versioned in the platform's database and materialized into the agent's workspace at startup — is unique in the corpus and solves a problem no seed addresses: behavioral drift, where an agent's CLAUDE.md evolves differently from what was intended when a ticket was created. The Mixed Relay pattern (multiple specialized agents progressing through design → backend → frontend → testing stages of one ticket) is more structured than any multi-agent pattern in the seeds. The runtime skill injection mechanism (skills materialized from database to agent directory at ticket start, cleaned up after) is also unique.

Positioning

OpenASE is the "Software Engineering OS for the AI era" (per SPEC.md vision). It treats the agent team as a managed workforce with job descriptions (Workflows/Harnesses), capability upgrades (Skills), job postings (Tickets), hiring platforms (Machines), and performance reviews (Lifecycle Hooks). This management layer metaphor is more complete than any other framework in the corpus.

Observable Failure Modes

1. Security model: Default permissive flags (--dangerously-skip-permissions, --yolo) are appropriate for trusted environments but dangerous otherwise. Deployment in shared environments requires explicit configuration.
2. PostgreSQL dependency: Requires a Postgres server — cannot run with just a single binary (contrary to the "single binary" marketing claim, which refers to the Go binary itself, not its dependencies).
3. Adapter coverage: Only Claude Code, Codex, and Gemini CLI are supported. New agent types require new adapters.
4. Complexity overhead: For small teams or solo developers, the setup overhead (Postgres, Docker, OIDC) may exceed the value compared to simpler tools.