tutorial

Monitoring Goose (Block) with Vigilmon

Goose is Block's open source autonomous AI coding agent that runs tasks end-to-end via CLI or REST API. Here's how to monitor its API server, LLM provider, extensions, task queue, and code execution sandbox with Vigilmon.

Goose is Block's (formerly Square) open-source autonomous AI coding agent. You give it a natural-language developer task and it handles the rest: writing code, running commands, installing packages, browsing the web, and iterating until the job is done. Goose runs as a CLI tool or a REST API server (port 3000) that accepts tasks programmatically, and it supports a rich extension system for web browsing, GitHub integration, and code execution. When Goose is configured with a local LLM backend via Ollama (port 11434), the full stack has multiple layers that each need monitoring. Vigilmon covers all of them — the API server, the LLM provider, the extension health endpoints, the task session state, and the file system.

What You'll Set Up

  • Goose REST API server availability monitor (port 3000)
  • LLM provider connectivity check (Ollama local or OpenAI/Anthropic remote)
  • Extension health monitors (web browsing, GitHub API, code execution)
  • Task session queue and stuck-session detection via heartbeat
  • File system write health check (disk space and permissions)
  • SSL certificate expiry alerts for reverse-proxy deployments

Prerequisites

  • Goose installed (pip install goose-ai or from github.com/block/goose)
  • Goose server mode running: goose server --port 3000 (optional, for programmatic access)
  • A configured LLM backend: Ollama (port 11434), OpenAI, or Anthropic API key
  • A free Vigilmon account

Step 1: Monitor the Goose API Server

When Goose runs in server mode (goose server), it exposes a REST API at port 3000 for programmatically submitting tasks and retrieving session results. This is the integration point for automated pipelines and CI/CD workflows. If it's down, no programmatic task submission is possible.

  1. Log in to vigilmon.online and click Add Monitor.
  2. Set Type to HTTP / HTTPS.
  3. Enter the server URL:
    • Local: http://localhost:3000/
    • Reverse-proxy / remote: https://goose.yourdomain.com/
  4. Set Check interval to 1 minute.
  5. Set Expected HTTP status to 200.
  6. Click Save.

The Goose API server returns 200 on its root or a /health path when running. A connection refused or 5xx means the process has crashed or failed to start after a system restart.

Tip: Add a /health endpoint check by setting the monitor URL to http://localhost:3000/health if your Goose version exposes one — this gives a richer signal than the root path.

Step 2: Monitor the LLM Provider

Goose relies on an LLM to reason through each task step. If the LLM backend goes offline — Ollama OOM-killed, OpenAI outage, or expired API key — the Goose server accepts connections but fails every task silently or with unhelpful error messages.

Local Ollama Backend (port 11434)

  1. Click Add Monitor → HTTP / HTTPS.
  2. Enter: http://localhost:11434/ (or the LAN IP of your Ollama host).
  3. Set Expected HTTP status to 200.
  4. Set Check interval to 1 minute.
  5. Click Save.

Ollama's root endpoint returns a running status when healthy. An OOM-killed or crashed Ollama process will surface here within one minute.

Remote OpenAI or Anthropic API

For Goose instances configured with a cloud LLM provider, add an HTTP monitor to verify provider reachability:

  • OpenAI: https://api.openai.com/
  • Anthropic: https://api.anthropic.com/

Set Check interval to 5 minutes. This tells you whether the provider's API is reachable from your server's network — it does not validate your API key, which is covered by the heartbeat probe in Step 5.

Step 3: Monitor Goose Extension Health

Goose's extension system (web browsing via Playwright, GitHub integration, code execution sandbox, file system tools) can be probed individually if the extensions expose health endpoints. Even without dedicated endpoints, you can validate each extension's underlying dependency directly.

Web Browsing Extension (Playwright)

Goose's web browsing capability relies on a Playwright-managed browser process. If the Chromium binary is missing or the browser crashes, all web tasks fail.

  1. Click Add Monitor → Cron Heartbeat.
  2. Set Expected ping interval to 30 minutes.
  3. Copy the heartbeat URL.

Create check_browser.sh:

#!/bin/bash
node -e "
const { chromium } = require('playwright');
(async () => {
  const browser = await chromium.launch({ headless: true });
  await browser.close();
  process.exit(0);
})().catch(() => process.exit(1));
" && curl -s "https://vigilmon.online/heartbeat/YOUR_BROWSER_HEARTBEAT_ID"

Schedule every 30 minutes.

GitHub API Connectivity

If Goose uses the GitHub extension to read issues or submit pull requests, validate GitHub API reachability:

  1. Click Add Monitor → HTTP / HTTPS.
  2. Enter: https://api.github.com/.
  3. Set Expected HTTP status to 200.
  4. Set Check interval to 5 minutes.
  5. Click Save.

This catches GitHub outages and network-level blocks that would prevent Goose from reading repository context or submitting PRs.

Step 4: Monitor the Task Queue and Stuck Sessions

Goose runs one task session at a time. A session that hangs on a slow tool call, an unresponsive subprocess, or an infinite reasoning loop blocks all subsequent task submissions. Without max-duration enforcement, stuck sessions are invisible until a developer manually checks.

  1. Click Add Monitor → Cron Heartbeat.
  2. Set Expected ping interval to 30 minutes (adjust to your longest expected task plus buffer).
  3. Copy the heartbeat URL.

Create a probe that checks the Goose API for session state and sends a heartbeat only if no session has exceeded the maximum allowed duration:

#!/bin/bash
MAX_SESSION_SECONDS=1800  # 30 minutes
NOW=$(date +%s)

