Skip to content
Skills Library
AI & agents · Automation

agent-admin

/agent-admin

Query and manage Shipwright agents via the admin API — cron jobs, env vars, tool permissions, API tokens, and plugins. Use to configure the running agent, manage its schedules, inspect another agent's config, or provision a new agent.

Repository
shipwright ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

95/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content30 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
1
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 1 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: agent-admin.content.test.ts

What it does and when to use it

Query and manage Shipwright agents via the admin API — cron jobs, env vars, tool permissions, API tokens, and plugins. Use to configure the running agent, manage its schedules, inspect another agent's config, or provision a new agent.

Original author description

Query and manage Shipwright agents via the admin API — cron jobs, env vars, tool permissions, API tokens, and plugins. Use to configure the running agent, manage its schedules, inspect another agent's config, or provision a new agent.

How it works

  1. Authentication
  2. Your Agent Identity
  3. Finding Other Agents
  4. Cron Jobs
  5. Env Vars
  6. Tool Permissions
  7. API Tokens
  8. Plugins
  9. Creating a New Agent (Admin Only)
  10. Metrics API
Original SKILL.md headings · 503 lines, 2,531 words
SKILL.md preview
---
name: agent-admin
description: >
  Query and manage Shipwright agents via the admin API — cron jobs, env vars, tool permissions,
  API tokens, and plugins. Use to configure the running agent, manage its schedules, inspect
  another agent's config, or provision a new agent.
---

# Shipwright Agent Admin — Skill

Use this skill to configure and manage Shipwright agents via the admin API. Covers cron jobs,
env vars, tool permissions, API tokens, and plugins for any agent — including yourself.

**Scope boundary:** For delivery pipeline work (planning, code tasks, reviews, deploys) use the
task-store, dev-task, review, or deploy skills. This skill is for agent lifecycle management only.

---

## Authentication

All calls require a Bearer token:

```bash
Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY
```

Your key and base URL are in the agent env:

```bash
echo $SHIPWRIGHT_API_URL        # base URL for the admin API
echo $SHIPWRIGHT_AGENT_API_KEY  # your per-agent API key
echo $SHIPWRIGHT_AGENT_ID       # your own agent ID
```

Verify the service is reachable before doing anything:

```bash
curl -sf "$SHIPWRIGHT_API_URL/health"
```

**Creating new agents** is an admin-only operation — it requires an admin-level key
(`SHIPWRIGHT_ADMIN_API_KEYS` on the server side). All other operations work with the
per-agent API key.

---

## Your Agent Identity

```bash
# Inspect your full config bundle (env vars, crons, tools, plugins)
curl -sf -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/config" | jq .
```

## Finding Other Agents

To manage another agent (e.g. resolve a name like "warchild" to an ID), list all agents:

```bash
curl -sf -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents" | jq .
# Returns: [{ id, name, selfHosted }, ...]
```

**Admin-scoped keys only** — this 403s unless your `SHIPWRIGHT_AGENT_API_KEY` is registered
in `SHIPWRIGHT_ADMIN_API_KEYS` with `scope: "*"`. Most per-agent keys don't have this; check
with whoever manages the admin service if you get a 403.

---

## Cron Jobs

Crons drive autonomous operation. The agent syncs from the API every 60 seconds — changes
take effect without a restart.

### System crons vs. custom crons

System crons (`"system": true` in the list output) are seeded from the specialty manifest's
`crons` array (`specialties/{typeName}/manifest.yaml`, resolved via the `SpecialtyRegistry`).
Important rules:

- **Cannot be deleted via the API** — the server returns 403. They are recreated on the
  next `reconcile` call.
- **Can be enabled/disabled via `PATCH {"enabled": bool}`** — the enabled-only toggle works
  for both custom and system crons. The enabled state persists across reconcile calls.
- **Content updates go through code** — submit a PR to change the manifest's `crons` array
  (`specialties/{typeName}/manifest.yaml`), then call `POST .../crons/reconcile` to apply the
  new definition.

Custom crons (user-created, `"system": false`) can be freely created, updated, and deleted.

