Agent integration

Quickstart

Claude edits Hero.tsx. Cursor starts from stale context and tries to edit the same file. Availsync gives the second agent skip_run before it overwrites the first change.

Start with npx @availsync/setup, then let each integrated agent check in before it acts.

Start free Read SDK docs Pilot in 10 minutes

Stop two coding agents from working on the same repo

Each agent checks and claims owner/repo before it starts. If another claim is active, the next run skips with a clear reason instead of touching the same files.

Coordinate server automations before they run

Deploys, migrations, review passes, cron jobs, and cleanup scripts can use the same repo claims as coding agents.

Also coordinate scheduling tools before they book

Scheduling agents can check availability, preview conflicts, create holds, and release them through the same priority and audit layer.

Production flow

Long-running coding agents

Run the dashboard setup test from Agent Connect.

For a no-risk pilot, switch the agent to Observe before connecting real automations.

Use repo-level scope by default: resource_type=repo and resource_key=owner/repo.

Run npx @availsync/setup, or use claude mcp add directly for Claude Code.

Reload Claude, Codex, Cursor, or Windsurf and confirm Availsync MCP tools are visible.

Verify real heartbeat and runtime calls in Activity.

Use run/start, run/extend, and run/finish for scheduled automations, or MCP tools for interactive agent clients.

Resource scope

Start safe, then split only independent work

Safe mode

Use repo-level claims when agents may touch shared files or shared context.

"resource_type": "repo",
"resource_key": "owner/repo"

Advanced mode

Use project-level claims only when work streams are independent during the same run.

"resource_type": "project",
"resource_key": "homepage"

Availsync blocks conflicts on the same resource. It does not yet infer that project:homepage depends on project:product-catalog, so use repo-level scope when stale context or shared files would be risky.

Node SDK

Use the SDK for pilots and production automations

Install the public package with npm install @availsync/node. The SDK wraps run/start, run/extend, and run/finish so your coding agent can skip cleanly when another agent owns the repo and always release the claim when work ends.

Basic guarded run

Use the SDK helper when your app should run work only after Availsync claims the repo.

import { createAvailsyncClient } from '@availsync/node';

const availsync = createAvailsyncClient({
  apiKey: process.env.AVAILSYNC_API_KEY!,
  agentId: process.env.AVAILSYNC_AGENT_ID!,
  baseUrl: process.env.AVAILSYNC_API_URL,
});

const result = await availsync.work.withClaim(
  'repo:owner/repo',
  {
    reason: 'coding-agent run',
    durationMinutes: 45,
    autoExtendIntervalMs: (45 - 5) * 60_000,
    autoExtendDurationMinutes: 45,
    autoExtendWorkingSet: {
      resource: 'repo:owner/repo',
      mode: 'edit',
      paths: ['frontend/components/Hero.tsx', 'frontend/app/page.tsx'],
      leaseSeconds: 600,
    },
  },
  async ({ claim, shadow }) => {
    if (shadow.wouldHaveBlocked) {
      console.warn('Observe-only: Availsync would have skipped this run.');
    }
    await claim?.updateWorkingSet({
      resource: 'repo:owner/repo',
      mode: 'edit',
      paths: ['frontend/components/Hero.tsx', 'frontend/app/page.tsx'],
      leaseSeconds: 600,
    });
    await doWork();
  },
);

if (result.action === 'skip_run') {
  console.log(result.reason);
}

Scheduled Codex run

Wrap a scheduled Codex task so it exits cleanly when another agent owns the repo.

import { createAvailsyncClient } from '@availsync/node';
import { spawn } from 'node:child_process';
import { once } from 'node:events';

const availsync = createAvailsyncClient({
  apiKey: process.env.AVAILSYNC_API_KEY!,
  agentId: 'AGENT_ID',
  baseUrl: process.env.AVAILSYNC_API_URL,
});

const result = await availsync.work.withClaim(
  'repo:owner/repo',
  {
    reason: 'scheduled Codex automation',
    durationMinutes: 45,
    idempotencyKey: `codex-owner-repo-${new Date().toISOString().slice(0, 13)}`,
  },
  async ({ shadow }) => {
    if (shadow.wouldHaveBlocked) {
      console.warn('Observe-only: Availsync would have skipped this Codex run.');
    }
    const child = spawn('codex', ['exec', 'run the scheduled maintenance task'], { stdio: 'inherit' });
    const [code] = await once(child, 'exit');
    if (code !== 0) throw new Error(`codex exited with ${code}`);
  },
);