SESSION=$(curl -s http://localhost:3000/api/sessions/current)
STATUS=$(echo "$SESSION" | python3 -c "import sys,json; s=json.load(sys.stdin); print(s.get('status','idle'))" 2>/dev/null)

if [ "$STATUS" = "idle" ] || [ -z "$STATUS" ]; then
  curl -s "https://vigilmon.online/heartbeat/YOUR_QUEUE_HEARTBEAT_ID"
  exit 0
fi

START=$(echo "$SESSION" | python3 -c "import sys,json; s=json.load(sys.stdin); print(s.get('startedAt',0))" 2>/dev/null)
ELAPSED=$(( NOW - START ))

if [ "$ELAPSED" -lt "$MAX_SESSION_SECONDS" ]; then
  curl -s "https://vigilmon.online/heartbeat/YOUR_QUEUE_HEARTBEAT_ID"
else
  echo "Goose session stalled: running for ${ELAPSED}s"
fi

Schedule every 15 minutes.

Step 5: Heartbeat for API Key Validity

An HTTP reachability check to api.openai.com confirms the network path, but not that your API key has remaining quota. Use a cron heartbeat driven by a minimal API probe to catch quota exhaustion or key revocation early.

  1. Click Add Monitor → Cron Heartbeat.
  2. Set Expected ping interval to 60 minutes.
  3. Copy the heartbeat URL.

Create check_llm_key.sh:

#!/bin/bash
# Make a minimal API call to verify key validity and quota
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"ping"}],"max_tokens":1}' \
  https://api.openai.com/v1/chat/completions)

if [ "$HTTP_CODE" = "200" ]; then
  curl -s "https://vigilmon.online/heartbeat/YOUR_APIKEY_HEARTBEAT_ID"
else
  echo "API key probe failed: HTTP $HTTP_CODE"
fi

Schedule hourly:

0 * * * * /path/to/check_llm_key.sh

Step 6: Monitor Code Execution Sandbox Health

Goose executes code in subprocesses — Python scripts, shell commands, npm builds. The sandbox depends on the Python interpreter, Node.js runtime, shell environment, and any project-specific dependencies all being available. A broken virtualenv or a missing runtime silently fails all code execution tasks.

  1. Click Add Monitor → Cron Heartbeat.
  2. Set Expected ping interval to 15 minutes.
  3. Copy the heartbeat URL.

Create check_sandbox.sh:

#!/bin/bash
# Verify Python and Node.js execution environments
python3 -c "print('ok')" > /dev/null 2>&1 || exit 1
node -e "process.exit(0)" > /dev/null 2>&1 || exit 1
curl -s "https://vigilmon.online/heartbeat/YOUR_SANDBOX_HEARTBEAT_ID"

Schedule every 15 minutes.

Step 7: Monitor File System Write Health

Goose writes code changes and creates new files as part of task execution. Disk full or permissions errors cause cryptic mid-task failures.

  1. Click Add Monitor → Cron Heartbeat.
  2. Set Expected ping interval to 15 minutes.
  3. Copy the heartbeat URL.

Create check_fs.sh:

#!/bin/bash
WORKDIR="${GOOSE_WORKDIR:-$HOME/projects}"

TESTFILE="$WORKDIR/.vigilmon_check"
echo "ok" > "$TESTFILE" && rm "$TESTFILE" || exit 1

# Alert if less than 1 GB free
AVAIL_MB=$(df -m "$WORKDIR" | awk 'NR==2{print $4}')
[ "$AVAIL_MB" -gt 1024 ] || exit 1

curl -s "https://vigilmon.online/heartbeat/YOUR_FS_HEARTBEAT_ID"

Step 8: SSL Certificate Monitoring

If the Goose API server is exposed through a reverse proxy with TLS (nginx, Caddy), monitor the certificate expiry.

  1. Open the HTTP monitor for the Goose API (created in Step 1).
  2. Enable Monitor SSL certificate.
  3. Set Alert when certificate expires in less than 21 days.
  4. Click Save.

Step 9: Configure Alert Channels

  1. Go to Alert Channels in Vigilmon and add Slack, email, Discord, or a webhook.
  2. On the Goose API server monitor: set Consecutive failures before alert to 2.
  3. On the Ollama backend monitor: set Consecutive failures to 1 — local inference servers crash hard.
  4. On heartbeat monitors: the default single-missed-interval threshold is appropriate.

Summary

| Monitor | Type | Target | Interval | |---------|------|--------|----------| | Goose API server | HTTP | http://localhost:3000/ | 1 min | | Ollama LLM backend | HTTP | http://localhost:11434/ | 1 min | | OpenAI / Anthropic reachability | HTTP | https://api.openai.com/ | 5 min | | API key validity | Heartbeat | probe script → Vigilmon | 60 min | | Browser extension (Playwright) | Heartbeat | probe script → Vigilmon | 30 min | | GitHub API connectivity | HTTP | https://api.github.com/ | 5 min | | Task session / stuck session | Heartbeat | probe script → Vigilmon | 15 min | | Code execution sandbox | Heartbeat | probe script → Vigilmon | 15 min | | File system write access | Heartbeat | probe script → Vigilmon | 15 min | | SSL certificate | SSL (on HTTP monitor) | reverse proxy domain | — |

Goose's promise — autonomous end-to-end task execution — depends on every component in its stack staying healthy. A crashed Ollama instance, an expired API key, or a full disk will stop tasks silently. With Vigilmon watching each layer, you catch failures within minutes and can restore developer productivity before anyone notices work isn't progressing.

Get started for free at vigilmon.online.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles