Changelog

Live Activities now support a third activity type: metrics.

Use metrics to track server health, queue pressure, replica lag, worker saturation, and similar backend state you want visible on your lock screen at a glance.

1
const status = await activitysmith.liveActivities.stream("prod-web-1", {
2
  content_state: {
3
    title: "Server Health",
4
    subtitle: "prod-web-1",
5
    type: "metrics",
6
    metrics: [
7
      { label: "CPU", value: 9, unit: "%" },
8
      { label: "MEM", value: 45, unit: "%" },
9
    ],
10
  },
11
});

Call the same PUT /live-activity/stream/{stream_key} endpoint again whenever the values change. ActivitySmith keeps the Live Activity in sync on the device for you.

When the signal is no longer relevant, call DELETE /live-activity/stream/{stream_key} to end the Live Activity.

Need full lifecycle control instead?

If your runtime already has state, you can use the start/update/end lifecycle to have full control over the Live Activity.

1
const start = await activitysmith.liveActivities.start({
2
  content_state: {
3
    title: "Server Health",
4
    subtitle: "prod-web-1",
5
    type: "metrics",
6
    metrics: [
7
      { label: "CPU", value: 76, unit: "%" },
8
      { label: "MEM", value: 52, unit: "%" },
9
    ],
10
  },
11
});
12
13
const activityId = start.activity_id;

Store the returned activity_id and use the same metrics shape in update and end requests.

1
await activitysmith.liveActivities.update({
2
  activity_id: activityId,
3
  content_state: {
4
    ...
5
  },
6
});

Availability

Available now across the API, SDKs, CLI, and GitHub Action.

This feature is available in the ActivitySmith iOS app version 1.5.0 and newer.

Live Activities now support a stateless stream mode.

I built this because while working on a new Live Activity type, I ran into a real limitation: lifecycle state management is fine in systems that already have state, but it becomes awkward in runtimes that wake up, do one thing, and exit.

GitHub Actions is a good example of where the original lifecycle still fits well. A workflow can start a Live Activity, keep the returned activity_id across steps, send updates, and end it when the run finishes.

A cron job is different. Each run can measure the current state of a process, but it does not naturally remember the activity_id from the previous run. You can bolt on a file, Redis key, or database row to persist it, but that means the integration is doing more state management than the job itself.

Stateless Live Activities remove that overhead.

What's new

• New PUT /live-activity/stream/{stream_key} endpoint for stateless start-or-update behavior.
• New DELETE /live-activity/stream/{stream_key} endpoint to end the tracked Live Activity when the process is over.
• ActivitySmith manages the lifecycle behind a stable stream_key, so the caller does not need to persist activity_id.
• This is a good fit for cron jobs, scheduled scripts, background workers, and polling loops.

How it works

Pick one stable stream_key for one thing you are tracking.

Examples:

• prod-web-1
• deployment-main
• nightly-backup
• ev-charging

Use one stream_key for one system, workflow, or process.

If no Live Activity exists yet for that key, ActivitySmith starts one. If one already exists, ActivitySmith updates it. If the current Live Activity needs to rotate, ActivitySmith handles that too.

The caller only sends the latest state.

Example: monitor PM2 process from cron

In this example, a cron job runs on a VPS, reads the CPU usage of one PM2 process by ID, maps that value to a progress Live Activity, and sends it with the same stream_key every time.

The important part is what the script does not do:

• it does not load an activity_id
• it does not save lifecycle state anywhere
• it just sends the latest data