if (result.action === 'skip_run') process.exit(0);

GitHub Actions step

Install the SDK in your automation project and use GitHub run id as the idempotency key.

- name: Run guarded agent task
  env:
    AVAILSYNC_API_KEY: ${{ secrets.AVAILSYNC_API_KEY }}
    AVAILSYNC_AGENT_ID: AGENT_ID
    AVAILSYNC_API_URL: https://availsync.dev
  run: |
    npm install @availsync/node
    node ./scripts/guarded-agent-run.mjs

# scripts/guarded-agent-run.mjs
import { createAvailsyncClient } from '@availsync/node';

const availsync = createAvailsyncClient({
  apiKey: process.env.AVAILSYNC_API_KEY,
  agentId: process.env.AVAILSYNC_AGENT_ID,
  baseUrl: process.env.AVAILSYNC_API_URL,
});

const result = await availsync.work.withClaim(
  'repo:owner/repo',
  {
    reason: 'GitHub Actions coding automation',
    idempotencyKey: `github-${process.env.GITHUB_RUN_ID}`,
    durationMinutes: 45,
    autoExtendIntervalMs: (45 - 5) * 60_000,
    autoExtendDurationMinutes: 45,
  },
  async ({ shadow }) => {
    if (shadow.wouldHaveBlocked) {
      console.warn('Observe-only: Availsync would have skipped this run.');
    }
    // Run the coding agent command here.
  },
);

if (result.action === 'skip_run') process.exit(0);

Manual long-running flow

Use start, extend, and finish directly when you need more control than withClaim.

const started = await availsync.work.start({
  resource: 'repo:owner/repo',
  reason: 'long-running agent run',
  durationMinutes: 45,
  idempotencyKey: `agent-owner-repo-${Date.now()}`,
});

if (started.action === 'skip_run') {
  console.log(started.reason);
  process.exit(0);
}

if (started.shadow_mode && started.would_have_blocked) {
  console.warn('Observe-only: Availsync would have skipped this run.');
}

let outcome = 'finished';
try {
  if (started.claim) {
    // Extend before expiry while the long-running task is still active.
    await availsync.work.extend(started.claim.id, { durationMinutes: 45 });
  }
  await doWork();
} catch (error) {
  outcome = 'error';
  throw error;
} finally {
  if (started.claim) {
    await availsync.work.finish(started.claim.id, { outcome });
  }
}

Python

Use REST directly from Python

A Python SDK is not published yet. For Airflow, Prefect, Dagster, FastAPI workers, or cron scripts, call the run API directly and fail closed if Availsync is unavailable in enforce mode.

Python guarded run

Start a repo claim, skip cleanly when blocked, and finish the claim in finally.

import os
import requests

api_url = "https://availsync.dev"
api_key = os.environ["AVAILSYNC_API_KEY"]
agent_id = os.environ["AVAILSYNC_AGENT_ID"]

response = requests.post(
    f"{api_url}/v1/work/run/start",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Idempotency-Key": "python-owner-repo-run-001",
    },
    json={
        "agent_id": agent_id,
        "resource_type": "repo",
        "resource_key": "owner/repo",
        "duration_minutes": 45,
        "reason": "Python guarded automation",
    },
    timeout=10,
)
response.raise_for_status()
started = response.json()

if started["action"] == "skip_run":
    print(started["reason"])
    raise SystemExit(0)

claim = started.get("claim")
try:
    # Run the Python automation here.
    pass
finally:
    if claim:
        requests.post(
            f"{api_url}/v1/work/run/finish",
            headers={"Authorization": f"Bearer {api_key}"},
            json={"claim_id": claim["id"], "outcome": "finished"},
            timeout=10,
        ).raise_for_status()

Observe-only pilot

See what Availsync would block before enforcing it

Enforce

Availsync creates a lease and returns skip_run when another active claim owns the same repo or project.

Observe

Availsync lets the automation proceed, creates no lease, and records whether it would have blocked the run.

Observe mode currently applies to the Node SDK, MCP work tools, and direct calls to /v1/work/run/start. Use Observe for the first pilot week, then switch high-value agents to Enforce once the dashboard shows useful would-have-blocked signals.

Copy-paste examples

One-command MCP setup first

