Skip to content
Back to search

skrun

Deploy any Agent Skill as an API via POST /run. The open-source multi-model alternative to Claude Managed Agents, Microsoft Foundry & Mistral/Koyeb — works with any LLM.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/skrun-dev/skrun with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/skrun-dev/skrun'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/skrun-dev--skrun/badge.svg)](/listings/skrun-dev--skrun)

HTML

<a href="/listings/skrun-dev--skrun"><img src="/api/listings/skrun-dev--skrun/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

npm install -g @skrun-dev/cli

skrun init --from-skill ./my-skill        # or: skrun init my-agent
skrun deploy -m "initial release"         # build + push + get your API URL
skrun verify dev/my-skill@1.0.0           # admin step — auto-admin in local dev
skrun run dev/my-skill -i '{"query":"analyze this"}'

That's it. Your agent is verified, callable via the CLI, and reachable as a `POST /run` HTTP endpoint:

curl -X POST http://localhost:4000/api/agents/dev/my-skill/run \
  -H "Authorization: Bearer dev-token" \
  -H "Content-Type: application/json" \
  -d '{"input": {"query": "analyze this"}}'

> `dev-token` is for local development. In production, authenticate via [GitHub OAuth or API keys](docs/api.md#authentication) — your GitHub username becomes your namespace, and `skrun verify` is governed by the operator [verification policy](docs/self-hosting.md#verification-policy) (admin-only by default; creators can self-attest under `owner`).

→ **[10-minute tutorial](docs/getting-started.md)** · **[Concepts](docs/concepts.md)** · **[API reference](docs/api.md)**

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 382 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <img src="assets/banner.svg" alt="Skrun — Deploy any Agent Skill as an API" width="600">
  3. </p>
  4. <h1 align="center">Skrun</h1>
  5. <p align="center">
  6. <b>Deploy any Agent as an API via <code>POST /run</code>.</b><br>
  7. The open, multi-model runtime for AI agents — works with any LLM, on any infrastructure.
  8. </p>
  9. <p align="center">
  10. <sub>The open-source alternative to Claude Managed Agents (CMA) and Google's
  11. Gemini Enterprise Agent Platform (GEAP) — multi-model, self-hostable, MIT.</sub>
  12. </p>
  13. <p align="center">
  14. <a href="https://github.com/skrun-dev/skrun/actions"><img alt="CI" src="https://img.shields.io/github/actions/workflow/status/skrun-dev/skrun/ci.yml?branch=main&style=for-the-badge&logo=github&label=CI"></a>
  15. <a href="https://www.npmjs.com/package/@skrun-dev/cli"><img alt="npm CLI" src="https://img.shields.io/npm/v/@skrun-dev/cli?style=for-the-badge&logo=npm&label=CLI&color=CB3837"></a>
  16. <a href="https://www.npmjs.com/package/@skrun-dev/sdk"><img alt="npm SDK" src="https://img.shields.io/npm/v/@skrun-dev/sdk?style=for-the-badge&logo=npm&label=SDK&color=CB3837"></a>
  17. <a href="https://github.com/skrun-dev/skrun/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/skrun-dev/skrun?style=for-the-badge&logo=github&color=FFD700"></a>
  18. <a href="LICENSE"><img alt="License" src="https://img.shields.io/badge/License-MIT-blue?style=for-the-badge"></a>
  19. </p>
  20. <p align="center">
  21. <img alt="Node" src="https://img.shields.io/badge/Node-%E2%89%A520-339933?style=for-the-badge&logo=node.js&logoColor=white">
  22. <img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-strict-3178C6?style=for-the-badge&logo=typescript&logoColor=white">
  23. <img alt="MCP" src="https://img.shields.io/badge/MCP-compatible-8B5CF6?style=for-the-badge">
  24. </p>
  25. <p align="center">
  26. <a href="#-why-skrun">Why</a> ·
  27. <a href="#️-use-cases">Use Cases</a> ·
  28. <a href="#-quick-start">Quick Start</a> ·
  29. <a href="#-dashboard">Dashboard</a> ·
  30. <a href="#-sdk">SDK</a> ·
  31. <a href="#-features">Features</a> ·
  32. <a href="#-documentation">Docs</a>
  33. </p>
  34. <p align="center">
  35. <img src="docs/assets/flow.gif" alt="Skrun demo: push an agent, explore the dashboard, run it in the playground" width="800">
  36. </p>
  37. <p align="center"><sub>
  38. <b>4 steps:</b> (1) <code>skrun deploy -m "initial release"</code> from your terminal →
  39. (2) the agent appears in the dashboard →
  40. (3) open the Playground, fill the input →
  41. (4) click Run, watch SSE events stream in real time, see the result.
  42. </sub></p>
  43. ---
  44. ## 🎯 Why Skrun?
  45. You shipped an AI capability. It works on your machine. But every user, every customer, every new model brings new plumbing.
  46. **Skrun is the open agent runtime.** Turn your skill — declared as `SKILL.md`, `AGENTS.md`, or your own format — into a `POST /run` endpoint. Without building your own agent loop. Without picking a vendor. Without locking your users behind a wall.
  47. **Any model. Any cloud. BYOK. MIT.** Your skill stays portable.
  48. ### What you get
  49. - ✅ Your skill stays in your repo, in the format you choose. Skrun is a deployment target — your repo stays the source of truth.
  50. - ✅ Compatible with the [Agent Skills open standard](https://agentskills.io) (`SKILL.md`) and [AGENTS.md](https://agents.md) (Linux Foundation). Your existing skill works.
  51. - ✅ Users bring their own LLM keys. You're never on the hook for their costs.
  52. - ✅ Self-host on your infrastructure (Node 22.19+, SQLite or Postgres). [Self-hosting guide](docs/self-hosting.md). Or the managed cloud: [quick start](https://skrun.sh/docs/quickstart).
  53. - ✅ MIT. Multi-model: Claude, GPT, Gemini, Mistral, Groq, Grok, Ollama.
  54. - ✅ Wrap existing scripts gradually. No big-bang rewrite required.
  55. ### Skrun vs vendor runtimes
  56. | | Skrun | CMA / GEAP / Vendor runtimes |
  57. |--|-------|-----------------|
  58. | **Models** | Claude, GPT, Gemini, Mistral, Groq, Grok + any OpenAI-compatible endpoint (DeepSeek, Kimi, Qwen, Ollama, vLLM…) | One provider only |
  59. | **Deployment** | Self-hosted (Node + SQLite/Postgres) or our cloud ([quick start](https://skrun.sh/docs/quickstart)) | Vendor cloud only |
  60. | **Format** | `SKILL.md` ([agentskills.io](https://agentskills.io), 40+ platforms), `AGENTS.md` ([Linux Foundation](https://agents.md)), or your own | Proprietary |
  61. | **Streaming** | SSE + async webhooks | Varies |
  62. | **License** | MIT | Closed |
  63. | **Auth** | GitHub OAuth + API keys — multi-tenant namespaces | Vendor console only |
  64. | **LLM keys** | Bring your own keys | Vendor billing only |
  65. ---
  66. ## 🏗️ Use Cases
  67. ### 🚀 For OSS skill maintainers — close the issues you can't answer today
  68. You wrote `changelog-generator` (or `research-to-brief`, or `incident-postmortem`). It works in Claude Code. Stars are climbing. Then someone opens issue #34: *"How do I run this from a CI pipeline?"* Issue #41: *"Can I integrate this with Linear?"* Issue #58: *"My status-page automation needs this."*
  69. Today you respond: *"Sorry, this is a SKILL.md — you need Claude Code installed."* Half abandon.
  70. **With Skrun:** `skrun deploy`, you reply with a curl command. Issue closed in 5 minutes instead of 3 hours of setup. The drop-off between "starred it" and "actually running it" disappears.
  71. ### 🛠️ For internal AI platforms — visibility and standardization without rewriting
  72. Your team has accumulated 12 LLM-powered scripts in 2 years. Each engineer rolled their own. One left last week — three of his scripts are crashing silently. Your LLM bill went 5x without explanation. The board asked twice "what's our AI strategy?" — you don't have one.
  73. **With Skrun:** wrap existing scripts gradually as skills (or `AGENTS.md`, or your own format). No big-bang rewrite. One dashboard for all AI calls — cost per feature, failure modes, ownership. Your team standardizes on one declarative format. New engineers read a manifest in 30 seconds instead of reverse-engineering 800 lines.
  74. ### 🎯 For freelance & agencies — stop bricolating per-client AI deliveries
  75. Each new client means 2-3 weeks of build. You glue Express + Anthropic SDK + Vercel for each delivery. The plumbing is identical 70% of the time. Worse: when a client wants to switch from Anthropic to OpenAI 3 months later, you're back rewriting auth + retry + fallback logic.
  76. **With Skrun:** same skill format, deploy per client. Model swap is a YAML edit. Your client gets a stable `POST /run` endpoint **they own** — they can host on their infra, swap models, take over anytime. You ship the skill, not a server you maintain.
  77. ---
  78. ## 💬 What would *you* deploy?
  79. What skill would you turn into an API tomorrow? What's missing in your current agent setup?
  80. **[Tell us in Discussions](https://github.com/skrun-dev/skrun/discussions)** — we read every post, and it shapes what we build next.
  81. ---
  82. ## 🚀 Quick Start
  83. ```bash
  84. npm install -g @skrun-dev/cli
  85. skrun init --from-skill ./my-skill # or: skrun init my-agent
  86. skrun deploy -m "initial release" # build + push + get your API URL
  87. skrun verify dev/my-skill@1.0.0 # admin step — auto-admin in local dev
  88. skrun run dev/my-skill -i '{"query":"analyze this"}'
  89. ```
  90. That's it. Your agent is verified, callable via the CLI, and reachable as a `POST /run` HTTP endpoint:
  91. ```bash
  92. curl -X POST http://localhost:4000/api/agents/dev/my-skill/run \
  93. -H "Authorization: Bearer dev-token" \
  94. -H "Content-Type: application/json" \
  95. -d '{"input": {"query": "analyze this"}}'
  96. ```
  97. > `dev-token` is for local development. In production, authenticate via [GitHub OAuth or API keys](docs/api.md#authentication) — your GitHub login becomes your namespace by default, and `skrun verify` is governed by the operator [verification policy](docs/self-hosting.md#verification-policy) (admin-only by default; creators can self-attest under `owner`).
  98. → **[10-minute tutorial](docs/getting-started.md)** · **[Concepts](docs/concepts.md)** · **[API reference](docs/api.md)**
  99. ---
  100. ## 📊 Dashboard
  101. <p align="center">
  102. <img src="docs/assets/dashboard/home.png" alt="Skrun Operator Dashboard — Home" width="900">
  103. </p>
  104. Every Skrun registry ships with a full operator dashboard at `/dashboard`. No separate install, no extra env var.
  105. - **Home** — workspace stats, 24h/7d toggles, the account's usage of the server's quotas, recent activity, top agents.
  106. - **Agents** — sortable list with run counts, token usage, verification status.
  107. - **Agent detail** — per-agent metrics, versions with notes, metadata, try-it curl.
  108. - **Runs** — every execution across all agents, filterable by agent/ID/status/model.
  109. - **Run detail** — full I/O, tokens, cost, model, event timeline (tool calls, LLM calls).
  110. - **Playground** — call any agent interactively, watch SSE events live, save outputs.
  111. - **Settings** — profile + API keys (`skrun_sk_…`) with one-shot reveal, revocation, and a per-key expiry (or none).
  112. → **[Screenshot tour of all 7 pages](docs/getting-started.md#6-explore-the-dashboard)**
  113. ---
  114. ## 📦 SDK
  115. ```bash
  116. npm install @skrun-dev/sdk
  117. ```
  118. ```typescript
  119. import { SkrunClient } from "@skrun-dev/sdk";
  120. const client = new SkrunClient({
  121. baseUrl: "http://localhost:4000",
  122. token: "dev-token",
  123. });
  124. // Sync — get the result
  125. const result = await client.run("dev/code-review", { code: "const x = 1;" });
  126. console.log(result.output);
  127. // Stream — real-time events
  128. for await (const event of client.stream("dev/code-review", { code: "..." })) {
  129. console.log(event.type); // run_start, tool_call, llm_complete, run_complete
  130. }
  131. // Async — fire and forget with webhook callback
  132. const { run_id } = await client.runAsync("dev/agent", input, "https://your-app.com/hook");
  133. // Pin a specific agent version — reproducible, no silent drift
  134. const pinned = await client.run("dev/code-review", input, { version: "1.2.0" });
  135. console.log(pinned.agent_version); // "1.2.0" — always echoed back
  136. // Push with a note (like a git commit message)
  137. await client.push("dev/code-review", bundle, "1.3.0", { message: "Added retry logic" });
  138. ```
  139. 10 methods: `run`, `stream`, `runAsync`, `push`, `pull`, `list`, `getAgent`, `getVersions`, `verifyVersion`, `setVisibility`. **Zero runtime dependencies**, Node.js 22+.
  140. ---
  141. ## ✨ Features
  142. | Feature | Description |
  143. |---------|-------------|
  144. | 🤖 **Multi-model** | 6 built-in providers (Anthropic, OpenAI, Google, Mistral, Groq, xAI) + any OpenAI-compatible endpoint (DeepSeek, Kimi, Qwen, Ollama, vLLM…) — with automatic fallback |
  145. | 🔧 **Tool calling** | Local scripts (`scripts/`) + MCP servers (`npx`) — same ecosystem as Claude Desktop |
  146. | 💾 **Stateful** | Agents remember across runs via key-value state — one notebook per caller by default |
  147. | 📡 **Streaming** | SSE real-time events (`run_start` → `tool_call` → `run_complete`) + async webhooks |
  148. | 📦 **Typed SDK** | `npm install @skrun-dev/sdk` — `run()`, `stream()`, `runAsync()` + 7 more methods |
  149. | 📊 **Operator Dashboard** | Web UI at `/dashboard` — agents, runs, stats, settings, integrated playground with SSE streaming |
  150. | 📖 **Interactive API docs** | OpenAPI 3.1 schema + Scalar explorer at `GET /docs` |
  151. | 🔐 **Production auth** | GitHub OAuth login + API keys (`skrun_sk_…`) + multi-tenant namespaces |
  152. | ⚖️ **Per-account quotas** | Off until the operator sets them, [per plan](docs/self-hosting.md#quotas-per-plan): an account's runs in progress and its compute time per window, a cap on the runs the whole instance holds at once — the lever that bounds what runs cost —, a longest timeout, and an account's bundle storage and live uploads, checked at the push and at the upload. A refused run gets a typed `429` / `503` / `400` with `Retry-After`, and the account's full-access credentials see its numbers in `X-Quota-*` headers and read them at any time from `GET /api/usage` (`client.usage()` in the SDK); with a pre-warm pool, a plan also sets how many runs an hour are entitled to a ready machine. An admin assigns an account's plan with one request |
  153. | 🗄️ **Persistent storage** | Pluggable database — SQLite for local dev (zero-config, file-based), any standard Postgres for production (Supabase, Neon, RDS, Fly Postgres… — no vendor lock-in) |
  154. | 🔑 **Caller keys** | Users bring their own LLM keys via `X-LLM-API-Key` — zero cost for operators. A key only ever goes to an endpoint its **owner** chose: an agent may declare its own `model.base_url`, so running someone else's agent with your key for its primary model means naming the origin you expect (`X-LLM-Base-URL`), and the server never pairs its own key with an agent-chosen endpoint unless the operator opts in |
  155. | ✅ **Agent verification** | Per-version verified flag, governed by the operator's [verification policy](docs/self-hosting.md#verification-policy): by default an unverified version cannot run at all, so an admin vets each version before any caller uses it; under `owner`, creators attest their own |
  156. | 🔒 **Private by default** | Every agent is `private` — only its owner/admin can `POST /run`; non-owners get an opaque 404 and can't override the agent's declared environment. Agents are private-only for now — setting one `public` is disabled |
  157. | 📌 **Version pinning + notes** | Pin a specific agent version per call (`version: "1.2.0"`) or attach a note at push (`-m "..."`) — reproducible integrations, visible changelog |
  158. | 🌍 **Environment separation** | Agent behavior (model, tools) separated from runtime environment (networking, timeout, cost cap). Per-run overrides via POST /run body |
  159. | 📁 **Files API** | Unified `/api/files` namespace for both directions — upload binary inputs (image/PDF/audio) via `POST /api/files`, download agent-produced artifacts via `GET /api/files/:id/content` |
  160. | 🖼️ **Multimodal inputs** | Declare `type: file` inputs (image / PDF / audio) in `agent.yaml`. Agents read images directly via vision (no OCR upstream). 3 transports: file_id ref, base64 inline, URL. Capability check at `skrun deploy/push` refuses incompatible model+media. |
  161. | 📦 **Script dependencies** | Drop a standard `package.json` (Node) or `requirements.txt` / `pyproject.toml` (Python) at the bundle root. Skrun installs them where your scripts run: a server that runs them itself resolves deps on first run and caches them at `~/.skrun/deps/<hash>/` for instant subsequent runs; the cloud sandbox installs them as each run starts. Auto-detects pnpm/yarn/npm + uv/poetry lockfiles for reproducible installs (npm only in the cloud sandbox). |
  162. | 🎯 **Tool choice** | Force the LLM to invoke a specific tool (top-level `tool_choice: <name>`), require any tool (`tool_choice: required`), block tool use (`none`), or mark per-tool invariants with `required: true`. Native cross-provider support (Anthropic / Gemini / OpenAI / xAI) with graceful soft-fallback when a directive isn't natively supported. |
  163. | 💸 **Native prompt caching** | Automatic across all 6 providers (Anthropic / OpenAI / Gemini / xAI / Groq / Mistral) — 30-90% input cost savings on repeated content (system prompts + tools + reference documents). Anthropic gets explicit `cache_control` injection on the system + tools prefixes, and on the conversation as a tool loop grows; OpenAI / Mistral / xAI / Groq / Gemini benefit from implicit caching. Cost-tracking accuracy improves to ±5% of provider invoice via the new `cache_read_tokens` / `cache_write_tokens` fields in `usage`. Track dollar savings live (`cost.saved`) and on the dashboard. |
  164. | 📊 **Structured logs** | JSON to stdout via pino — pipe to Axiom, Datadog, ELK. `LOG_LEVEL` env var controls verbosity |
  165. | ☁️ **Cloud deployment** | `SKRUN_RUNTIME=flyio` spawns a dedicated ephemeral sandbox machine per run. The harness drives the LLM loop and holds every credential; the sandbox runs agent code with zero LLM/DB/S3 keys, as a non-root UID with zero capabilities, behind an iptables egress allowlist; its root filesystem is writable, and each machine serves a single run. Self-host `docker-compose` applies container-level hardening (read-only rootfs, non-root, cap-drop, no-new-privileges); the per-run micro-VM + zero-credential sandbox are cloud-only (self-host runs agents in-process). |
  166. ---
  167. ## 🧪 Demo agents
  168. Fourteen runnable demos under [`agents/`](./agents/). The eight below each produce a real, downloadable artifact (PDF, XLSX, PPTX, ZIP, CSV, MD); the six others — code-review, data-analyst, email-drafter, pdf-processing, seo-audit, web-scraper — answer in the run's output. All use Google's Gemini 3.8 Flash by default (free tier), with Gemini 3.5 Flash-Lite as fallback. Change the `model` section in `agent.yaml` to use any [supported provider](#-features).
  169. ### For OSS developers
  170. | Agent | What it does | Artifact |
  171. |-------|--------------|----------|
  172. | 📝 [changelog-generator](agents/changelog-generator/) | Reads your local `git log` between two tags, groups commits by Conventional Commit type, drafts release notes | `CHANGELOG.md` + `release-notes.md` |
  173. | 📐 [adr-writer](agents/adr-writer/) | Captures an architectural decision (context / options / decision / consequences) as a numbered Markdown ADR — auto-numbers from your existing `adrs/` folder | `NNNN-<slug>.md` |
  174. ### For internal-platform / engineering teams
  175. | Agent | What it does | Artifact |
  176. |-------|--------------|----------|
  177. | 🎯 [meeting-transcript-to-action-items](agents/meeting-transcript-to-action-items/) | Extracts decisions + action items from a Zoom/Teams transcript. **Stateful** — auto-resolves prior actions when next meeting mentions them as done | `actions.csv` + `recap.md` |
  178. | 🛡️ [semgrep-rule-creator](agents/semgrep-rule-creator/) | Turns a CVE description + bad-code snippet into a complete Semgrep rule bundle (rule + tests + rationale) | `rule.yml` + `tests.md` + `README.md` |
  179. ### For freelancers / analysts / biz operators
  180. | Agent | What it does | Artifact |
  181. |-------|--------------|----------|
  182. | 📊 [csv-to-executive-report](agents/csv-to-executive-report/) | CSV → analyzed multi-page PDF with charts + narrative + summary table | `report.pdf` |
  183. | 🎤 [slide-deck-generator](agents/slide-deck-generator/) | Markdown outline → polished `.pptx` with brand color, title/content/closing layouts, speaker notes | `deck.pptx` |
  184. | 🧾 [receipts-to-expenses](agents/receipts-to-expenses/) | Receipt photos (vision-native) + optional bank statement → categorized expense workbook + summary PDF | `expenses.xlsx` + `monthly.pdf` |
  185. ### Universal
  186. | Agent | What it does | Artifact |
  187. |-------|--------------|----------|
  188. | 🧠 [knowledge-base-from-vault](agents/knowledge-base-from-vault/) | Folder of Markdown notes (Obsidian/Notion/raw) → navigable static HTML site. **Stateful** — concept index densifies across runs | `kb.zip` (HTML+CSS) |
  189. <details>
  190. <summary><b>Earlier minimal demos</b></summary>
  191. Shorter examples that each illustrate one primitive (model fallback, MCP, state, scripts) without producing artifacts:
  192. [code-review](agents/code-review/) · [pdf-processing](agents/pdf-processing/) · [seo-audit](agents/seo-audit/) · [data-analyst](agents/data-analyst/) · [email-drafter](agents/email-drafter/) · [web-scraper](agents/web-scraper/)
  193. </details>
  194. <details>
  195. <summary><b>Try one locally</b></summary>
  196. ```bash
  197. # 1. Start the registry (uses SQLite — data persists across restarts)
  198. cp .env.example .env # add your GOOGLE_API_KEY
  199. pnpm dev:registry # keep this terminal open
  200. # 2. In another terminal — pick any agent (changelog-generator is the lightest)
  201. skrun login --token dev-token
  202. cd agents/changelog-generator
  203. skrun build && skrun push -m "v1 — first push"
  204. skrun verify dev/changelog-generator@0.3.1 # admin step; dev-token = auto-admin
  205. # 3. Call it (uses the bundled fixture — no real git repo needed)
  206. skrun run dev/changelog-generator \
  207. -i '{"repo_path": "./fixtures/sample-repo.git-log.txt", "project_name": "demo"}'
  208. # Or via raw HTTP:
  209. curl -X POST http://localhost:4000/api/agents/dev/changelog-generator/run \
  210. -H "Authorization: Bearer dev-token" \
  211. -H "Content-Type: application/json" \
  212. -d '{"input": {"repo_path": "./fixtures/sample-repo.git-log.txt", "project_name": "demo"}}'
  213. # 4. Download the artifacts via the Files API (run_id from response)
  214. curl http://localhost:4000/api/runs/<run_id>/files/CHANGELOG.md \
  215. -H "Authorization: Bearer dev-token" -o CHANGELOG.md
  216. ```
  217. > **Windows (PowerShell):** use `curl.exe` instead of `curl`, and pass `-d "@input.json"` for the body.
  218. > **Python demos** (slide-deck-generator, csv-to-executive-report, receipts-to-expenses) and the **Node demo** (knowledge-base-from-vault): no manual install. The local registry resolves each agent's `requirements.txt` / `package.json` on its first call and caches the result on this machine, at `~/.skrun/deps/<hash>/`. See the [Script dependencies](docs/agent-yaml.md#script-dependencies) reference.
  219. </details>
  220. ---
  221. ## 💻 CLI
  222. | Command | Description |
  223. |---------|-------------|
  224. | `skrun init [dir]` | Create a new agent |
  225. | `skrun init --from-skill <path>` | Import existing skill |
  226. | `skrun dev` | Local server with POST /run (mock, free) |
  227. | `skrun test` | Check tests against simulated outputs (no model call) |
  228. | `skrun build` | Package `.agent` bundle |
  229. | `skrun push -m "note"` | Push with a version note |
  230. | `skrun verify <ns>/<name>@<v>` | Attest a version (authority per the verification policy — admin by default) |
  231. | `skrun unverify <ns>/<name>@<v>` | Revoke verification (authority per the verification policy) |
  232. | `skrun run <ns>/<name>[@<v>]` | Invoke an agent — `-i` inline, `-f` file, `--stdin` pipe |
  233. | `skrun deploy -m "note"` | Build + push + run URL |
  234. | `skrun pull <agent>` | Download agent bundle |
  235. | `skrun keys create --name <key-name> --agent <ns>/<name> --run-only` | Mint a scoped/restricted API key (e.g. a run-only client key) |
  236. | `skrun llm-key set <provider> --agent <ns>/<name>` | Attach your LLM key so callers run the agent on your key (key from stdin / `--key-env`) |
  237. | `skrun login --registry <url>` / `logout` | Sign in to a server, which the CLI then remembers (OAuth or token); sign out of it |
  238. | `skrun logs <agent>` | Execution logs (planned) |
  239. → **[Full CLI reference](docs/cli.md)**
  240. ---
  241. ## 🌐 Self-hosting
  242. Skrun is MIT — deploy anywhere.
  243. Recommended: the prod-parity Docker Compose stack (Postgres + MinIO + Redis + Caddy) — follow its **[quick start](docs/self-hosting-docker.md#quick-start)**.
  244. - 🐳 **Docker Compose** — `docker compose up` brings the prod-parity stack (Postgres + MinIO + Redis + Caddy) live with every sandbox hardening control on by default. See **[self-hosting with Docker](docs/self-hosting-docker.md)**.
  245. - **SQLite (bare-metal)** — zero config, file-based, survives restarts. Good for local dev and single-node.
  246. - **Postgres** — production-grade. Any host works (Supabase, Neon, RDS, Fly Postgres…) via `DATABASE_URL=postgres://…`. No vendor lock-in.
  247. - **Any cloud** — Fly.io, AWS, GCP, Hetzner, bare metal. Caddy or nginx in front.
  248. - **GitHub OAuth** — users sign in with GitHub; their login becomes their namespace by default (`<login>--2` if it is taken).
  249. → **[Self-hosting guide](docs/self-hosting.md)** — step-by-step with env vars, reverse proxy, migrations.
  250. ---
  251. ## 📚 Documentation
  252. - 📖 **[Getting Started](docs/getting-started.md)** — 10-minute tutorial with dashboard screenshots
  253. - 🧠 **[Concepts](docs/concepts.md)** — vocabulary reference (agent, skill, run, namespace…)
  254. - 🌐 **[Self-hosting](docs/self-hosting.md)** — deploy on your own infrastructure
  255. - 🔧 [agent.yaml](docs/agent-yaml.md) · [CLI](docs/cli.md) · [API](docs/api.md) — full references
  256. - 🎮 [Interactive API explorer](http://localhost:4000/docs) — live Scalar UI (start the registry first)
  257. - 📋 [OpenAPI schema](http://localhost:4000/openapi.json) — import into Postman / Insomnia
  258. - 📝 [Changelog](CHANGELOG.md) · 🤝 [Contributing](CONTRIBUTING.md)
  259. ---
  260. ## 👥 Community
  261. - 💬 [GitHub Discussions](https://github.com/skrun-dev/skrun/discussions) — ask questions, share agents
  262. - 🐛 [Issues](https://github.com/skrun-dev/skrun/issues) — report bugs, request features
  263. - ⭐ [Star the repo](https://github.com/skrun-dev/skrun) if you like the project!
  264. ---
  265. ## 🤝 Contributing
  266. ```bash
  267. git clone https://github.com/skrun-dev/skrun.git
  268. cd skrun
  269. pnpm install && pnpm build && pnpm test
  270. ```
  271. See [CONTRIBUTING.md](CONTRIBUTING.md) for conventions and setup.
  272. ---
  273. ## 📜 License
  274. [MIT](LICENSE) — free to use, modify, self-host, and build on top.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.