enact

内容来源：README.md（说明文档） · 原始地址 · 查看安装指南

原始内容

# Enact

**Runtime and Registry for Agent Skills**

[![Discord](https://img.shields.io/discord/1312642330502627348?color=5865F2&logo=discord&logoColor=white&label=Discord)](https://discord.com/invite/mMfxvMtHyS)

Discover, verify, and execute capabilities on demand.

Enact packages tools as portable skill bundles and runs them securely — locally, in containers, or remotely — with policy enforcement and cryptographic verification. Skills can be chained into workflows that mix deterministic execution with model reasoning.

**[Browse Skills](https://enact.tools)** · **[Get Started](https://github.com/EnactProtocol/enact/blob/HEAD/GETTING-STARTED.md)**

---

## Built for Autonomous Agents

Agents shouldn't ship with every tool preinstalled. They should acquire capabilities when needed.

**Discover by capability** — Search the registry for skills that solve the task:

```bash
enact search "resize images"
```

**Run instantly** — Execute without manual setup or environment wiring:

```bash
enact run alice/resizer --width 800
```

**Chain into workflows** — Combine skills and model reasoning into repeatable pipelines:

```bash
enact workflow run research-pipeline.yaml --input url=https://example.com
```

**Know what's available** — Agents and developers can inspect installed capabilities:

```bash
enact list
```

---

## A Runtime — Not Just a Registry

Traditional package managers deliver code to developers. Enact delivers capabilities to autonomous systems with guarantees.

| Without Enact | With Enact |
|---|---|
| Manual integration | Drop-in execution |
| Implicit trust | Verified signatures |
| Environment drift | Reproducible runtime |
| Secrets in code | Secure injection |
| Static installs | On-demand capabilities |

> npx launches code. A runtime governs execution.

---

## Policy-Enforced Execution

The model decides what to run. Enact decides **whether and how** it runs.

```
Model (Claude, GPT, etc.)
    ↓
Host (Claude Code, Cursor, VS Code, etc.)
    ↓
Tool Call (MCP or CLI)
    ↓
Enact Runtime
    ├── Signature verification (Sigstore)
    ├── Trust policy enforcement
    ├── Backend selection (local / docker / remote)
    ├── Secret injection
    └── Isolated execution
```

Before execution, Enact:

- **Verifies signatures** via [Sigstore](https://www.sigstore.dev/)
- **Applies trust policies** per your configuration
- **Selects an execution backend** based on policy and environment
- **Injects secrets securely** without exposing them to the agent
- **Runs in isolation** when needed

---

## Workflows

Chain skills and model steps into repeatable pipelines using GitHub Actions-style YAML.

```yaml
name: Research and Report
on:
  manual:
    inputs:
      url:
        description: URL to research
        required: true

jobs:
  pipeline:
    steps:
      - id: scrape
        name: Scrape page
        uses: enact/web-scrape:scrape
        with:
          url: ${{ inputs.url }}

      - id: analyze
        name: Analyze content
        model: agent
        prompt: |
          Extract the key themes and action items from this content:
          ${{ steps.scrape.outputs.text }}
        needs: [scrape]

      - id: report
        name: Format report
        uses: enact/report:generate
        with:
          content: ${{ steps.analyze.outputs.response }}
        needs: [analyze]
```

```bash
enact workflow run research.yaml --input url=https://example.com
enact workflow run research.yaml --dry-run   # preview without executing
enact workflow run research.yaml --json       # machine-readable output
```

### Two step types

**Skill steps** run deterministically in a container:

```yaml
- id: count
  uses: demo/word-counter:count
  with:
    text: ${{ inputs.text }}
```

**Model steps** delegate reasoning to a model:

```yaml
- id: summarize
  model: agent                    # delegate to the running agent
  prompt: Summarize: ${{ steps.count.outputs.text }}

- id: deep-research
  model: claude-opus-4-6          # or call a specific model directly
  prompt: Research this topic in depth...
  tools:
    - enact/search:query          # skills the model can call during this step
```

`model: agent` means "whoever is running this workflow handles this step" — no extra API call when Claude is already orchestrating. `model: claude-*` makes a direct API call with the specified model.

### Expressions

Steps reference inputs and prior step outputs using `${{ }}` expressions:

```yaml
text: ${{ inputs.query }}
content: ${{ steps.fetch.outputs.text }}
token: ${{ secrets.API_TOKEN }}
```

### Visual Editor

Build workflows visually with the Workflow Studio:

```bash
cd packages/workflow-ui && bun run dev
# Opens at http://localhost:3001
```

Drag skill and model nodes onto the canvas, connect them, configure inputs — the YAML is generated live.

---

## Run Anywhere

Skills are portable across environments. Write once, run anywhere.

| Backend | When to use |
|---------|-------------|
| **Local** | Fast, trusted workflows |
| **Docker** | Isolation for untrusted code, reproducible environments |
| **Remote** | No local runtime required |

Enact automatically chooses the safest available option based on policy and environment.

```yaml
# ~/.enact/config.yaml
execution:
  default: docker
  fallback: remote
  trusted_scopes: ["my-org/*"]
```

---

## Simple Skill Packages

A skill is just agent-facing documentation, a runtime manifest, and implementation code. No special framework required.

```
my-skill/
├── SKILL.md              # Agent-facing documentation
├── skill.package.yaml    # Runtime manifest
└── code/
```

**skill.package.yaml** defines identity, execution, and secrets:

```yaml
name: acme/scraper
version: "1.0.0"
description: Scrape URLs and convert web pages to clean markdown
from: python:3.12-slim

build: "pip install -r requirements.txt"

env:
  API_KEY:
    secret: true

scripts:
  default: "python /workspace/scrape.py"   # invoked by: enact run acme/scraper
  scrape: "python /workspace/scrape.py"    # invoked by: enact run acme/scraper:scrape
```

The `build` field installs dependencies before execution (run once, cached). Scripts define executable commands. A script named `default` is invoked automatically when no script is specified — so `enact run acme/scraper` works without a `:script` suffix.

**Arguments are passed directly to the script:**
```bash
enact run acme/scraper --url "https://example.com" --format markdown
# explicit script name also works:
enact run acme/scraper:scrape --url "https://example.com"
# for complex types (arrays, objects), use JSON:
enact run acme/scraper -a '{"items":["a","b"],"count":5}'
```

Unknown flags are passed straight through to your script, which handles its own parsing (argparse, commander, clap, etc).

**SKILL.md** teaches the agent how to use the skill — plain markdown, no special syntax.

Package anything from a small script to a full application.

---

## Built-In Trust

Every published skill is cryptographically signed and transparently verified.

- **Publisher identity validation** — who signed this package
- **Tamper detection** — the package hasn't been modified since publishing
- **Transparency logs** — signatures are logged to a public ledger
- **Configurable trust policies** — enforce, warn, or skip per your needs

```yaml
# ~/.enact/config.yaml
trust:
  policy: enforce
  auditors: ["my-org"]
```

Use public registries, private registries, or fully self-hosted deployments.

---

## Secrets

Skills declare what they need in the manifest — secrets are injected at runtime without being exposed in logs, manifests, or to the agent.

```yaml
# skill.package.yml
env:
  FIRECRAWL_API_KEY:
    secret: true
```

```bash
enact env set FIRECRAWL_API_KEY fc-your-key --secret --namespace enact
```

The skill sees a normal environment variable. The agent never sees the value.

---

## Native Agent Integration

Enact integrates with the [Model Context Protocol](https://modelcontextprotocol.io/), allowing AI clients to discover and execute skills dynamically through a standardized interface. No preconfiguration required.

**Setup for Claude Code:**

```bash
claude mcp add enact -- npx -y @enactprotocol/mcp-server
```

Run `enact mcp install` for setup instructions for Claude Desktop, Cursor, VS Code, and other clients.

Agents can:

- **Search** for capabilities
- **Read** documentation
- **Execute** tools
- **Install** frequently used skills

| Tool | Description |
|------|-------------|
| `enact_search` | Find skills by keyword or capability |
| `enact_learn` | Read a skill's documentation and usage |
| `enact_run` | Execute a skill from the registry |
| `enact_install` | Cache a skill locally for faster runs |

**Example:**

```
User: "Scrape the Anthropic homepage and summarize it"

Agent searches → finds enact/firecrawl
Agent learns  → reads docs, sees it needs FIRECRAWL_API_KEY
Agent runs    → enact/firecrawl with url: "https://anthropic.com"
Agent summarizes the returned markdown
```

---

## CLI

Manage skills from the terminal.

```bash
enact search "pdf parser"      # Find skills
enact learn alice/parser       # Read docs
enact run alice/parser         # Execute (uses 'default' script)
enact run alice/parser:parse   # Execute a specific script
enact install alice/parser     # Install to .agents/skills/ (project) or ~/.agents/skills/ (--global)
enact publish                  # Share your skill
```

### Workflows

```bash
enact workflow run pipeline.yaml                        # Run a workflow
enact workflow run pipeline.yaml --input key=value      # Pass inputs
enact workflow run pipeline.yaml --dry-run              # Preview steps
enact workflow run pipeline.yaml --verbose              # Step-by-step output
enact workflow run pipeline.yaml --json                 # JSON result
```

### Create a Skill

```bash
enact init          # Scaffold a new skill (creates skill.package.yaml + hello.py)
enact run ./        # Test locally
enact login         # Authenticate
enact publish       # Publish to registry
```

---

## Self-Host or Use the Public Registry

Run your own registry with a single command, or use the public ecosystem.

```bash
enact serve --port 8080 --data ./registry-data
```

```bash
enact config set registry http://localhost:8080
```

- No external dependencies — SQLite + local file storage
- Local or private deployments
- Mirror or curate skills
- Full control over trust policies

A public registry is available at **[enact.tools](https://enact.tools)**.

---

## Why Enact

| | |
|---|---|
| **Portable** | Skills run across environments without modification |
| **Secure by default** | Verification and policy enforcement before execution |
| **Agent-native** | Designed for dynamic capability discovery |
| **Composable** | Chain skills and model reasoning into workflows |
| **Flexible** | Works locally, in containers, or remotely |
| **Open** | Self-host, extend, or integrate into your stack |

---

## Get Started

Install the CLI and run your first skill in seconds.

```bash
npm install -g @enactprotocol/cli
enact search scraper
enact run enact/firecrawl --url "https://example.com"
```

**[Read the Docs](https://github.com/EnactProtocol/enact/blob/HEAD/GETTING-STARTED.md)** · **[Browse Skills](https://enact.tools)**

---

## Addressing

Packages are `scope/name`. Scripts within a package are `scope/name:script`.

A script named `default` is invoked automatically — `enact run scope/name` is equivalent to `enact run scope/name:default`.

Installed skills live in `.agents/skills/` (project-local) or `~/.agents/skills/` (global). The `.agents/skills.json` file tracks project dependencies.

## Documentation

- **[Getting Started](https://github.com/EnactProtocol/enact/blob/HEAD/GETTING-STARTED.md)** — Installation and first skill
- **[Protocol Spec](https://github.com/EnactProtocol/enact/blob/HEAD/docs/SPEC.md)** — The `skill.package.yml` format and execution semantics
- **[API Reference](https://github.com/EnactProtocol/enact/blob/HEAD/docs/API.md)** — Registry API
- **[Trust & Signing](https://github.com/EnactProtocol/enact/blob/HEAD/docs/TRUST.md)** — Sigstore-based verification
- **[Dev Setup](https://github.com/EnactProtocol/enact/blob/HEAD/DEV-SETUP.md)** — Contributing to Enact

## Architecture

```
packages/
├── api           # Registry API client
├── cli           # Command-line interface
├── execution     # Pluggable execution backends (local, docker, dagger, remote)
├── mcp-server    # MCP server for AI agents
├── registry      # Self-hosted registry backend (SQLite)
├── secrets       # Secure credential storage
├── shared        # Core types, manifest parsing, config
├── trust         # Sigstore signing and verification
├── web           # Web UI (enact.tools)
├── workflow      # Workflow runner (skill + model steps, DAG execution)
└── workflow-ui   # Visual workflow editor (Workflow Studio)
```

## Contributing

1. Fork the repository
2. Create a feature branch
3. Run `bun run lint` and `bun test`
4. Submit a pull request

See [DEV-SETUP.md](https://github.com/EnactProtocol/enact/blob/HEAD/DEV-SETUP.md) for full instructions.

## License

Apache-2.0 — see [LICENSE](https://github.com/EnactProtocol/enact/tree/HEAD/LICENSE).

## Community

- **Registry:** [enact.tools](https://enact.tools)
- **Discord:** [discord.gg/mMfxvMtHyS](https://discord.gg/mMfxvMtHyS)
- **Issues:** [GitHub](https://github.com/EnactProtocol/enact/issues)

Enact

Runtime and Registry for Agent Skills

Discover, verify, and execute capabilities on demand.

Enact packages tools as portable skill bundles and runs them securely — locally, in containers, or remotely — with policy enforcement and cryptographic verification. Skills can be chained into workflows that mix deterministic execution with model reasoning.

Browse Skills · Get Started

Built for Autonomous Agents

Agents shouldn't ship with every tool preinstalled. They should acquire capabilities when needed.

Discover by capability — Search the registry for skills that solve the task:

enact search "resize images"

Run instantly — Execute without manual setup or environment wiring:

enact run alice/resizer --width 800

Chain into workflows — Combine skills and model reasoning into repeatable pipelines:

enact workflow run research-pipeline.yaml --input url=https://example.com

Know what's available — Agents and developers can inspect installed capabilities:

enact list

A Runtime — Not Just a Registry

Traditional package managers deliver code to developers. Enact delivers capabilities to autonomous systems with guarantees.

Without Enact	With Enact
Manual integration	Drop-in execution
Implicit trust	Verified signatures
Environment drift	Reproducible runtime
Secrets in code	Secure injection
Static installs	On-demand capabilities

npx launches code. A runtime governs execution.

Policy-Enforced Execution

The model decides what to run. Enact decides whether and how it runs.

Model (Claude, GPT, etc.)
    ↓
Host (Claude Code, Cursor, VS Code, etc.)
    ↓
Tool Call (MCP or CLI)
    ↓
Enact Runtime
    ├── Signature verification (Sigstore)
    ├── Trust policy enforcement
    ├── Backend selection (local / docker / remote)
    ├── Secret injection
    └── Isolated execution

Before execution, Enact:

Verifies signatures via Sigstore
Applies trust policies per your configuration
Selects an execution backend based on policy and environment
Injects secrets securely without exposing them to the agent
Runs in isolation when needed

Workflows

Chain skills and model steps into repeatable pipelines using GitHub Actions-style YAML.

name: Research and Report
on:
  manual:
    inputs:
      url:
        description: URL to research
        required: true

jobs:
  pipeline:
    steps:
      - id: scrape
        name: Scrape page
        uses: enact/web-scrape:scrape
        with:
          url: ${{ inputs.url }}

      - id: analyze
        name: Analyze content
        model: agent
        prompt: |
          Extract the key themes and action items from this content:
          ${{ steps.scrape.outputs.text }}
        needs: [scrape]

      - id: report
        name: Format report
        uses: enact/report:generate
        with:
          content: ${{ steps.analyze.outputs.response }}
        needs: [analyze]

enact workflow run research.yaml --input url=https://example.com
enact workflow run research.yaml --dry-run   # preview without executing
enact workflow run research.yaml --json       # machine-readable output

Two step types

Skill steps run deterministically in a container:

- id: count
  uses: demo/word-counter:count
  with:
    text: ${{ inputs.text }}

Model steps delegate reasoning to a model:

- id: summarize
  model: agent                    # delegate to the running agent
  prompt: Summarize: ${{ steps.count.outputs.text }}

- id: deep-research
  model: claude-opus-4-6          # or call a specific model directly
  prompt: Research this topic in depth...
  tools:
    - enact/search:query          # skills the model can call during this step

model: agent means "whoever is running this workflow handles this step" — no extra API call when Claude is already orchestrating. model: claude-* makes a direct API call with the specified model.

Expressions

Steps reference inputs and prior step outputs using ${{ }} expressions:

text: ${{ inputs.query }}
content: ${{ steps.fetch.outputs.text }}
token: ${{ secrets.API_TOKEN }}

Visual Editor

Build workflows visually with the Workflow Studio:

cd packages/workflow-ui && bun run dev
# Opens at http://localhost:3001

Drag skill and model nodes onto the canvas, connect them, configure inputs — the YAML is generated live.

Run Anywhere

Skills are portable across environments. Write once, run anywhere.

Backend	When to use
Local	Fast, trusted workflows
Docker	Isolation for untrusted code, reproducible environments
Remote	No local runtime required

Enact automatically chooses the safest available option based on policy and environment.

# ~/.enact/config.yaml
execution:
  default: docker
  fallback: remote
  trusted_scopes: ["my-org/*"]

Simple Skill Packages

A skill is just agent-facing documentation, a runtime manifest, and implementation code. No special framework required.

my-skill/
├── SKILL.md              # Agent-facing documentation
├── skill.package.yaml    # Runtime manifest
└── code/

skill.package.yaml defines identity, execution, and secrets:

name: acme/scraper
version: "1.0.0"
description: Scrape URLs and convert web pages to clean markdown
from: python:3.12-slim

build: "pip install -r requirements.txt"

env:
  API_KEY:
    secret: true

scripts:
  default: "python /workspace/scrape.py"   # invoked by: enact run acme/scraper
  scrape: "python /workspace/scrape.py"    # invoked by: enact run acme/scraper:scrape

The build field installs dependencies before execution (run once, cached). Scripts define executable commands. A script named default is invoked automatically when no script is specified — so enact run acme/scraper works without a :script suffix.

Arguments are passed directly to the script:

enact run acme/scraper --url "https://example.com" --format markdown
# explicit script name also works:
enact run acme/scraper:scrape --url "https://example.com"
# for complex types (arrays, objects), use JSON:
enact run acme/scraper -a '{"items":["a","b"],"count":5}'

Unknown flags are passed straight through to your script, which handles its own parsing (argparse, commander, clap, etc).

SKILL.md teaches the agent how to use the skill — plain markdown, no special syntax.

Package anything from a small script to a full application.

Built-In Trust

Every published skill is cryptographically signed and transparently verified.

Publisher identity validation — who signed this package
Tamper detection — the package hasn't been modified since publishing
Transparency logs — signatures are logged to a public ledger
Configurable trust policies — enforce, warn, or skip per your needs

# ~/.enact/config.yaml
trust:
  policy: enforce
  auditors: ["my-org"]

Use public registries, private registries, or fully self-hosted deployments.

Secrets

Skills declare what they need in the manifest — secrets are injected at runtime without being exposed in logs, manifests, or to the agent.

# skill.package.yml
env:
  FIRECRAWL_API_KEY:
    secret: true

enact env set FIRECRAWL_API_KEY fc-your-key --secret --namespace enact

The skill sees a normal environment variable. The agent never sees the value.

Native Agent Integration

Enact integrates with the Model Context Protocol, allowing AI clients to discover and execute skills dynamically through a standardized interface. No preconfiguration required.

Setup for Claude Code:

claude mcp add enact -- npx -y @enactprotocol/mcp-server

Run enact mcp install for setup instructions for Claude Desktop, Cursor, VS Code, and other clients.

Agents can:

Search for capabilities
Read documentation
Execute tools
Install frequently used skills

Tool	Description
`enact_search`	Find skills by keyword or capability
`enact_learn`	Read a skill's documentation and usage
`enact_run`	Execute a skill from the registry
`enact_install`	Cache a skill locally for faster runs

Example:

User: "Scrape the Anthropic homepage and summarize it"

Agent searches → finds enact/firecrawl
Agent learns  → reads docs, sees it needs FIRECRAWL_API_KEY
Agent runs    → enact/firecrawl with url: "https://anthropic.com"
Agent summarizes the returned markdown

CLI

Manage skills from the terminal.

enact search "pdf parser"      # Find skills
enact learn alice/parser       # Read docs
enact run alice/parser         # Execute (uses 'default' script)
enact run alice/parser:parse   # Execute a specific script
enact install alice/parser     # Install to .agents/skills/ (project) or ~/.agents/skills/ (--global)
enact publish                  # Share your skill

Workflows

enact workflow run pipeline.yaml                        # Run a workflow
enact workflow run pipeline.yaml --input key=value      # Pass inputs
enact workflow run pipeline.yaml --dry-run              # Preview steps
enact workflow run pipeline.yaml --verbose              # Step-by-step output
enact workflow run pipeline.yaml --json                 # JSON result

Create a Skill

enact init          # Scaffold a new skill (creates skill.package.yaml + hello.py)
enact run ./        # Test locally
enact login         # Authenticate
enact publish       # Publish to registry

Self-Host or Use the Public Registry

Run your own registry with a single command, or use the public ecosystem.

enact serve --port 8080 --data ./registry-data

enact config set registry http://localhost:8080

No external dependencies — SQLite + local file storage
Local or private deployments
Mirror or curate skills
Full control over trust policies

A public registry is available at enact.tools.

Why Enact


Portable	Skills run across environments without modification
Secure by default	Verification and policy enforcement before execution
Agent-native	Designed for dynamic capability discovery
Composable	Chain skills and model reasoning into workflows
Flexible	Works locally, in containers, or remotely
Open	Self-host, extend, or integrate into your stack

Get Started

Install the CLI and run your first skill in seconds.

npm install -g @enactprotocol/cli
enact search scraper
enact run enact/firecrawl --url "https://example.com"

Read the Docs · Browse Skills

Addressing

Packages are scope/name. Scripts within a package are scope/name:script.

A script named default is invoked automatically — enact run scope/name is equivalent to enact run scope/name:default.

Installed skills live in .agents/skills/ (project-local) or ~/.agents/skills/ (global). The .agents/skills.json file tracks project dependencies.

Documentation

Getting Started — Installation and first skill
Protocol Spec — The skill.package.yml format and execution semantics
API Reference — Registry API
Trust & Signing — Sigstore-based verification
Dev Setup — Contributing to Enact

Architecture

packages/
├── api           # Registry API client
├── cli           # Command-line interface
├── execution     # Pluggable execution backends (local, docker, dagger, remote)
├── mcp-server    # MCP server for AI agents
├── registry      # Self-hosted registry backend (SQLite)
├── secrets       # Secure credential storage
├── shared        # Core types, manifest parsing, config
├── trust         # Sigstore signing and verification
├── web           # Web UI (enact.tools)
├── workflow      # Workflow runner (skill + model steps, DAG execution)
└── workflow-ui   # Visual workflow editor (Workflow Studio)

Contributing

Fork the repository
Create a feature branch
Run bun run lint and bun test
Submit a pull request

See DEV-SETUP.md for full instructions.

License

Apache-2.0 — see LICENSE.

Community

Registry: enact.tools
Discord: discord.gg/mMfxvMtHyS
Issues: GitHub