Local Codex, Cursor, and Windsurf users should start with npx @availsync/setup. Claude Code users can either let setup print the native command or run claude mcp add directly. Manual MCP config with npx -y @availsync/mcp stays available when you need exact control.

Recommended: one-command setup

Run this once after creating an agent. It configures Codex, Cursor, and Windsurf directly, and prints the safe Claude Code command when selected.

npx @availsync/setup --agent-id AGENT_ID --api-url https://availsync.dev

Non-interactive setup

Use this from a shell where AVAILSYNC_API_KEY is already exported. Claude Code still receives a command to run explicitly.

npx @availsync/setup \
  --agent-id AGENT_ID \
  --api-url https://availsync.dev \
  --tools claude,codex,cursor,windsurf \
  --yes

Claude Code fast path

Claude Code users can add Availsync directly with the official mcp add flow.

claude mcp add --transport stdio \
  --env AVAILSYNC_API_URL=https://availsync.dev \
  --env AVAILSYNC_AGENT_ID=AGENT_ID \
  --env AVAILSYNC_API_KEY=API_KEY \
  availsync -- npx -y @availsync/mcp

MCP environment

Store these values in your MCP or server environment. The API key is a runtime secret.

AVAILSYNC_API_URL=https://availsync.dev
AVAILSYNC_AGENT_ID=AGENT_ID
AVAILSYNC_API_KEY=API_KEY

Claude or Cursor MCP config

Use the public stdio MCP package with environment variables. Replace API_KEY in your local secret store.

{
  "mcpServers": {
    "availsync": {
      "command": "npx",
      "args": ["-y", "@availsync/mcp"],
      "env": {
        "AVAILSYNC_API_URL": "https://availsync.dev",
        "AVAILSYNC_AGENT_ID": "AGENT_ID",
        "AVAILSYNC_API_KEY": "API_KEY"
      }
    }
  }
}

Codex app MCP server fields

In Codex, open Settings -> MCP servers -> Add server, then fill the fields below. Keep API_KEY as a secret value from create or rotate key.

Name
Availsync

Command
npx

Arguments
-y @availsync/mcp

Transport
stdio

Working directory
Leave empty

Environment variables
AVAILSYNC_API_URL=https://availsync.dev
AVAILSYNC_AGENT_ID=AGENT_ID
AVAILSYNC_API_KEY=API_KEY

Multiple Codex sessions or roles

Use one MCP server entry per Availsync agent when you want role-specific priorities, for example builder and reviewer. The setup CLI writes the OS-specific command shape; this example uses POSIX npx.

[mcp_servers.availsync_builder]
command = "npx"
args = ["-y", "@availsync/mcp"]
enabled = true

[mcp_servers.availsync_builder.env]
AVAILSYNC_API_URL = "https://availsync.dev"
AVAILSYNC_AGENT_ID = "BUILDER_AGENT_ID"
AVAILSYNC_API_KEY = "BUILDER_API_KEY"

[mcp_servers.availsync_reviewer]
command = "npx"
args = ["-y", "@availsync/mcp"]
enabled = true

[mcp_servers.availsync_reviewer.env]
AVAILSYNC_API_URL = "https://availsync.dev"
AVAILSYNC_AGENT_ID = "REVIEWER_AGENT_ID"
AVAILSYNC_API_KEY = "REVIEWER_API_KEY"

Shell guardrail wrapper

Use run/start before work and always call run/finish from a trap when a claim was created. Use repo-level resources for maximum safety. Use project-level resources only for independent work streams; Availsync does not yet infer dependencies between different resources.

#!/usr/bin/env bash
set -euo pipefail

API_URL="https://availsync.dev"
AGENT_ID="AGENT_ID"
RESOURCE_TYPE="repo"
RESOURCE_KEY="owner/repo"
IDEMPOTENCY_KEY="automation-owner-repo-$(date +%Y%m%d%H)"
CLAIM_ID=""

finish_claim() {
  if [ -n "$CLAIM_ID" ]; then
    curl -fsS -X POST "$API_URL/v1/work/run/finish" \
      -H "Authorization: Bearer $AVAILSYNC_API_KEY" \
      -H "Content-Type: application/json" \
      -d "{\"claim_id\":\"$CLAIM_ID\",\"outcome\":\"finished\"}" >/dev/null || true
  fi
}
trap finish_claim EXIT