1
#!/bin/bash
2
set -euo pipefail
3
4
API_BASE_URL="https://activitysmith.com/api"
5
API_KEY="YOUR_API_KEY"
6
STREAM_KEY="pm2-activitysmith-api-cpu"
7
PM2_PROCESS_ID="0"
8
9
cpu_raw=$(pm2 jlist | jq -r --arg id "$PM2_PROCESS_ID" '
10
  map(select((.pm2_env.pm_id | tostring) == $id)) | .[0].monit.cpu
11
')
12
13
if [ -z "$cpu_raw" ] || [ "$cpu_raw" = "null" ]; then
14
  exit 1
15
fi
16
17
cpu=$(printf "%.0f" "$cpu_raw")
18
19
if [ "$cpu" -gt 100 ]; then
20
  cpu=100
21
fi
22
23
if [ "$cpu" -ge 80 ]; then
24
  color="red"
25
elif [ "$cpu" -ge 40 ]; then
26
  color="yellow"
27
else
28
  color="green"
29
fi
30
31
payload=$(cat <<EOF
32
{
33
  "content_state": {
34
    "title": "API Health",
35
    "subtitle": "PM2 activitysmith-api CPU",
36
    "type": "progress",
37
    "percentage": $cpu,
38
    "color": "$color"
39
  }
40
}
41
EOF
42
)
43
44
curl --fail --silent --show-error \
45
  -X PUT "$API_BASE_URL/live-activity/stream/$STREAM_KEY" \
46
  -H "Authorization: Bearer $API_KEY" \
47
  -H "Content-Type: application/json" \
48
  -d "$payload"

Then let cron run it every minute:

* * * * * /opt/monitoring/pm2-cpu-live-activity.sh

One run might send a green update at normal CPU usage.

A later run can spike the same Live Activity to yellow.

That is the whole point of stream mode: each execution is stateless, but the Live Activity stays continuous on the device.

When to use which model

Use stream mode when the caller should only send the latest state and move on.

Good fits:

• cron jobs
• scheduled health checks
• queue depth samplers
• background workers
• scripts that run independently and exit

Keep the original start/update/end lifecycle when the caller already has a natural place to keep state.

Good fits:

• GitHub Actions workflows
• deploy orchestration
• import pipelines
• long-running jobs that already pass IDs between stages

Ending the stream

When the tracked process is over and you no longer want the Live Activity on devices, end the stream explicitly:

curl --fail --silent --show-error \
  -X DELETE "https://activitysmith.com/api/live-activity/stream/pm2-activitysmith-api-cpu" \
  -H "Authorization: Bearer YOUR_API_KEY"

If you later send another PUT request with the same stream_key, ActivitySmith starts a new Live Activity for that stream again.

Availability

Available now across the API, SDKs, CLI, and GitHub Action.

This feature is available in the ActivitySmith iOS app version 1.5.0 and newer.

Live Activities now support optional action button.

Use it when a long-running job should stay actionable while progress is visible on the Lock Screen.

Open the GitHub Action run for a deployment, open a runbook, or trigger a backend webhook to pause or retry work without having to search for the right link or dashboard first.

What’s new

• New optional action field on Live Activity start, update, and end requests.
• One button per Live Activity.
• Action type:
  • open_url: opens the provided HTTPS URL in the browser.
  • webhook: ActivitySmith backend calls the provided HTTPS webhook (GET or POST).
• Supported for both segmented_progress and progress Live Activities.

Open URL example

Use this to jump from the Live Activity straight into the deployment or CI page.

1
{
2
  "content_state": {
3
    "title": "Deploying payments-api",
4
    "subtitle": "Running database migrations",
5
    "number_of_steps": 5,
6
    "current_step": 3,
7
    "type": "segmented_progress"
8
  },
9
  "action": {
10
    "title": "Open Workflow",
11
    "type": "open_url",
12
    "url": "https://github.com/acme/payments-api/actions/runs/1234567890"
13
  }
14
}

Webhook example

Use this when the action should trigger backend behavior instead of opening a page.

1
{
2
  "content_state": {
3
    "title": "Reindexing product search",
4
    "subtitle": "Shard 7 of 12",
5
    "number_of_steps": 12,
6
    "current_step": 7,
7
    "type": "segmented_progress"
8
  },
9
  "action": {
10
    "title": "Pause Reindex",
11
    "type": "webhook",
12
    "url": "https://ops.example.com/hooks/search/reindex/pause",
13
    "method": "POST",
14
    "body": {
15
      "job_id": "reindex-2026-03-19",
16
      "requested_by": "activitysmith"
17
    }
18
  }
19
}

Good fits

• deployment progress: open the workflow, deployment page, PR, or incident runbook
• customer imports and backfills: pause the import or retry a failed batch
• search reindex jobs: pause the reindex from the Live Activity itself
• database backup or restore verification: open the runbook or trigger the next backend step

Availability

Available now across the API, SDKs, CLI, and GitHub Action.

This feature is available in the ActivitySmith iOS app version 1.4.0 and newer.

Push Notifications now support optional media.

Attach an image, video, or audio file to the notification itself so you can press and hold to preview media directly from the notification, then tap through to open the linked content.

This is a good fit for agent outputs, QA review flows, design previews, generated voice overs, and any backend workflow where the notification should carry the actual result, not just a line of text.

What’s new

• New optional media field for push notifications.
• Send direct image, video, or audio URLs in the payload.
• Press and hold to preview the media directly from the notification.
• media can be combined with redirection.
• If redirection is omitted, tapping the notification opens the media URL.

What will work

• direct image URL: .jpg, .png, .gif, etc.
• direct audio file URL: .mp3, .m4a, etc.
• direct video file URL: .mp4, .mov, etc.
• URL that responds with a proper media Content-Type, even if the path has no extension

Example payload

1
{
2
  "title": "Homepage ready",
3
  "message": "Your agent finished the redesign.",
4
  "media": "https://cdn.example.com/output/homepage-v2.png",
5
  "redirection": "https://github.com/acme/web/pull/482"
6
}

Availability

Available now across the API, SDKs, CLI, and GitHub Action.

This feature is available in the ActivitySmith iOS app version 1.3.0 and newer.

Live Activities now support a second activity type: progress.

Use progress when the work is naturally continuous instead of step-based.

It fits EV charging, file transfers, data sync progress, imports, downloads, uploads, and any job where a percentage or numeric range is clearer than "step 2 of 4".

What’s new

• New progress type for Live Activities.
• Send either percentage or value with upper_limit.
• Keep using segmented_progress for step-based workflows.
• segmented_progress still supports dynamic number_of_steps during update and end calls.

Choose the right type

• segmented_progress: best for jobs tracked in steps.
• progress: best for jobs tracked as a percentage or numeric range.

Lifecycle

The lifecycle stays the same:

1. Start the activity.
2. Save the returned activity_id.
3. Update it as progress changes.
4. End it when the work is finished.

Start Live Activity

1
{
2
  "content_state": {
3
    "title": "EV Charging",
4
    "subtitle": "Added 30 mi range",
5
    "percentage": 15,
6
    "type": "progress",
7
    "color": "lime"
8
  }
9
}

Update Live Activity

1
{
2
  "content_state": {
3
    "title": "EV Charging",
4
    "subtitle": "Added 120 mi range",
5
    "percentage": 60
6
  }
7
}

End Live Activity

1
{
2
  "content_state": {
3
    "title": "EV Charging",
4
    "subtitle": "Added 200 mi range",
5
    "percentage": 100,
6
    "auto_dismiss_minutes": 2
7
  }
8
}

Numeric range example

1
{
2
  "content_state": {
3
    "title": "Data Sync",
4
    "subtitle": "241 of 360 records synced",
5
    "value": 241,
6
    "upper_limit": 360,
7
    "type": "progress",
8
    "color": "blue"
9
  }
10
}

Availability

Available now across the API, SDKs, CLI, GitHub Action, and ActivitySmith skill.

This feature is available in the ActivitySmith iOS app version 1.2.0 and newer.

Push Notifications now support optional redirection and actions fields.

Use redirection to open a URL when a user taps the notification. Use actions to show up to four buttons on long-press.

What’s new

• redirection: HTTPS URL opened on notification tap.
• actions: up to 4 action buttons shown on long-press.
• Action type:
  • open_url: opens the provided URL in browser.
  • webhook: triggers backend webhook call (GET or POST).

Availability

This feature is available in the ActivitySmith iOS app version 1.1.0 and newer.

Example payload

1
{
2
  "title": "Build Failed 🚨",
3
  "message": "CI pipeline failed on main branch",
4
  "redirection": "https://github.com/org/repo/actions/runs/123456789",
5
  "actions": [
6
    {
7
      "title": "Open Failing Run",
8
      "type": "open_url",
9
      "url": "https://github.com/org/repo/actions/runs/123456789"
10
    },
11
    {
12
      "title": "Create Incident",
13
      "type": "webhook",
14
      "url": "https://hooks.example.com/incidents/create",
15
      "method": "POST",
16
      "body": {
17
        "service": "payments-api",
18
        "severity": "high"
19
      }
20
    }
21
  ]
22
}

All SDKs, CLI, and the GitHub Action now support these optional fields in push notification requests.

ActivitySmith now provides a skill you can install with npx skills add to send Push Notifications and trigger Live Activities from your coding agents.

Install

npx skills add ActivitySmithHQ/activitysmith-cli --skill activitysmith

Repository: github.com/activitysmithhq/activitysmith-cli

Push notification example

./skills/activitysmith/scripts/send_push.sh \
  -t "Codex task finished" \
  -m "Implemented OAuth callback fix, added regression tests, and opened PR #128."

Live Activity workflow example

1
activity_id="$(./skills/activitysmith/scripts/start_activity.sh \
2
  --title "Codex: migrate billing webhooks" \
3
  --subtitle "Analyzing handlers" \
4
  --type "segmented_progress" \
5
  --steps 4 \
6
  --current 1 \
7
  --id-only)"
