OpenObserve PR Brief
openobserve/openobserve
Produces a read-only morning brief of your open pull requests across the openobserve GitHub org, with a next step for each and a reminder for idle ones.
This skill should be used when the user asks to "create an automation", "schedule a task", "set up a cron job", "webhook integration", "event-triggered automation", or mentions automations…
$ npx skills add OpenHands/extensions --skill openhands-automation -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install OpenHands/extensions openhands-automation --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/OpenHands/extensions.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/openhands-automation .claude/skills/openhands-automation && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "openhands-automation" agent skill from https://github.com/OpenHands/extensions/tree/main/skills/openhands-automation into .claude/skills/openhands-automation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "openhands-automation", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/OpenHands/extensions/tree/main/skills/openhands-automationType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add OpenHands/extensions --skill openhands-automation -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install OpenHands/extensions openhands-automation --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/OpenHands/extensions.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/openhands-automation .agents/skills/openhands-automation && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "openhands-automation" agent skill from https://github.com/OpenHands/extensions/tree/main/skills/openhands-automation into .agents/skills/openhands-automation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "openhands-automation", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add OpenHands/extensions --skill openhands-automation -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install OpenHands/extensions openhands-automation --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/OpenHands/extensions.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/openhands-automation .cursor/skills/openhands-automation && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "openhands-automation" agent skill from https://github.com/OpenHands/extensions/tree/main/skills/openhands-automation into .cursor/skills/openhands-automation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "openhands-automation", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/OpenHands/extensions.git --path skills/openhands-automation--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add OpenHands/extensions --skill openhands-automation -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install OpenHands/extensions openhands-automation --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/OpenHands/extensions.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/openhands-automation .gemini/skills/openhands-automation && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "openhands-automation" agent skill from https://github.com/OpenHands/extensions/tree/main/skills/openhands-automation into .gemini/skills/openhands-automation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "openhands-automation", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install OpenHands/extensions openhands-automationInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add OpenHands/extensions --skill openhands-automation -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/OpenHands/extensions.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/openhands-automation .github/skills/openhands-automation && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "openhands-automation" agent skill from https://github.com/OpenHands/extensions/tree/main/skills/openhands-automation into .github/skills/openhands-automation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "openhands-automation", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add OpenHands/extensions --skill openhands-automation -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install OpenHands/extensions openhands-automation --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/OpenHands/extensions.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/openhands-automation .opencode/skills/openhands-automation && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "openhands-automation" agent skill from https://github.com/OpenHands/extensions/tree/main/skills/openhands-automation into .opencode/skills/openhands-automation/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "openhands-automation", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
openhands-automationThis skill should be used when the user asks to "create an automation", "schedule a task", "set up a cron job", "webhook integration", "event-triggered automation", or mentions automations…
Openhands Automation is an agent skill from OpenHands/extensions. This skill should be used when the user asks to "create an automation", "schedule a task", "set up a cron job", "webhook integration", "event-triggered automation", or mentions automations, scheduled tasks, cron scheduling, or webhook events in OpenHands Cloud.
Its SKILL.md is about 12k tokens, which your agent loads only when the skill is triggered. The skill folder holds 12 other files, including reference files (for example `.plugin/plugin.json`, `README.md` and `commands/automation-create.md`).
It sits in Productivity & Automation, covering Scheduled and recurring tasks and Webhooks. It works with GitHub. The repository describes itself as: Public registry for OpenHands extensions. The licence is MIT.
2 steps, taken from the first numbered list in SKILL.md.
Read from SKILL.md and the folder at commit d008b81. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Shell commands in SKILL.md call:
curljqpython3From the folder's file list and the shell code blocks in SKILL.md.
Hosts in commands or code, which the agent is likely to contact:
github.comslack.comgitlab.comFrom URLs in SKILL.md, links to its own repository left out.
Names these keys or tokens, usually read from environment variables:
OPENHANDS_API_KEYSESSION_API_KEYAUTOMATION_KV_TOKENOPENHANDS_AUTOMATION_API_KEYAUTOMATION_CALLBACK_API_KEYSLACK_BOT_TOKENFrom names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Openhands Automation loads about 12k tokens when it runs, and up to ~24k if it reads all its reference files. Until then it costs about 71 tokens; SKILL.md has 3,738 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from OpenHands/extensions at commit d008b81, republished under its MIT licence (© OpenHands). 3,738 words, ~12,150 tokens.
.claude/skills/openhands-automation/SKILL.md (or your agent's skills folder). This skill also uses 9 other files; get the full folder from GitHub.Create and manage automations that run inside an OpenHands agent server — triggered by cron schedules or webhook events (GitHub, custom services).
Windows PowerShell equivalents for the automation API curl examples and shell-variable conventions are in references/windows.md.
The agent must follow these steps when creating an automation:
canvas_ui tool if available, otherwise present it in a fenced code block in your replyTwo components work together to run automations:
Automation Service (API at OPENHANDS_HOST/api/automation/v1)
Manages the when: holds automation definitions, schedules cron-triggered runs, dispatches webhook-triggered runs, and receives completion callbacks to mark runs as done. This is the API you call to create, update, and manage automations.
Agent Server (accessible as AGENT_SERVER_URL inside script runs)
Manages the what: the runtime environment where automation scripts execute and where conversations (AI agent interactions with tools, bash, file editing, etc.) run. When a run is triggered, the automation service uploads the automation's tarball to the agent server, which unpacks and runs the entrypoint script. The script connects back to the agent server using AGENT_SERVER_URL and a session API key to start, monitor, and stop conversations.
The agent server typically runs inside a sandbox (a Docker or Kubernetes container). Some deployments use sandboxless mode, where the agent server runs directly on a host.
Key environment variables:
| Variable | Availability | Description |
|---|---|---|
RUNTIME_URL | Ambient in cloud environments | Public-facing URL of the agent server sandbox. Use this to determine whether external webhook delivery is possible — if unset or local, webhooks cannot be received. The automation service may run at a separate URL (see Determining the API Host). |
AGENT_SERVER_URL | Injected into scripts at run time, local Agent Canvas only | Internal URL of the agent server. Available inside script execution context; not an ambient environment variable outside of a running script, and not set on OpenHands Cloud or Enterprise. |
OPENHANDS_HOST | Shell convention only — set manually | Base URL for the automation service API. Not a real environment variable. Set it from an explicit host, a detected local Agent Canvas server, or the cloud default. Used in all curl examples throughout this skill. |
⚠️ CRITICAL — Agent behavior rules:
Does this task need an LLM at all? Check first. Before picking a preset, ask whether the task actually requires reasoning, judgment, summarization, or open-ended tool use. If it is fully deterministic — fixed data transforms, scheduled HTTP calls, healthcheck pings, file rotation, picking from a known list, posting a templated message — an LLM-driven preset is overkill. Every run will consume LLM tokens, which adds up fast at high frequencies (every 5 min ≈ 288 runs/day). Surface the trade-off to the user and offer the custom-script path (see
references/custom-automation.md) as the cheaper, more reliable option. Be especially careful for cron schedules tighter than hourly.Instant-recognition patterns — these are always deterministic, never use an LLM preset:
- "post a quote / message / fact every N minutes" (rotating from a list)
- "send a scheduled reminder / standup / digest"
- "ping a health-check URL on a schedule"
- "post to Slack / webhook every N minutes"
- Any task where the full output could be written as a static template right now
For LLM-appropriate work, default to preset endpoints. They handle all SDK boilerplate, tarball packaging, and upload automatically:
- Prompt preset (
POST /v1/preset/prompt) — for tasks expressed as a natural language prompt that benefit from agent reasoning- Plugin preset (
POST /v1/preset/plugin) — when plugins with skills, MCP configs, or commands are neededPresent the options, then build the one the user picks. Whenever rule 0 applies, or neither preset is a clean fit (custom Python dependencies, a non-Python entrypoint, a multi-file project, direct SDK lifecycle control), lay the choices out side by side with a one-line note on cost and reliability for each, and let the user choose:
- Prompt preset - natural language prompt execution (LLM-driven)
- Plugin preset - load plugins with extended capabilities (skills, MCP, hooks, commands)
- Custom script - full control over code, with or without an LLM; see
references/custom-automation.mdDo not silently fall back to either side. The "ready to deploy?" confirmation in the creation process applies to every path equally; a custom script needs no extra permission beyond it, and a preset gets no pass on it.
Building a custom script: follow
references/custom-automation.mdfor tarball packaging, validation, and upload. The Custom Script Example (No LLM) below shows the whole flow end to end.Before suggesting event-triggered (webhook) automations, check whether the deployment is publicly reachable. Check
RUNTIME_URL. Webhooks require an internet-accessible URL so that external services (GitHub, Slack, Linear, etc.) can deliver events to the automation service. IfRUNTIME_URLis unset, empty, or resolves to a local or private address (localhost,127.0.0.1,0.0.0.0, or any RFC 1918 range:10.x.x.x,192.168.x.x,172.16–31.x.x), the service cannot receive inbound webhook traffic from the public internet. In that case:
- Recommend a cron-based polling automation instead. Have the automation run on a schedule and call the external service's API (e.g., the GitHub REST API) to check for new events since the last run.
- Explain the limitation clearly to the user: "Because this is a local deployment, external services can't reach the webhook endpoint. I'll set up a polling automation using a cron schedule instead."
When building a deterministic custom script, these two stdlib-only functions are required. Copy them verbatim - they use variables injected by the automation service: SESSION_API_KEY, plus AGENT_SERVER_URL on a local Agent Canvas or OPENHANDS_CLOUD_API_URL and SANDBOX_ID on OpenHands Cloud and Enterprise.
import json, os, urllib.request
def get_secret(name):
"""Fetch a named secret: from the agent server when AGENT_SERVER_URL is set, else from the OpenHands API."""
url = os.environ.get("AGENT_SERVER_URL", "").rstrip("/")
key = os.environ.get("SESSION_API_KEY") or os.environ.get("OH_SESSION_API_KEYS_0", "")
if url: # local Agent Canvas
url = f"{url}/api/settings/secrets/{name}"
else: # OpenHands Cloud / Enterprise
api = os.environ["OPENHANDS_CLOUD_API_URL"].rstrip("/")
url = f"{api}/api/v1/sandboxes/{os.environ['SANDBOX_ID']}/settings/secrets/{name}"
with urllib.request.urlopen(urllib.request.Request(
url, headers={"X-Session-API-Key": key}
)) as r:
return r.read().decode().strip()
def fire_callback(status="COMPLETED", error=None):
"""Signal run completion. MUST be called on every exit path — success AND error."""
url = os.environ.get("AUTOMATION_CALLBACK_URL", "")
if not url: return
body = {"status": status, "run_id": os.environ.get("AUTOMATION_RUN_ID", "")}
if error: body["error"] = error
try:
urllib.request.urlopen(urllib.request.Request(url, data=json.dumps(body).encode(), headers={
"Content-Type": "application/json",
"Authorization": f"Bearer {os.environ.get('AUTOMATION_CALLBACK_API_KEY', '')}",
}))
except Exception as e: print(f"Callback error: {e}")Entrypoint must be python3 main.py (no setup.sh needed). Wrap your main logic in try/except and call fire_callback("FAILED", str(e)) in the except block.
State persistence between runs — polling automations that track a "last processed" timestamp or active conversation IDs must use the built-in KV store rather than local files. Local files are lost when a run ends on a cloud pod. The KV store is available when AUTOMATION_KV_TOKEN is injected into the run environment. See references/custom-automation.md#state-persistence-kv-store for ready-to-copy kv_get / kv_set / load_state / save_state helpers.
All requests require authentication:
Cloud (default https://app.all-hands.dev): Bearer token:
-H "Authorization: Bearer ${OPENHANDS_API_KEY}"
Local Agent Canvas (http://localhost:8001): session API key through X-Session-API-Key:
-H "X-Session-API-Key: ${OPENHANDS_AUTOMATION_API_KEY:-${SESSION_API_KEY}}"
The curl examples below show cloud Bearer authentication. For local Agent Canvas, replace that header with the X-Session-API-Key header above.
Before making API calls, determine the correct host:
The automation service may run at a different URL from the agent server. In the examples throughout this skill, ${OPENHANDS_HOST} is a shell-variable convention for the automation service base URL — it is not a real environment variable. Set it from context before running any curl command:
<HOST> value in the system prompt or runtime-services block. If present, use that URL.http://localhost:8001 for the local automation/agent-server API.https://app.all-hands.dev.For a local Agent Canvas server, validate the endpoint before making a mutating request and authenticate with the session key through X-Session-API-Key when that API requires it. Do not use the cloud default merely because no <HOST> value is present.
# Choose the host that matches the detected environment:
OPENHANDS_HOST="http://localhost:8001" # local Agent Canvas
# OPENHANDS_HOST="https://app.all-hands.dev" # OpenHands Cloud| Endpoint | Method | Description |
|---|---|---|
/api/automation/v1/preset/prompt | POST | Create automation from a prompt (recommended) |
/api/automation/v1/preset/plugin | POST | Create automation with plugins |
/api/automation/v1 | GET | List automations |
/api/automation/v1/{id} | GET | Get automation details |
/api/automation/v1/{id} | PATCH | Update automation |
/api/automation/v1/{id} | DELETE | Delete automation |
/api/automation/v1/{id}/dispatch | POST | Trigger a run manually |
/api/automation/v1/{id}/runs | GET | List automation runs |
| Endpoint | Method | Description |
|---|---|---|
/api/automation/v1/webhooks | POST | Register a custom webhook source |
/api/automation/v1/webhooks | GET | List all custom webhooks |
/api/automation/v1/webhooks/{id} | GET | Get webhook details |
/api/automation/v1/webhooks/{id} | PATCH | Update webhook settings |
/api/automation/v1/webhooks/{id} | DELETE | Delete a webhook |
/api/automation/v1/webhooks/{id}/rotate-secret | POST | Rotate signing secret |
Automations support two trigger types:
| Trigger Type | Use Case |
|---|---|
| Cron | Run on a schedule (daily, weekly, hourly, etc.) |
| Event | Run when a webhook event occurs (GitHub PR opened, issue commented, etc.) — requires a publicly reachable deployment |
Two preset endpoints simplify automation creation by handling SDK boilerplate, tarball packaging, and upload automatically:
Use the preset/prompt endpoint for simple automations. Provide a natural language prompt describing the task.
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "My Automation Name",
"prompt": "What the automation should do",
"trigger": {
"type": "cron",
"schedule": "0 9 * * *",
"timezone": "UTC"
}
}'| Field | Required | Description |
|---|---|---|
name | Yes | Name of the automation (1-500 characters) |
prompt | Yes | Natural language instructions (1-50,000 characters) |
trigger | Yes | Trigger configuration — either cron or event (see below) |
timeout | No | Max execution time in seconds (default: system maximum) |
repos | No | Repositories to clone (see Repository Cloning) |
Cron Trigger Fields:
| Field | Required | Description |
|---|---|---|
trigger.type | Yes | "cron" |
trigger.schedule | Yes | Cron expression (5 fields: min hour day month weekday) |
trigger.timezone | No | IANA timezone (default: "UTC") |
Event Trigger Fields:
| Field | Required | Description |
|---|---|---|
trigger.type | Yes | "event" |
trigger.source | Yes | Event source: "github" or custom webhook source name |
trigger.on | Yes | Event key pattern(s) to match (see Event Keys below) |
trigger.filter | No | JMESPath expression for payload filtering (see Filter Expressions below) |
Write the prompt as an instruction to an AI agent. The prompt executes inside a sandbox with full tool access (bash, file editing, etc.), the user's configured LLM, stored secrets, and MCP server integrations. Examples:
"Generate a weekly status report summarizing the team's GitHub activity and post it to Slack""Read yesterday's new error reports in Sentry, group them by likely root cause, and open one GitHub issue per new failure pattern with a proposed fix""Go through support tickets tagged 'bug' since the last run, try to reproduce each against main, and comment on the ticket with what you found"Each of these needs judgment: deciding what counts as a pattern, whether a reproduction succeeded, what is worth reporting. A task whose output could be written as a fixed template right now belongs in a custom script instead (see Custom Script Example (No LLM) below).
| Field | Values | Description |
|---|---|---|
| Minute | 0-59 | Minute of the hour |
| Hour | 0-23 | Hour of the day (24-hour) |
| Day | 1-31 | Day of the month |
| Month | 1-12 | Month of the year |
| Weekday | 0-6 | Day of week (0=Sun, 6=Sat) |
Common schedules: 0 9 * * * (daily 9 AM), 0 9 * * 1-5 (weekdays 9 AM), 0 9 * * 1 (Mondays 9 AM), 0 0 1 * * (first of month), */15 * * * * (every 15 min), 0 */6 * * * (every 6 hours).
{
"id": "123e4567-e89b-12d3-a456-426614174000",
"name": "My Automation Name",
"trigger": {"type": "cron", "schedule": "0 9 * * *", "timezone": "UTC"},
"enabled": true,
"created_at": "2025-03-25T10:00:00Z"
}Daily report:
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Daily Report",
"prompt": "Generate a daily status report and save it to a file in the workspace",
"trigger": {"type": "cron", "schedule": "0 9 * * 1-5", "timezone": "America/New_York"}
}'Weekly dependency review:
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Weekly Dependency Review",
"prompt": "Check the repository dependencies for new releases. Read each changelog, open one PR with the upgrades that look safe, and list any release with breaking changes in the PR description so a human can decide on it",
"trigger": {"type": "cron", "schedule": "0 2 * * 0", "timezone": "UTC"},
"timeout": 1800
}'The same shape as the prompt preset, for a task that needs no reasoning: check a URL on a schedule and post to Slack only when it fails. Every run takes a moment and costs no tokens. This is the complete flow; get_secret and fire_callback are the helpers from No-LLM Script Helpers above.
mkdir healthcheck && cd healthcheck
cat > main.py << 'PYEOF'
"""Hourly health check: alert Slack on a non-200 response. No LLM, no SDK."""
import json, os, sys, urllib.request
URL = "https://api.example.com/health"
CHANNEL = "C12345678"
def get_secret(name):
url = os.environ.get("AGENT_SERVER_URL", "").rstrip("/")
key = os.environ.get("SESSION_API_KEY") or os.environ.get("OH_SESSION_API_KEYS_0", "")
if url: # local Agent Canvas
url = f"{url}/api/settings/secrets/{name}"
else: # OpenHands Cloud / Enterprise
api = os.environ["OPENHANDS_CLOUD_API_URL"].rstrip("/")
url = f"{api}/api/v1/sandboxes/{os.environ['SANDBOX_ID']}/settings/secrets/{name}"
req = urllib.request.Request(url,
headers={"X-Session-API-Key": key})
with urllib.request.urlopen(req) as r:
return r.read().decode().strip()
def fire_callback(status="COMPLETED", error=None):
url = os.environ.get("AUTOMATION_CALLBACK_URL", "")
if not url: return
body = {"status": status, "run_id": os.environ.get("AUTOMATION_RUN_ID", "")}
if error: body["error"] = error
req = urllib.request.Request(url, data=json.dumps(body).encode(), headers={
"Content-Type": "application/json",
"Authorization": f"Bearer {os.environ.get('AUTOMATION_CALLBACK_API_KEY', '')}",
})
try: urllib.request.urlopen(req)
except Exception as e: print(f"Callback error: {e}")
def slack(text):
token = get_secret("SLACK_BOT_TOKEN")
req = urllib.request.Request("https://slack.com/api/chat.postMessage",
data=json.dumps({"channel": CHANNEL, "text": text}).encode(),
headers={"Content-Type": "application/json", "Authorization": f"Bearer {token}"})
urllib.request.urlopen(req)
try:
try:
status = urllib.request.urlopen(URL, timeout=10).status
except Exception as e:
status = f"error: {e}"
if status != 200:
slack(f":rotating_light: {URL} returned {status}")
print(f"{URL} -> {status}")
fire_callback("COMPLETED")
except Exception as e:
print(f"ERROR: {e}", file=sys.stderr)
fire_callback("FAILED", str(e))
sys.exit(1)
PYEOF
tar -czf ../healthcheck.tar.gz .
TARBALL_PATH=$(curl -s -X POST "${OPENHANDS_HOST}/api/automation/v1/uploads?name=healthcheck" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/gzip" \
--data-binary @../healthcheck.tar.gz | jq -r '.tarball_path')
curl -X POST "${OPENHANDS_HOST}/api/automation/v1" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d "{
\"name\": \"Hourly Health Check\",
\"trigger\": {\"type\": \"cron\", \"schedule\": \"0 * * * *\", \"timezone\": \"UTC\"},
\"tarball_path\": \"$TARBALL_PATH\",
\"entrypoint\": \"python3 main.py\"
}"For state between runs (last alert time, last seen event), use the KV store helpers in references/custom-automation.md#state-persistence-kv-store.
When the deployment cannot receive inbound webhook traffic (see rule 4), use a cron-triggered automation that calls the external service’s API on a schedule to check for new events.
| Webhooks (Event trigger) | Polling (Cron trigger) | |
|---|---|---|
| Requires public URL | Yes | No — works locally |
| Latency | Near-instant | Up to one poll interval |
| API calls | Only on real events | Every poll interval |
| Best for | Cloud / public deployments | Local or private deployments |
Event-triggered automations run when a webhook event occurs — like a GitHub PR being opened, an issue receiving a comment, or a custom service sending a notification.
GitHub is a built-in integration — no webhook registration needed. Just create automations with "source": "github".
Events use the format {event_type}.{action} or just {event_type} (for events without actions like push).
| Event Type | Event Keys | Description |
|---|---|---|
pull_request | pull_request.opened, pull_request.closed, pull_request.synchronize, pull_request.labeled, pull_request.unlabeled, pull_request.reopened, pull_request.edited, pull_request.ready_for_review | PR activity |
issues | issues.opened, issues.closed, issues.reopened, issues.labeled, issues.unlabeled, issues.edited, issues.assigned | Issue activity |
issue_comment | issue_comment.created, issue_comment.edited, issue_comment.deleted | Comments on issues/PRs |
push | push | Code pushed to a branch |
release | release.published, release.created, release.released, release.prereleased | Release activity |
pull_request_review | pull_request_review.submitted, pull_request_review.edited, pull_request_review.dismissed | PR review activity |
Wildcards: Use * to match any action — e.g., pull_request.* matches all PR events.
Multiple patterns: The on field can be a string or array — e.g., ["push", "pull_request.opened"].
Filters let you match events based on payload content using JMESPath expressions.
| Function | Description | Example |
|---|---|---|
glob(str, pattern) | Wildcard pattern matching | glob(repository.full_name, 'myorg/*') |
icontains(str, substr) | Case-insensitive substring | icontains(comment.body, '@openhands') |
contains(array, value) | Array contains value | contains(pull_request.labels[].name, 'bug') |
regex(str, pattern) | Regular expression match | regex(ref, '^refs/tags/v\\d+') |
starts_with(str, prefix) | String starts with | starts_with(ref, 'refs/heads/') |
ends_with(str, suffix) | String ends with | ends_with(ref, '/main') |
lower(str) / upper(str) | Case conversion | lower(sender.login) == 'admin' |
&& — AND|| — OR ! — NOT// Exact match on label name
"contains(pull_request.labels[].name, 'openhands')"
// Case-insensitive mention in comment
"icontains(comment.body, '@openhands')"
// Match specific repository
"repository.full_name == 'myorg/myrepo'"
// Match any repo in an org
"glob(repository.full_name, 'myorg/*')"
// PR with 'bug' label in any org repo
"glob(repository.full_name, 'myorg/*') && contains(pull_request.labels[].name, 'bug')"
// Push to main or release branches
"glob(ref, 'refs/heads/main') || glob(ref, 'refs/heads/release/*')"
// Issue opened by a specific user
"sender.login == 'dependabot[bot]'"
// Not a draft PR
"!pull_request.draft"curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "OpenHands Mention Responder",
"prompt": "Analyze the issue or PR context and provide a helpful response to the user'\''s question. The comment body and context are available in the event payload.",
"trigger": {
"type": "event",
"source": "github",
"on": "issue_comment.created",
"filter": "icontains(comment.body, '\''@openhands'\'')"
},
"timeout": 300
}'curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Auto Review PRs",
"prompt": "Review this pull request for code quality, potential bugs, and best practices. Provide constructive feedback.",
"trigger": {
"type": "event",
"source": "github",
"on": "pull_request.labeled",
"filter": "contains(pull_request.labels[].name, '\''openhands'\'')"
}
}'curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Risky Change Watch",
"prompt": "Review the diff of this push. If it touches authentication, billing, data migrations, or anything that changes behavior for existing users, open an issue that explains the risk in plain terms and mentions the code owners. Otherwise do nothing.",
"trigger": {
"type": "event",
"source": "github",
"on": "push",
"filter": "ref == '\''refs/heads/main'\''"
}
}'curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Issue Triage Bot",
"prompt": "Analyze this new issue and suggest appropriate labels. If it looks like a bug, try to identify the root cause.",
"trigger": {
"type": "event",
"source": "github",
"on": "issues.opened",
"filter": "glob(repository.full_name, '\''myorg/*'\'')"
}
}'curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "PR Activity Bot",
"prompt": "Process the PR event and take appropriate action based on the event type.",
"trigger": {
"type": "event",
"source": "github",
"on": ["pull_request.opened", "pull_request.synchronize", "pull_request.ready_for_review"]
}
}'For services other than GitHub (Linear, Stripe, Slack, etc.), register a custom webhook first.
Agent behavior:
- Always provide the curl request to the user — do not attempt to register webhooks yourself. The exception is a service skill that ships a setup script for its webhook, such as
jira-issue-to-pr: the script registers both sides and keeps the signing secret out of the conversation, so run it as that skill describes.- Ask the user: "Do you have a webhook signing secret from [service], or should the system generate one?"
- If they have one → include
webhook_secretin the request- If not → omit it; the response will contain a generated secret they must configure in their service
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/webhooks" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Linear Issues",
"source": "linear",
"event_key_expr": "type",
"signature_header": "Linear-Signature",
"webhook_secret": "your-linear-webhook-secret"
}'| Field | Required | Description |
|---|---|---|
name | Yes | Human-readable name for the webhook |
source | Yes | Unique source identifier (lowercase, alphanumeric with hyphens, 1-50 chars) |
event_key_expr | No | JMESPath expression to extract event type from payload (default: "type") |
signature_header | No | HTTP header containing HMAC signature (default: "X-Signature-256") |
webhook_secret | No | Signing secret — provide your own (from the external service) or let the system generate one |
{
"id": "550e8400-e29b-41d4-a716-446655440000",
"webhook_url": "https://app.all-hands.dev/v1/events/{org_id}/linear",
"source": "linear",
"enabled": true
}Note: When you provide your own webhook_secret, it won't be echoed back in the response. If you don't provide one, the system generates a secret and returns it once — store it securely.
# List all webhooks
curl "${OPENHANDS_HOST}/api/automation/v1/webhooks" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}"
# Update a webhook
curl -X PATCH "${OPENHANDS_HOST}/api/automation/v1/webhooks/{webhook_id}" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{"enabled": false}'
# Rotate the signing secret
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/webhooks/{webhook_id}/rotate-secret" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}"
# Delete a webhook
curl -X DELETE "${OPENHANDS_HOST}/api/automation/v1/webhooks/{webhook_id}" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}"Linear sends webhooks with:
Linear-Signaturetype field (e.g., Issue, Comment, Project)action field (e.g., create, update, remove)# 1. Register the Linear webhook
# - Get your webhook signing secret from Linear's webhook settings
# - Use "Linear-Signature" as the signature header
# - Use "type" to extract the event type from the payload
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/webhooks" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Linear Issues",
"source": "linear",
"event_key_expr": "type",
"signature_header": "Linear-Signature",
"webhook_secret": "lin_wh_xxxxxxxxxxxxx"
}'
# Response includes webhook_url — configure this in Linear:
# Settings → API → Webhooks → New webhook → paste the webhook_url
# 2. Create an automation for new Linear issues
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Triage New Linear Issues",
"prompt": "A new issue was created in Linear. Analyze the issue title and description, suggest appropriate labels, and add a comment with initial triage notes.",
"trigger": {
"type": "event",
"source": "linear",
"on": "Issue",
"filter": "action == '\''create'\''"
}
}'
# 3. Create an automation for high-priority issue updates
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "High Priority Issue Alert",
"prompt": "A high-priority issue was updated. Review the changes and notify the team if action is needed.",
"trigger": {
"type": "event",
"source": "linear",
"on": "Issue",
"filter": "action == '\''update'\'' && data.priority == `1`"
}
}'Jira Cloud sends webhooks with:
X-Hub-Signature (sha256= followed by the hex HMAC-SHA256 of the body), sent only when the webhook has a secretwebhookEvent field (e.g., jira:issue_created, jira:issue_updated)issue.fields.labels is ["create-pr"], not a list of objects, so issue.fields.labels[].name matches nothingchangelog.items list naming each changed fieldOnly a webhook a Jira admin registers (Jira settings → System → WebHooks, or the REST API) can carry a secret. The "Send web request" action of a Jira Automation rule cannot sign its request, so it cannot deliver to a custom webhook.
When the user can supply the API token of a Jira administrator, scripts/setup_webhook.py in the jira-issue-to-pr skill registers the webhook on both sides for them, replacing step 1 and the Jira configuration below. Done by hand:
# 1. Register the Jira webhook
# - Use "X-Hub-Signature" as the signature header
# - Use "webhookEvent" to extract the event type from the payload
# - Omit webhook_secret to have one generated, or pass the one Jira generated
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/webhooks" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Jira Cloud",
"source": "jira",
"event_key_expr": "webhookEvent",
"signature_header": "X-Hub-Signature"
}'
# Response includes webhook_url and the generated webhook_secret - configure both in Jira:
# Jira settings → System → WebHooks → Create a WebHook → paste the webhook_url and the
# secret, then select the issue events. A JQL filter such as `labels = create-pr` keeps
# unrelated issues from being sent at all.
# 2. Create an automation for issues that receive a label
# The filter matches an issue created with the label and an update that changes the
# labels of an issue carrying it. Without the changelog check, every later edit of a
# labelled issue would start another run. It still fires when another label is added
# to or removed from an issue that carries the label, so have the prompt skip an
# issue that already has a pull request.
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Jira Issues Labelled create-pr",
"prompt": "A Jira issue received the create-pr label. Read the issue from the event payload and open a pull request for it.",
"trigger": {
"type": "event",
"source": "jira",
"on": ["jira:issue_created", "jira:issue_updated"],
"filter": "contains(issue.fields.labels, '\''create-pr'\'') && (webhookEvent == '\''jira:issue_created'\'' || length(changelog.items[?field == '\''labels'\''] || `[]`) > `0`)"
}
}'An unsigned request to the webhook URL answers 401 Missing signature header: X-Hub-Signature; that is the webhook working, not a fault. 404 Unknown webhook source means no webhook with that source is registered for the organization in the URL.
| Service | Signature Header | Event Key Expression |
|---|---|---|
| Linear | Linear-Signature | type |
| Jira Cloud | X-Hub-Signature | webhookEvent |
| Stripe | Stripe-Signature | type |
| Slack | X-Slack-Signature | type |
| Twilio | X-Twilio-Signature | type |
| Generic | X-Signature-256 | type |
Use the preset/plugin endpoint when you need to load one or more plugins that provide extended capabilities like skills, MCP configurations, hooks, and commands.
💡 Finding plugins: Browse the OpenHands/extensions repository for available skills and plugins. When given a broad use case, check this directory first to see if something already exists that fits your needs.
/plugin-name:command)curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/plugin" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "My Plugin Automation",
"plugins": [
{"source": "github:owner/repo", "ref": "v1.0.0"},
{"source": "github:owner/another-plugin"}
],
"prompt": "Use the plugin commands to perform the task",
"trigger": {
"type": "cron",
"schedule": "0 9 * * 1",
"timezone": "UTC"
}
}'| Field | Required | Description |
|---|---|---|
name | Yes | Name of the automation (1-500 characters) |
plugins | Yes | List of plugin sources (at least one required) |
plugins[].source | Yes | Plugin source: github:owner/repo, git URL, or local path |
plugins[].ref | No | Git ref: branch, tag, or commit SHA |
plugins[].repo_path | No | Subdirectory path for monorepos |
prompt | Yes | Instructions for the automation (1-50,000 characters) |
trigger | Yes | Trigger configuration — either cron or event (same as Prompt Preset) |
timeout | No | Max execution time in seconds (default: system maximum) |
repos | No | Repositories to clone (see Repository Cloning) |
| Format | Example | Description |
|---|---|---|
| GitHub shorthand | github:owner/repo | Fetches from GitHub |
| Git URL | https://github.com/owner/repo.git | Any git repository |
| With ref | {"source": "github:owner/repo", "ref": "v1.0.0"} | Specific branch/tag/commit |
| Monorepo | {"source": "github:org/monorepo", "repo_path": "plugins/my-plugin"} | Subdirectory in repo |
{
"id": "123e4567-e89b-12d3-a456-426614174000",
"name": "My Plugin Automation",
"trigger": {"type": "cron", "schedule": "0 9 * * 1", "timezone": "UTC"},
"enabled": true,
"created_at": "2025-03-25T10:00:00Z"
}Single plugin with version:
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/plugin" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Code Review Automation",
"plugins": [
{"source": "github:owner/code-review-plugin", "ref": "v2.0.0"}
],
"prompt": "Review all Python files in the repository for code quality issues",
"trigger": {"type": "cron", "schedule": "0 9 * * 1-5", "timezone": "UTC"}
}'Multiple plugins:
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/plugin" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Security Scan Automation",
"plugins": [
{"source": "github:owner/security-scanner"},
{"source": "github:owner/report-generator", "ref": "main"}
],
"prompt": "Run a security scan on the codebase and generate a report",
"trigger": {"type": "cron", "schedule": "0 2 * * 0", "timezone": "UTC"},
"timeout": 600
}'Monorepo plugin:
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/plugin" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Style Guide Enforcement",
"plugins": [
{"source": "github:company/monorepo", "repo_path": "plugins/style-guide", "ref": "main"}
],
"prompt": "Check all files against the company style guide",
"trigger": {"type": "cron", "schedule": "0 8 * * 1", "timezone": "America/Los_Angeles"}
}'Both presets support an optional repos field to clone repositories into the sandbox before execution. Cloned repos have their skills (AGENTS.md, .agents/skills/) automatically loaded.
| Format | Example | Description |
|---|---|---|
| Full URL | "https://github.com/owner/repo" | Provider auto-detected |
| Full URL + ref | {"url": "https://github.com/owner/repo", "ref": "main"} | With branch/tag/SHA |
| Short URL | {"url": "owner/repo", "provider": "github"} | Requires provider field |
Supported providers: github, gitlab, bitbucket
Note: Short URLs (
owner/repo) require an explicitproviderfield. Full URLs auto-detect the provider.
Single repo (full URL):
{
"repos": ["https://github.com/OpenHands/openhands-cli"]
}Multiple repos with refs:
{
"repos": [
{"url": "https://github.com/owner/repo1", "ref": "main"},
{"url": "https://gitlab.com/owner/repo2", "ref": "v1.0.0"}
]
}Short URL with provider:
{
"repos": [
{"url": "owner/repo", "provider": "github", "ref": "main"}
]
}curl -X POST "${OPENHANDS_HOST}/api/automation/v1/preset/prompt" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{
"name": "Analyze Codebase",
"prompt": "Analyze the openhands-cli codebase and generate a summary report",
"trigger": {"type": "cron", "schedule": "0 9 * * 1"},
"repos": [
{"url": "https://github.com/OpenHands/openhands-cli", "ref": "main"}
]
}'curl "${OPENHANDS_HOST}/api/automation/v1?limit=20" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}"# Get details
curl "${OPENHANDS_HOST}/api/automation/v1/{automation_id}" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}"
# Update (fields: name, trigger, enabled, timeout)
curl -X PATCH "${OPENHANDS_HOST}/api/automation/v1/{automation_id}" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}" \
-H "Content-Type: application/json" \
-d '{"enabled": false}'
# Delete
curl -X DELETE "${OPENHANDS_HOST}/api/automation/v1/{automation_id}" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}"# Manually trigger a run
curl -X POST "${OPENHANDS_HOST}/api/automation/v1/{automation_id}/dispatch" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}"
# List runs
curl "${OPENHANDS_HOST}/api/automation/v1/{automation_id}/runs?limit=20" \
-H "Authorization: Bearer ${OPENHANDS_API_KEY}"Run status values: PENDING (waiting for dispatch), RUNNING (in progress), COMPLETED (success), FAILED (check error_detail).
When a run completes, the automation service receives a callback and marks the run done. Any conversations started during the run remain accessible in the OpenHands UI — users can view the history and continue interacting. The agent server persists until it times out or is manually deleted.
The automation script itself controls when the callback fires (signalling completion). For simple synchronous scripts this happens naturally on exit. For scripts that start asynchronous conversations, the callback should be deferred until the conversation reaches an idle state (see references/custom-automation.md for patterns).
Pick based on what the task needs, not just what is technically possible. An LLM-driven preset can do almost anything, so "the preset can satisfy this" is not by itself a good reason to pick it — every run costs tokens and sandbox time.
| Use Case | Recommended |
|---|---|
| Reasoning, summarization, triage, code review, or open-ended tool use | Prompt Preset |
| Needs plugin commands / skills / MCP configs / hooks | Plugin Preset |
| Compare plugin versions or configurations across runs | Plugin Preset with A/B testing — see references/ab-testing.md |
| Deterministic task (fixed data + scheduled action, e.g. healthcheck, Slack notification, rotating from a known list) — especially if it runs frequently | Custom script, no LLM — see references/custom-automation.md#deterministic-script-no-llm |
| Custom Python dependencies, multi-file project, or direct SDK lifecycle control | Custom script with SDK — see references/custom-automation.md#sdk-based-scripts |
The prompt preset is the right default for genuinely agent-shaped work — anything that benefits from reasoning over context, calling tools dynamically, or producing a non-templated output. Use the plugin preset when you need extended capabilities from plugins (skills, MCP configurations, hooks, commands).
Watch for deterministic, high-frequency patterns. Requests like "send a daily standup reminder", "ping a healthcheck URL every minute", "post a random quote every 5 minutes", or "rotate a fact-of-the-day message" do not need an LLM. Surface this to the user explicitly with a rough cost framing (e.g. "this schedule will invoke your LLM ~288 times/day") before defaulting to a preset. As a rule of thumb, any cron tighter than hourly deserves a deliberate "should this really be agent-driven?" check.
When neither preset is the right fit (deterministic task, custom Python dependencies, non-Python entrypoint, multi-file project structure, direct SDK lifecycle control), explain the options and let the user decide, exactly as for any other automation. If they choose the custom route, follow references/custom-automation.md and the Custom Script Example (No LLM) above.
Automations run agents with real tool access against real secrets, often triggered by content anyone can produce — a GitHub issue, a PR comment, a Slack message.
See references/security.md — also covers narrowing triggers and sender-level authorization.
references/custom-automation.md — Detailed guide for custom automations: tarball uploads, code structure (SDK and no-LLM), state persistence via the KV store, environment variables, validation rules, and complete examples. Consult this whenever you need to evaluate, recommend, or build the custom path (including for deterministic / cost-sensitive tasks per rule 0).references/ab-testing.md — A/B testing for plugin automations: defining variants with weights, experiment configuration, variant selection logic, observability via conversation tags, and complete examples. Consult this when a user wants to compare plugin versions or configurations.references/security.md — Trust boundaries for automations: untrusted event content vs. verified sender, least-privilege secret scoping for spawned conversations, narrowing triggers, sender-level authorization, and verifying a script actually runs before deploying it. Consult this whenever an automation handles external/untrusted input (GitHub issues/PRs, Slack messages, any public-facing webhook) or forwards secrets to a spawned conversation.© OpenHands, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
SKILL.md and 9 other files (references) in skills/openhands-automation of OpenHands/extensions.
Open the folder on GitHubat commit d008b81
Openhands Automation next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Openhands Automation this skillOpenHands/extensions | 158 | — | ~12k | Automated safety check: Pass | MIT | |
| OpenObserve PR Briefopenobserve/openobserve | 22k | — | ~1.8k | Automated safety check: Pass | AGPL-3.0 | |
| Chat SDKdatabuddy-analytics/Databuddy | 1.2k | — | ~2.6k | Automated safety check: Pass | AGPL-3.0 | |
| Superset Automatesuperset-sh/superset | 15k | — | ~1.4k | Automated safety check: Pass | Custom licence | |
| RoutinesYesterday-AI/paperclip-plugin-company-wizard | 184 | — | ~2.1k | Automated safety check: Pass | MIT | |
| Aeon Agent Setup and Managementaeonfun/aeon | 767 | — | ~9k | Automated safety check: Warn | MIT |
openobserve/openobserve
Produces a read-only morning brief of your open pull requests across the openobserve GitHub org, with a next step for each and a reminder for idle ones.
databuddy-analytics/Databuddy
Build multi-platform chat bots with Chat SDK (chat npm package).
superset-sh/superset
Turns a recurring chore into a scheduled or event-triggered Superset agent, drafting its prompt, picking a target and trigger, and reviewing the first run.
Yesterday-AI/paperclip-plugin-company-wizard
Set up and manage Paperclip Routines — recurring scheduled tasks that replace expensive always-on heartbeats.
aeonfun/aeon
Sets up and manages an Aeon agent instance that runs skills on a schedule through GitHub Actions: starting, rescheduling, debugging, editing skills and mining chat history.
Yesterday-AI/paperclip-plugin-company-wizard
Analyze a Paperclip company's issue history, agent health, recurring failure patterns, and project architecture to design and provision tailored routines with cron/webhook triggers.
OpenHands/extensions
Interact with GitHub repositories, pull requests, issues, and workflows using the GITHUBTOKEN environment variable and GitHub CLI.
OpenHands/extensions
Evaluate how well a codebase supports autonomous AI-assisted development.
OpenHands/extensions
Build and automate Discord integrations (bots, webhooks, slash commands, and REST API workflows).
OpenHands/extensions
Create an automation that implements GitHub issues when a configurable trigger label is applied.
OpenHands/extensions
This skill should be used when the user asks to "monitor a GitHub repository", "watch GitHub for issues or PRs", "respond to @OpenHands mentions on GitHub", "set up an OpenHands GitHub integration"…
OpenHands/extensions
Create an automation that implements GitLab issues when a configurable trigger label is applied.
Works with
Categories
This skill should be used when the user asks to "create an automation", "schedule a task", "set up a cron job", "webhook integration", "event-triggered automation", or mentions automations…. Openhands Automation is an agent skill from OpenHands/extensions. This skill should be used when the user asks to "create an automation", "schedule a task", "set up a cron job", "webhook integration", "event-triggered automation", or mentions automations, scheduled tasks, cron scheduling, or webhook events in OpenHands Cloud.
Openhands Automation fits situations like: asks to create an automation; schedule a task; set up a cron job; webhook integration.
Run `npx skills add OpenHands/extensions --skill openhands-automation -a claude-code`. Or copy the skill folder (skills/openhands-automation in OpenHands/extensions) into .claude/skills/openhands-automation in your project. Claude Code loads it when a task matches its description.
Run `npx skills add OpenHands/extensions --skill openhands-automation -a codex`. Or copy the skill folder (skills/openhands-automation in OpenHands/extensions) into .agents/skills/openhands-automation in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add OpenHands/extensions --skill openhands-automation -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/openhands-automation, .gemini/skills/openhands-automation, .github/skills/openhands-automation and .opencode/skills/openhands-automation in your project.
Going by SKILL.md and its folder, Openhands Automation needs the command-line tools its instructions call (curl, jq and python3) and credentials named OPENHANDS_API_KEY, SESSION_API_KEY, AUTOMATION_KV_TOKEN and OPENHANDS_AUTOMATION_API_KEY. Our summary lists: Python 3; Docker; A credential in SESSION_API_KEY; A credential in AUTOMATION_CALLBACK_API_KEY.
SKILL.md names 3 domains. In commands or code: github.com, slack.com and gitlab.com; the agent is likely to contact these when it follows the instructions. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
Openhands Automation is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 12k tokens (SKILL.md is roughly 49k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 12k tokens, read only when the agent opens those files.
Skills that share tags, products or a category with Openhands Automation: OpenObserve PR Brief (openobserve/openobserve, 22k stars), Chat SDK (databuddy-analytics/Databuddy, 1.2k stars), Superset Automate (superset-sh/superset, 15k stars) and Routines (Yesterday-AI/paperclip-plugin-company-wizard, 184 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
OpenHands (a GitHub organization) maintains it in OpenHands/extensions, which has 158 GitHub stars. The repository holds 78 skills in this directory. The repository was last updated on October 7, 2026.
Source: OpenHands/extensions on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.