START_RESPONSE=$(curl -fsS -X POST "$API_URL/v1/work/run/start" \
  -H "Authorization: Bearer $AVAILSYNC_API_KEY" \
  -H "Idempotency-Key: $IDEMPOTENCY_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"agent_id\":\"$AGENT_ID\",\"resource_type\":\"$RESOURCE_TYPE\",\"resource_key\":\"$RESOURCE_KEY\",\"duration_minutes\":45,\"reason\":\"scheduled coding automation\"}")

ACTION=$(node -e "const r=JSON.parse(process.argv[1]); console.log(r.action)" "$START_RESPONSE")
if [ "$ACTION" = "skip_run" ]; then
  node -e "const r=JSON.parse(process.argv[1]); console.log(r.reason)" "$START_RESPONSE"
  exit 0
fi

CLAIM_ID=$(node -e "const r=JSON.parse(process.argv[1]); console.log(r.claim?.id || '')" "$START_RESPONSE")

# Run the coding agent command here.
# codex exec "...your task..."

GitHub Actions step

Put Availsync secrets in repository or organization secrets and skip cleanly when another agent owns the repo.

- name: Start Availsync guarded run
  id: availsync
  env:
    AVAILSYNC_API_KEY: ${{ secrets.AVAILSYNC_API_KEY }}
  run: |
    RESPONSE=$(curl -fsS -X POST "https://availsync.dev/v1/work/run/start" \
      -H "Authorization: Bearer $AVAILSYNC_API_KEY" \
      -H "Idempotency-Key: github-${{ github.run_id }}" \
      -H "Content-Type: application/json" \
      -d '{"agent_id":"AGENT_ID","resource_type":"repo","resource_key":"owner/repo","duration_minutes":45,"reason":"GitHub Actions coding automation"}')
    echo "action=$(node -e 'const r=JSON.parse(process.argv[1]); console.log(r.action)' "$RESPONSE")" >> "$GITHUB_OUTPUT"
    echo "claim_id=$(node -e 'const r=JSON.parse(process.argv[1]); console.log(r.claim?.id || "")' "$RESPONSE")" >> "$GITHUB_OUTPUT"

- name: Finish Availsync guarded run
  if: always() && steps.availsync.outputs.claim_id != ''
  env:
    AVAILSYNC_API_KEY: ${{ secrets.AVAILSYNC_API_KEY }}
  run: |
    curl -fsS -X POST "https://availsync.dev/v1/work/run/finish" \
      -H "Authorization: Bearer $AVAILSYNC_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"claim_id":"${{ steps.availsync.outputs.claim_id }}","outcome":"finished"}'

Codex automation prompt

Use this in a scheduled Codex run so the agent respects the shared repo claim before editing.

Before changing files, start an Availsync guarded run.

Use:
- API URL: https://availsync.dev
- Agent ID: AGENT_ID
- Resource: repo:owner/repo

Resource scope:
- Safe default: repo:owner/repo means one active agent can work in the repo.
- Advanced: project:homepage allows parallel work only when it does not depend on other active project work.

Call POST /v1/work/run/start with an Idempotency-Key for this run.
If action is "skip_run", stop and report the reason.
If action is "proceed", keep the claim id, extend with /v1/work/run/extend if work continues near expiry, and always call /v1/work/run/finish before ending.

Server worker flow

Use this shape in cron, queue workers, deploy bots, or hosted scheduled jobs.

POST https://availsync.dev/v1/work/run/start
Authorization: Bearer API_KEY
Idempotency-Key: worker-owner-repo-RUN_ID

{
  "agent_id": "AGENT_ID",
  "resource_type": "repo",
  "resource_key": "owner/repo",
  "duration_minutes": 45,
  "reason": "server-side automation"
}

If action === "skip_run": exit 0 with reason.
If action === "proceed": run work, call /v1/work/run/extend while active, then /v1/work/run/finish in finally.

OpenClaw SKILL.md

Install this as an OpenClaw skill so the agent claims the repo before it edits files.

---
name: availsync-guardrail
description: Use before coding, repo edits, scheduled automations, deploy work, migrations, or other agent work that must not overlap with another agent. Coordinates through Availsync work run endpoints and prevents the agent from touching the same selected resource while another claim is active.
---

# Availsync Guardrail

Use Availsync before changing files, running deploys, editing a repo, or starting long-running project work.

## Required environment

