ALPS — Agent Lifecycle Process Skills

What is ALPS?

ALPS is a common language for describing reusable Agent Skills.

In ALPS:

• a Process is the work being performed;
• a Process Description explains that work; and
• an Agent Skill is treated as a Process Description.

A useful description lets a reader understand why the work exists, what success means, what work belongs to it, what enters and leaves it, and what conditions apply. It does not require one particular performer or implementation method.

ALPS also provides a three-Skill Reference Model for defining, applying, and managing Agent Skills.

Using ALPS

Install the plugin

ALPS is distributed as an Agent Plugins v1 package. With Node.js 18 or later available, install it through the plugins CLI:

npx plugins add mashimashica/alps

The installer discovers the package, detects supported agent clients, and asks for confirmation before installation. Restart the affected clients after installation so they reload the Skills.

Choose a reference Skill

Invoke a reference Skill explicitly

Clients may select a Skill from its discovery description. When a particular ALPS Process is intended, name the Skill identifier directly in the request. This natural-language form does not depend on client-specific slash-command syntax.

Use `define-alps` to design and verify an ALPS-conformant Skill for this recurring incident-review workflow.

Use `apply-alps` to select and compose the Skills for this request, with every Output/Input handoff made explicit.

Use `manage-alps` to assess this Skill from its execution records and propose controlled improvements.

Add repository guidance

For a repository that uses ALPS regularly, add a short policy to AGENTS.md so later agent sessions apply the same selection and composition rules. The block below is the canonical minimal policy for a consumer repository. ALPS's own AGENTS.md applies the same core policy and adds repository-maintenance instructions.

## ALPS

This repository uses the ALPS Reference Model.

- For each substantive request, use the ALPS Reference Model to select the applicable reference Skills from `define-alps`, `apply-alps`, and `manage-alps`.
- Identify other ALPS-conformant Skills by the `ALPS-conformant.` marker at the end of `description`, then assess their fit from the discovery description.
- Read each selected Skill's complete `SKILL.md` before applying it.
- Use `apply-alps` for existing Skills, `define-alps` for an unmet need or Skill redefinition, and `manage-alps` for adoption, Tailoring, assessment, change, or retirement.
- When combining Skills, make every Output/Input handoff explicit.

ALPS Reference Model

ALPS defines the Skill life cycle through three Processes. They are not fixed phases and may be applied concurrently, iteratively, or recursively as needed. The arrows show representative Output/Input handoffs.

This repository contains the ALPS specification and three Agent Skills that implement these Processes. English is authoritative, with Japanese localizations bundled in each Skill.

flowchart LR
    DEFINE["Definition Process<br/>Defines and verifies Skills"]
    MANAGE["Management Process<br/>Governs and improves Skill assets"]
    APPLY["Application Process<br/>Selects, executes, and composes Skills"]

    DEFINE -->|"Verified Skill Description"| MANAGE
    MANAGE -->|"Managed Skills and application conditions"| APPLY
    APPLY -->|"Execution records, lessons, and measurements"| MANAGE
    MANAGE -->|"Change or reverification request"| DEFINE

Beyond this Reference Model, ALPS specifies rules for Skill Descriptions, Skill Packages, composition and handoffs across multiple Skills, Controls, Constraints, Enablers, Entry/Exit Criteria, Decision Gates, Tailoring, and Conformance.

Reading a Skill

ALPS separates questions that are often mixed together in ordinary descriptions.

Example: turning meeting notes into a usable summary

Suppose an Agent Skill processes meeting notes.

• Purpose — make the discussion usable after the meeting.
• Outcome — decisions, action items, and unresolved questions are identified.
• Input — meeting notes, a transcript, or supplied materials.
• Output — a structured meeting summary.
• Activities and Tasks — identify relevant statements, classify them, and preserve links to the source.
• Controls and Constraints — applicable privacy rules, required formats, and declared limits.
• Enablers — language capabilities, tools, and the execution environment.

The Output is the summary that is produced. The Outcome is the condition used to judge whether the Process succeeded. They are related, but they are not the same.

The Skill does not require the work to be performed by one particular person, Agent, or tool, and it does not prescribe one implementation method.

Process Framework

The Process Framework formalizes these distinctions and gives ALPS a reusable vocabulary for intent, work content, transformation, application context, Process relationships, Tailoring, and Assessment.

flowchart TD
    WHY["Why?<br/>Purpose"] --> PROCESS["Process<br/>the work being performed"]

    INPUT["What is transformed?<br/>Input"] --> PROCESS
    PROCESS --> OUTPUT["What is produced?<br/>Output"]
    PROCESS --> OUTCOME["What counts as success?<br/>Outcome"]

    WORK["What work belongs?<br/>Activities and Tasks"] --> PROCESS
    CONDITIONS["What directs, limits, or supports it?<br/>Controls, Constraints, Enablers"] --> PROCESS
    TIMING["When?<br/>Entry and Exit Criteria"] --> PROCESS

    OPEN["Who and how?<br/>Chosen for the application"] -.-> PROCESS

Name, Purpose, and Outcomes are required in a Process Description. Activities and Tasks describe work content; they are not implementation methods or procedural steps merely because they appear in an order. Inputs are items transformed into Outputs. People, Agents, tools, and execution environments are resources or Enablers rather than Inputs.

ALPS applies this Framework to Skill description, life cycle management, Tailoring, Assessment, and Conformance. The Framework does not prescribe a life cycle, a sequence of phases, or one implementation method.

Repository Contents

Versioning

ALPS is versioned as a single repository-wide release unit. The current version is 0.3.0, and it remains in initial development. The exact contents of a release are identified by its Git tag and commit. See CHANGELOG.md for release history and Versioning for compatibility and release rules.

License and Reuse

Except for identified third-party material, the repository is licensed under the Apache License, Version 2.0. The license covers the specification, documentation, Skill Packages, scripts, and the project-created icon. See NOTICE for attribution and material excluded from the repository license.

Contributing

Contributions are accepted under the repository license and the Developer Certificate of Origin 1.1. Every contributed commit requires a Signed-off-by trailer. See CONTRIBUTING.md before submitting a change.