8
9
./skills/activitysmith/scripts/update_activity.sh \
10
  --activity-id "$activity_id" \
11
  --title "Codex: migrate billing webhooks" \
12
  --subtitle "Implementing + tests" \
13
  --current 2
14
15
./skills/activitysmith/scripts/end_activity.sh \
16
  --activity-id "$activity_id" \
17
  --title "Codex: migrate billing webhooks" \
18
  --subtitle "Done" \
19
  --current 4 \
20
  --auto-dismiss 2

Use ACTIVITYSMITH_API_KEY for auth in your shell or environment.

ActivitySmith now integrates with Zapier so you can send iOS Push Notifications and Live Activities from your automations.

Connect ActivitySmith to any Zap and route runtime events from your apps, scripts, and workflows to paired team devices.

Supported actions

• Send push notifications for immediate events.
• Start and update Live Activities for long-running workflows.

Visit ActivitySmith integration on Zapier for more details.

Use channels to route Push Notifications and Live Activities to specific users and devices.

Channels are now supported across all ActivitySmith SDKs and integrations, and the documentation has been updated with channel examples.

You can also scope API keys to specific channels for tighter control over where updates can be delivered.

Why channels

Channels let you route updates to the right audience, for example: #engineering, #ios-builds, #marketing.

Example