- AVAILSYNC_API_URL: https://availsync.dev
- AVAILSYNC_AGENT_ID: AGENT_ID
- AVAILSYNC_API_KEY: runtime secret, never write it into files or chat
- AVAILSYNC_RESOURCE_TYPE: repo
- AVAILSYNC_RESOURCE_KEY: owner/repo

## Resource scope

Use AVAILSYNC_RESOURCE_TYPE=repo and AVAILSYNC_RESOURCE_KEY=owner/repo for maximum safety. That allows only one active agent in the repo.

Use project-level resources only for independent work streams. Availsync does not yet infer that project:homepage depends on project:product-catalog.

## Workflow

1. Before making changes, call POST /v1/work/run/start.
2. Send Authorization: Bearer $AVAILSYNC_API_KEY and an Idempotency-Key for the current run.
3. Include client_name: "openclaw" in the JSON body.
4. If response action is "skip_run", stop immediately and report the reason. Do not edit files.
5. If response action is "proceed", keep the claim id and do the requested work.
6. If work continues near expires_at, call POST /v1/work/run/extend with the claim id.
7. Always call POST /v1/work/run/finish before ending, including after errors or no-op runs.

## Start request

curl -fsS -X POST "$AVAILSYNC_API_URL/v1/work/run/start" \
  -H "Authorization: Bearer $AVAILSYNC_API_KEY" \
  -H "Idempotency-Key: openclaw-$(date +%Y%m%d%H%M%S)" \
  -H "Content-Type: application/json" \
  -d '{"agent_id":"'$AVAILSYNC_AGENT_ID'","resource_type":"'$AVAILSYNC_RESOURCE_TYPE'","resource_key":"'$AVAILSYNC_RESOURCE_KEY'","duration_minutes":45,"reason":"OpenClaw guarded run","client_name":"openclaw"}'

## Finish request

curl -fsS -X POST "$AVAILSYNC_API_URL/v1/work/run/finish" \
  -H "Authorization: Bearer $AVAILSYNC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"claim_id":"CLAIM_ID","outcome":"finished","client_name":"openclaw"}'

## Failure policy

If Availsync is unreachable, authentication fails, or the start response cannot be parsed, stop without editing files. Never continue unguarded.

OpenClaw setup

Create the skill folder, paste SKILL.md, and keep secrets in environment variables.

mkdir -p ~/.openclaw/skills/availsync-guardrail
$EDITOR ~/.openclaw/skills/availsync-guardrail/SKILL.md

export AVAILSYNC_API_URL="https://availsync.dev"
export AVAILSYNC_AGENT_ID="AGENT_ID"
export AVAILSYNC_API_KEY="API_KEY"
export AVAILSYNC_RESOURCE_TYPE="repo"
export AVAILSYNC_RESOURCE_KEY="owner/repo"

# Resource scope:
# - repo + owner/repo is the safest default: one active agent per repo.
# - project + homepage allows parallel work only when streams are independent.
# - Availsync does not yet infer dependencies between different resources.

# Test after installing:
# 1. Ask OpenClaw to use Availsync before editing this repo.
# 2. Confirm Activity shows client "openclaw".
# 3. Confirm blocked runs stop with skip_run instead of editing files.

Check work slot

Call this before a coding agent starts. Default to repo-level scope unless the work stream is independent. Use repo-level resources for maximum safety. Use project-level resources only for independent work streams; Availsync does not yet infer dependencies between different resources.

curl -X POST "https://availsync.dev/v1/work/check" \
  -H "Authorization: Bearer API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"agent_id":"AGENT_ID","resource_type":"repo","resource_key":"owner/repo","duration_minutes":45,"reason":"pre-flight coding run"}'

Start guarded run

Use run/start for new automations. It returns action: proceed or skip_run and supports observe mode.

curl -X POST "https://availsync.dev/v1/work/run/start" \
  -H "Authorization: Bearer API_KEY" \
  -H "Idempotency-Key: coding-run-owner-repo-$(date +%Y%m%d%H)" \
  -H "Content-Type: application/json" \
  -d '{"agent_id":"AGENT_ID","resource_type":"repo","resource_key":"owner/repo","duration_minutes":45,"reason":"coding agent run"}'

Extend while running

Call this before expires_at if the agent is still working.

curl -X POST "https://availsync.dev/v1/work/run/extend" \
  -H "Authorization: Bearer API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"claim_id":"CLAIM_ID","duration_minutes":45}'

Release when done

