OpenASE is an all-in-one platform that turns tickets into working code — AI agents automatically pick up tickets, execute workflows on your machines, and deliver results with full traceability.

The embedded web UI covers ticket orchestration, AI-assisted planning, skill authoring, and live project tracking.

Live execution
Monitor real project work as tickets move across backlog, todo, in-progress, and review.

Ticket board Manage backlog and execution flow with a kanban-style ticket view.	Project AI Break work into tickets and inspect workspace context directly beside the board.
Skill editor Edit built-in or custom skills that drive repeatable automation workflows.

OpenASE is a single Go binary that ships an API server, workflow orchestrator, and embedded web UI together. It follows a ticket-driven model: every piece of work is a ticket, every ticket has a workflow, and AI agents automatically pick up and execute tickets based on status triggers.

You create a ticket  →  Orchestrator detects pickup status
    →  Agent claims the ticket  →  Executes workflow on a Machine
    →  Activity stream records every step  →  Ticket completes

No Node.js at runtime — the SvelteKit frontend is compiled and embedded into the Go binary via go:embed.

AI coding agents are powerful — but only when humans stay in control. OpenASE is built around two complementary modes of human–agent interaction:

When requirements are clear and a Harness (a hard-boundary document that constrains agent behavior) is in place, the Ticket Agent executes the entire task autonomously. It follows the Workflow's instructions, updates ticket statuses, and completes the work — humans don't need to babysit. Two common patterns:

• Fullstack Coder — A single agent handles the entire lifecycle (Todo → In Progress → In Review → Merging → Done).
• Mixed Relay — Multiple specialized agents collaborate (Design → Backend → Frontend → Testing → In Review → Merging → Done), each responsible for one stage.

When requirements are vague or you want to explore before committing to tickets, start a conversation with Project AI — a synchronous assistant in the control plane sidebar. Each tab runs in its own isolated workspace; tabs are independent, parallel, and easy to manage. Project AI can read tickets/workflows/skills, edit harnesses and skills, operate git, and trigger agent runs. As you navigate, it switches between Workflow / Skill / Ticket / Machine focus modes automatically.

Skills are reusable instruction documents that give agents extra capabilities. Every Workflow auto-binds a built-in Ticket Skill so agents know how to drive status flow. You can bind more built-in skills, author custom ones in the Skill Editor, or import them from your repo. Bound skills are injected into the CLI agent's skill directory at runtime (.codex/skills/, .claude/skills/, .gemini/skills/).

OpenASE supports multi-Organization management out of the box. Each Org contains its own Projects, tickets, workflows, skills, machines, and providers. Cross-Org team collaboration is WIP.

To maximize unattended Workflow execution, OpenASE launches CLI agents with permissive flags by default (--dangerously-skip-permissions for Claude Code, --yolo for Codex). Agents can read, write, and execute arbitrary commands on the host without per-action confirmation. You can switch to standard interactive mode per-provider in Provider settings.

• Only run OpenASE on machines where you trust the agent's scope of access.
• This project is NOT designed for public-facing deployment — it targets local dev, private networks, and trusted environments.
• Browser access is always authorization-gated. Fresh installs use local bootstrap links; networked deployments should move to HTTPS + OIDC (see OIDC & RBAC Guide).

Both async and sync AI support multiple agent CLIs. Claude Code and Codex are recommended for production use; Gemini CLI is supported but less stable.

For fresh Linux or macOS machines:

curl -fsSL https://raw.githubusercontent.com/pacificstudio/openase/main/scripts/install.sh | sh

The installer detects OS/arch/package managers, downloads and verifies the matching GitHub release, offers PostgreSQL bootstrap, and writes a runnable ~/.openase/config.yaml and ~/.openase/.env. Docker-backed PostgreSQL is only offered when Docker is already installed and the current user can reach the Docker daemon; otherwise the installer shows the system-package path when available, plus skip.

To pin a specific version:

curl -fsSL https://raw.githubusercontent.com/pacificstudio/openase/main/scripts/install.sh | sh -s -- --version <version>

git clone https://github.com/PacificStudio/openase.git
cd openase
make build-web              # build frontend + Go binary
./bin/openase setup         # interactive first-run setup
./bin/openase all-in-one --config ~/.openase/config.yaml

On fresh cloud VMs, budget enough memory for the frontend build. In practice make build-web is much more reliable on machines with at least 8 GB RAM, or on a 4 GB droplet after adding swap first.

The control plane is then available at http://127.0.0.1:19836.

For prerequisite installs (Go, Node, PostgreSQL, agent CLIs), full setup walkthrough, run modes (managed user service, split-process, env-only), and validation steps, see the Source Build & Startup Guide.

Follow the User Guide — Quick Start (EN | 中文) to configure ticket statuses, register a machine and agent, create your first workflow, and watch the agent execute.

flowchart LR
    U[User / Scheduled Job] --> T[Ticket]
    T --> O[Orchestrator]
    O -->|status trigger| A[Agent]
    A --> W[Workflow + Harness]
    W --> S[Skills]
    A -->|executes on| M[Machine]
    M --> R[Results]
    R --> E[Activity Stream]
    E --> UI[Web Control Plane]

For repository layout, build commands, and quality gates, see the Development Guide.

See LICENSE.

linux.do

OpenASE
Create the ticket. The agent does the rest.