1
{
2
  "title": "Build Failed",
3
  "message": "CI pipeline failed on main branch",
4
  "channels": ["ios-builds", "engineering"]
5
}

If channels are omitted, delivery behavior stays unchanged.

Add your team members to keep everyone notified and up to date with shared Push Notifications and Live Activities.

When your backend, scripts, or automations send push notifications or Live Activities, each update is delivered to all paired iOS devices on your team.

How it works

1. Add team members in ActivitySmith.
2. Teammates accept the invite and pair their iOS devices.
3. Send updates from your backend, scripts, automations, or AI agents.
4. Everyone gets notified and up to date with Push Notifications and Live Activities.

The official ActivitySmith SDK suite is now available across all major backend stacks.

You can now integrate ActivitySmith with:

• Node.js (npm)
• Python (PyPI)
• Go
• PHP (Packagist)
• Ruby (RubyGems)
• CLI

Install

1
# Node.js SDK
2
npm i activitysmith
3
4
# Python SDK
5
pip install activitysmith
6
7
# Go SDK
8
go get github.com/ActivitySmithHQ/activitysmith-go
9
10
# PHP SDK
11
composer require activitysmith/activitysmith
12
13
# Ruby SDK
14
gem install activitysmith
15
16
# ActivitySmith CLI
17
npm i -g activitysmith-cli

Documentation

Full SDK documentation:

• activitysmith.com/docs/sdks/overview

The official ActivitySmith GitHub Action is now live on the GitHub Marketplace.

Connect your CI and deployment workflows directly to ActivitySmith so your team gets real-time updates on their mobile devices.

You can now:

• Send push notifications from any workflow step.
• Start, update, and end Live Activities as your pipeline progresses.

Push Notifications

For lightweight updates like deploy completed, build failed, or rollback started, send a push notification in a single step:

1
- name: Send push notification
2
  uses: ActivitySmithHQ/[email protected]
3
  with:
4
    action: send_push_notification
5
    api-key: ${{ secrets.ACTIVITYSMITH_API_KEY }}
6
    payload: |
7
      title: "ActivitySmith Deployment"
8
      message: "New release deployed to production."

This is a good fit for one-off alerts where you want immediate visibility but no ongoing activity timeline.

Live Activities

For long-running workflows, start the activity, post as many progress updates as needed, then end it when complete.

The start_live_activity step returns live_activity_id, which you pass into update/end steps.

1
- name: Start live activity
2
  id: start_activity
3
  uses: ActivitySmithHQ/[email protected]
4
  with:
5
    action: start_live_activity
6
    api-key: ${{ secrets.ACTIVITYSMITH_API_KEY }}
7
    payload: |
8
      content_state:
9
        title: "ActivitySmith API Deployment"
10
        subtitle: "ci: install & build"
11
        number_of_steps: 3
12
        current_step: 1
13
        type: "segmented_progress"
14
15
- name: Update live activity
16
  uses: ActivitySmithHQ/[email protected]
17
  with:
18
    action: update_live_activity
19
    api-key: ${{ secrets.ACTIVITYSMITH_API_KEY }}
20
    live-activity-id: ${{ steps.start_activity.outputs.live_activity_id }}
21
    payload: |
22
      content_state:
23
        title: "ActivitySmith API Deployment"
24
        subtitle: "ci: tests"
25
        current_step: 2
26
27
- name: End live activity
28
  uses: ActivitySmithHQ/[email protected]
29
  with:
30
    action: end_live_activity
31
    api-key: ${{ secrets.ACTIVITYSMITH_API_KEY }}
32
    live-activity-id: ${{ steps.start_activity.outputs.live_activity_id }}
33
    payload: |
34
      content_state:
35
        title: "ActivitySmith API Deployment"
36
        subtitle: "done"
37
        current_step: 3

After months of building, ActivitySmith is live! Trigger Live Activities and send Push Notifications to your iOS device(s) with a simple API call.

Start here:

• Download the ActivitySmith iOS app and pair your device.
• Create API key and use the REST API to trigger Live Activities and send Push Notifications from any backend or CI.
• Check Quickstart guide at activitysmith.com/docs.

Try it now at activitysmith.com.