Always release the claim when the agent finishes or exits cleanly.

curl -X POST "https://availsync.dev/v1/work/run/finish" \
  -H "Authorization: Bearer API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"claim_id":"CLAIM_ID","outcome":"finished"}'

Check availability

Ask Availsync for open slots before touching a calendar or downstream booking tool.

curl "https://availsync.dev/v1/availability?agent_id=AGENT_ID&from=NEXT_BUSINESS_DAY_START&to=NEXT_BUSINESS_DAY_END&duration_minutes=30" \
  -H "Authorization: Bearer API_KEY"

Preview conflict

Preview the decision and explanation before creating a hold.

curl -X POST "https://availsync.dev/v1/conflicts/check" \
  -H "Authorization: Bearer API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"agent_id":"AGENT_ID","start_at":"NEXT_BUSINESS_DAY_START","end_at":"NEXT_BUSINESS_DAY_SLOT_END","reason":"demo booking"}'

Create hold

Create a hold only after availability and conflict preview pass.

curl -X POST "https://availsync.dev/v1/holds" \
  -H "Authorization: Bearer API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"agent_id":"AGENT_ID","start_at":"NEXT_BUSINESS_DAY_START","end_at":"NEXT_BUSINESS_DAY_SLOT_END","reason":"demo booking"}'

Codex automation prompt

Paste this into a scheduled coding-agent run so it respects Availsync before editing.

Before changing files, use Availsync.

Agent id: AGENT_ID
Protected repo: owner/repo

Resource scope:
- Safe default: claim repo:owner/repo so only one active agent can work in the repo.
- Advanced: use project-level resources only when work streams are independent.

1. Call guard_work_run for owner/repo before editing files. Include the first paths if you already know them.
2. If the response is skip_run or blocked, stop and report the blocking claim.
3. If the response is proceed with a real claim, keep the claim_id for extend and release calls.
4. While working, call extend_work_slot before expires_at if more time is needed.
5. Before continuing edits on a new or changed file set, call update_working_set with the current paths and stop if it returns blocked.
6. Call release_work_slot when finished, even if the run failed or no code changes were made.

Server or cron pre-flight

Use run/start in scheduled jobs so blocked runs skip cleanly instead of failing the job.

#!/usr/bin/env bash
set -euo pipefail

API_URL="https://availsync.dev"
AGENT_ID="AGENT_ID"
RESOURCE_TYPE="repo"
RESOURCE_KEY="owner/repo"
CLAIM_ID=""

finish_claim() {
  if [ -n "$CLAIM_ID" ]; then
    curl -fsS -X POST "$API_URL/v1/work/run/finish" \
      -H "Authorization: Bearer $AVAILSYNC_API_KEY" \
      -H "Content-Type: application/json" \
      -d "{\"claim_id\":\"$CLAIM_ID\",\"outcome\":\"finished\"}" >/dev/null || true
  fi
}
trap finish_claim EXIT

START_RESPONSE=$(curl -fsS -X POST "$API_URL/v1/work/run/start" \
  -H "Authorization: Bearer $AVAILSYNC_API_KEY" \
  -H "Idempotency-Key: cron-owner-repo-$(date +%Y%m%d%H)" \
  -H "Content-Type: application/json" \
  -d "{\"agent_id\":\"$AGENT_ID\",\"resource_type\":\"$RESOURCE_TYPE\",\"resource_key\":\"$RESOURCE_KEY\",\"duration_minutes\":45,\"reason\":\"cron guarded run\"}")

ACTION=$(node -e "const r=JSON.parse(process.argv[1]); console.log(r.action)" "$START_RESPONSE")
if [ "$ACTION" = "skip_run" ]; then
  node -e "const r=JSON.parse(process.argv[1]); console.log(r.reason)" "$START_RESPONSE"
  exit 0
fi

# Observe mode returns proceed with no active claim.
CLAIM_ID=$(node -e "const r=JSON.parse(process.argv[1]); console.log(r.claim?.id || '')" "$START_RESPONSE")

# Run the scheduled job here.

Roadmap

What comes next

The current pilot path is the Node SDK, public MCP package, REST, or the OpenClaw SKILL.md workflow. These work with Codex, Claude, Cursor, MCP clients, server jobs, scheduled automations, and scheduling agents.

Next priorities are webhooks, Python SDK, team roles, and a dedicated Codex plugin come after the core integration path is proven.