```bash
# List all crons for an agent
curl -sf -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/crons" | jq .

# Create a custom cron (posts to a Slack channel)
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/crons" \
  -d '{
    "schedule": "0 9 * * 1-5",
    "prompt": "Run the morning brief...",
    "channel": "C123456",
    "enabled": true
  }' | jq .

# Create a cron that DMs a user
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/crons" \
  -d '{
    "schedule": "0 20 * * 1-5",
    "prompt": "Evening check-in...",
    "user": "U0AALR8M69X",
    "enabled": true
  }' | jq .

# Create a silent cron with a preCheck script
# preCheck formats:
#   "plugin:script.ts"    — resolves to the named plugin's scripts/ dir
#   "./relative/path.ts"  — resolves relative to the agent's workspace root
#   "/absolute/path.ts"   — used as-is
# If preCheck exits 0 with output: that output becomes the prompt.
# If preCheck exits non-0 or produces no output: the tick is skipped entirely.
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/crons" \
  -d '{
    "schedule": "*/30 * * * *",
    "prompt": "/shipwright:dev-task",
    "silent": true,
    "preCheck": "shipwright:check-test-readiness.ts",
    "enabled": true
  }' | jq .

# Update a cron's content — schedule and prompt required together; enabled is optional
curl -sf -X PATCH \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/crons/{cronId}" \
  -d '{
    "schedule": "0 8 * * 1-5",
    "prompt": "Updated prompt text here",
    "channel": "C123456",
    "preCheck": "shipwright:check-docs-freshness.ts"
  }' | jq .

# Enable or disable any cron (custom or system) — enabled-only toggle
curl -sf -X PATCH \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/crons/{cronId}" \
  -d '{"enabled": false}' | jq .

# Set or clear preCheck without touching schedule/prompt — preCheck-only toggle
curl -sf -X PATCH \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/crons/{cronId}" \
  -d '{"preCheck": "shipwright:check-docs-freshness.ts"}' | jq .

# Clear preCheck (pass null)
curl -sf -X PATCH \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/crons/{cronId}" \
  -d '{"preCheck": null}' | jq .

# Update content and toggle enabled in one request
curl -sf -X PATCH \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/crons/{cronId}" \
  -d '{
    "schedule": "0 8 * * 1-5",
    "prompt": "Updated prompt text here",
    "enabled": true
  }' | jq .

# Delete a custom cron (system crons cannot be deleted — 403)
curl -sf -X DELETE \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/crons/{cronId}"

# Reconcile system crons — re-seeds from the specialty manifest, preserving per-agent enabled state
# Run after a shipwright plugin update that changes system cron definitions
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/crons/reconcile" | jq .
# Returns: { "created": N, "updated": N, "deleted": N }
```

**Cron field reference:**

| Field | Required | Description |
|---|---|---|
| `schedule` | Yes | 5-field cron expression (`* * * * *`) |
| `prompt` | Yes | Prompt sent to Claude (fallback when preCheck is set) |
| `channel` | One of† | Slack channel ID for output |
| `user` | One of† | Slack user ID (posts as DM) |
| `silent` | No | `true` = run Claude but post nothing to Slack |
| `enabled` | No | Default `true`. Patchable via enabled-only or full-content PATCH |
| `preCheck` | No | Script — stdout becomes the live prompt; non-0 exit skips the tick |
| `name` | No | Human-readable label (required for system crons) |

† `channel` and `user` are mutually exclusive. At least one is required unless `silent: true`.

---

## Env Vars

Env vars are encrypted at rest. The agent's config-sync loop picks up changes every 60 seconds
— no restart needed.

```bash
# Get all env vars (decrypted)
curl -sf -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/envs" | jq .

# Replace all env vars (bulk POST — overwrites every existing key)
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/envs" \
  -d '{"SLACK_BOT_TOKEN": "xoxb-...", "GH_TOKEN": "ghp_..."}' | jq .

# Merge — update specific keys, leave unmentioned keys unchanged
# Note: unlike POST, the PATCH body wraps keys under "env" — a flat body 400s with "env: Required"
curl -sf -X PATCH \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/envs" \
  -d '{"env": {"GH_TOKEN": "ghp_new_token"}}' | jq .

# Merge and flag a key as secret (masked in future GETs) — secretKeys is optional
curl -sf -X PATCH \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/envs" \
  -d '{"env": {"GH_TOKEN": "ghp_new_token"}, "secretKeys": ["GH_TOKEN"]}' | jq .

# Delete a single key
curl -sf -X DELETE \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/envs/GH_TOKEN"
```

---

## Tool Permissions

Tool patterns control which Claude Code tools the agent can invoke.

```bash
# List tool patterns
curl -sf -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/tools" | jq .

# Add a tool pattern
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/tools" \
  -d '{"pattern": "Bash(git *)"}' | jq .

# Enable or disable a tool pattern (by toolId from the list)
curl -sf -X PATCH \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/tools/{toolId}" \
  -d '{"enabled": false}' | jq .

# Remove a tool pattern
curl -sf -X DELETE \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/tools/{toolId}"
```

---

## API Tokens

Per-agent tokens for service-to-service or CI calls. The raw token value is returned only
once at creation time — store it immediately.

```bash
# List tokens (metadata only — the stored hash is never returned)
curl -sf -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/tokens" | jq .

# Create a token — save rawToken from the response immediately
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/tokens" \
  -d '{"label": "ci-runner"}' | jq .
# Returns: { token: { id, agentId, label, createdAt }, rawToken: "sw_..." }

# Revoke a token
curl -sf -X DELETE \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/tokens/{tokenId}"
```

---

## Plugins

Plugins installed on the agent determine which skills and commands are available.

**`name` is the canonical Claude install spec** — exactly the string you'd pass to
`claude plugin install`:

- `"<plugin>@<marketplace>"` for a marketplace-scoped plugin (e.g. `"shipwright@shipwright"`,
  `"my-plugin@my-marketplace"`). The config bundle splits on the first `@`, and the harness
  reassembles `<plugin>@<marketplace>` to install it.
- A bare `"<plugin>"` defaults to the bundled `shipwright` marketplace.

Do **not** use an npm-scoped form like `@my-marketplace/my-plugin` — `claude plugin install`
does not accept scoped plugin identifiers, and the agent would fail to install it.

```bash
# List installed plugins
curl -sf -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/plugins" | jq .

# Install a plugin from the bundled shipwright marketplace (or re-add to pin a version)
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/plugins" \
  -d '{"name": "shipwright", "version": "4.27.2"}' | jq .

# Install a plugin from a different marketplace baked into the agent image
# (use the canonical "<plugin>@<marketplace>" spec)
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/plugins" \
  -d '{"name": "my-plugin@my-marketplace"}' | jq .

# Update a plugin version
# name goes in the query param — a spec like my-plugin@org/marketplace can contain "/" which breaks path matching
curl -sf -X PATCH \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/plugins?name=shipwright" \
  -d '{"version": "4.27.2"}' | jq .

# Remove a plugin
curl -sf -X DELETE \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/$SHIPWRIGHT_AGENT_ID/plugins?name=shipwright"
```

---

## Creating a New Agent (Admin Only)

Two callers, one implementation: `POST /agents` (JSON admin API) and the web UI form at
`/admin/agents/new` (`POST /admin/agents`, an HTML form endpoint) both delegate to the same
`createAgent()` function — validate name/typeName, create the Agent row, seed
AgentTool/AgentPlugin from the selected Specialty manifest, attach repos/allowlists/members,
patch Claude credentials, and (for `runtime: "in-cluster"`) provision the Kubernetes workload.
Creation is transactional: any failure leaves zero rows behind, never a partial-success 200.
(`/admin/provision` still works as a legacy redirect to the form.)

```bash
# POST /agents — admin key or session cookie only (not a per-agent bearer token)
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_ADMIN_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents" \
  -d '{
    "name": "My New Agent",
    "typeName": "coding",
    "runtime": "in-cluster",
    "reposRaw": "my-org/my-repo\nmy-org/another-repo"
  }' | jq .
```

Every field besides `name`/`typeName` is optional and raw/unparsed — `reposRaw`,
`authorAllowlistRaw`, `patchAuthorAllowlistRaw`, and `memberEmailsRaw` are newline-separated
lists (mirroring the form's textareas); `restrictSlackToMembersRaw` is only truthy for the
literal string `"true"`. On success the response is the created agent, same shape as
`GET /agents/:id`. On failure the response is `{ "error": "create agent failed: <code>" }`
with a 4xx status — `<code>` is one of `missing_fields`, `invalid_type`,
`provisioning_disabled`, `seed_failed`, `invalid_repo_format`,
`invalid_author_allowlist_format`, or `provision_failed`.

The web UI form at `/admin/agents/new` remains the friendlier path for a human: it covers
both runtime modes, specialty selection, Slack app connection, GitHub auth, AI credentials,
repos, member emails, and author allowlists in one guided flow.

After the agent is created, set env vars, add tool patterns, install plugins, and seed
crons using the endpoints documented elsewhere in this skill.

---

## Metrics API

The metrics service exposes task-store-backed pipeline data. Endpoints require Bearer auth.

| Endpoint | What it returns |
|---|---|
| `GET /metrics/summary` | Cycle time, task counts, FTQ rate |
| `GET /metrics/trends` | Metrics over time, groupable by day/week/month |
| `GET /metrics/features` | Per-feature task and CI data |
| `GET /metrics/queue` | Queue funnel and cycle breakdown |
| `GET /metrics/tokens` | Token usage by agent and session type |

For a human-facing view of the same data — cycle time, FTQ rate, CI gate, and other
quality metrics — with charts and trend lines, use the server-rendered dashboard at
`/dashboard` instead of calling the endpoints directly.

---

## Repos, Ask, Chat Credentials and /doc

Platform routes gated by scope and, for three of them, by a feature flag. Scopes come from the
key's `name:token:scope` entry in `SHIPWRIGHT_ADMIN_API_KEYS`: `platform.read` may only `GET`;
`platform.ops` may also call the mutating routes below; `*` may call everything. A disabled
flag makes the route return `404`. In the Helm chart the flags are set by `admin.ask.enabled`
(plus `admin.ask.allowlist`), `admin.chatCredentialMint.enabled` and `admin.doc.enabled`.

### Repos add / remove

Scope: `platform.ops` or `*`. No flag.

```bash
# Add repos (union into the existing list; idempotent)
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/{agentId}/repos" \
  -d '{"repos": ["my-org/my-repo"]}' | jq .

# Remove one repo (404 if the agent does not have it)
curl -sf -X DELETE \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/{agentId}/repos/my-org/my-repo" | jq .
```

### Ask another agent

Flag: `SHIPWRIGHT_AGENT_ASK_ENABLED=enabled` (chart: `admin.ask.enabled`). The `from>to` pair must
be on `SHIPWRIGHT_AGENT_ASK_ALLOWLIST` (chart: `admin.ask.allowlist`). Scope: `platform.ops`, `*`,
or the agent key whose id equals `from`. `GET /agents/{id}/asks` (audit rows) needs `platform.read`.

```bash
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/{targetAgentId}/ask" \
  -d '{"from": "'"$SHIPWRIGHT_AGENT_ID"'", "question": "Which repos do you cover?", "waitMs": 30000}' | jq .
# Returns: { askId, threadId, status: "replied" | "pending", reply? }
```

### Chat credentials mint / revoke

Flag: `SHIPWRIGHT_CHAT_TOKEN_MINT_ENABLED=enabled` (chart: `admin.chatCredentialMint.enabled`).
Scope: `platform.ops` or `*` only, never the agent's own key. The raw token is returned once.

```bash
# Mint (the body is closed: do not send agentId)
curl -sf -X POST \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  -H "Content-Type: application/json" \
  "$SHIPWRIGHT_API_URL/agents/{agentId}/chat-credentials" \
  -d '{"label": "web-client"}' | jq .
# Returns: { tokenId, rawToken, label, agentId }

# Revoke
curl -sf -X DELETE \
  -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" \
  "$SHIPWRIGHT_API_URL/agents/{agentId}/chat-credentials/{tokenId}"
```

### Platform OpenAPI document (/doc)

Flag: `SHIPWRIGHT_ADMIN_DOC_ENABLED=enabled` (chart: `admin.doc.enabled`). Scope: `platform.read`
or higher. When the flag is off the route is absent (404).

```bash
curl -sf -H "Authorization: Bearer $SHIPWRIGHT_AGENT_API_KEY" "$SHIPWRIGHT_API_URL/doc" | jq .
```

---

## API Reference

The full admin API schema is committed to the repository at `admin/openapi.json`. For
interactive schema exploration, call the `/doc` endpoint described above on an admin service
that has `SHIPWRIGHT_ADMIN_DOC_ENABLED=enabled`.

---

## Safety Rules

- **Confirm before any DELETE** — token revocations and plugin removals are not easily reversed.
- **Never attempt to delete system crons** — the API returns 403. Use `PATCH {"enabled": false}` to disable them instead.
- **Content PATCH requires `schedule` + `prompt` together** — you must resend both even when changing only one. For toggling only enabled, use `{"enabled": bool}` with no schedule/prompt.
- **POST to `/envs` replaces everything** — use PATCH to update specific keys without wiping others.
- **Token raw values are shown once** — save `rawToken` from the create response before closing the session.
- **If the API isn't responding**, stop and tell the user — don't guess or retry blindly.
Files in this package (2)
  • SKILL.md 19 KB
  • agent-admin.content.test.ts 1 KB

Versions

The database has no other skills named agent-admin.

Database snapshot: 13.11.2026 · package version d7a91c6cf80f (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100env-vars
    Manage environment variables and API keys in the sandbox. Use when the user asks to set, update, or manage environment variables, API keys, secrets, or credentials, or when you need to configure API keys or secrets for tools, scripts, or services you are running.
  • 100github-actions-mcp-config
    MCP server config for GitHub Actions — tool permissions, env vars, multi-server setups. Use when configuring MCP servers in GitHub Actions workflows.
  • 90claude-agent-sdk-tool-integration
    Use when integrating tools, permissions, and MCP servers with Claude AI agents using the Agent SDK.
  • 100cron-scheduler
    Schedules recurring or delayed agent tasks. Use for: schedule this, run daily, cron job, set timer.
  • 85scheduled-agents
    Schedules recurring coding-agent work, such as a morning triage or a weekly report, as a Leverage automation that runs on a cloud machine even when every laptop is closed. Use when the user says "run this agent every morning", "cron job for Claude Code", "scheduled agents", or…
  • 100agent-manager
    tmux + Python agent lifecycle manager — start, stop, monitor, and assign tasks to AI agents running in tmux sessions. Use when managing multiple AI agents without a server, scheduling agent jobs via cron, monitoring agent heartbeats, or injecting skills into agent sessions. Zero…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.