How to Auto-Respond to Meeting Requests with Paradime, OpenClaw, and Google Calendar

Stop wasting time on meeting management. Every data engineer knows the feeling: your calendar fills up with back-to-back meetings, Friday afternoons get blocked before you can blink, and suddenly you've spent more time responding to invites than writing actual code. What if your AI agent could triage meeting requests for you—automatically declining Friday meetings, enforcing a daily cap, and sending polite responses via Gmail—all on a recurring schedule?

In this guide, you'll build exactly that. We'll wire up OpenClaw (the open-source AI assistant) with Google Calendar API and Gmail API, orchestrate it through Paradime's Bolt scheduler on a cron every 2 hours, and set up monitoring so you know the instant something breaks. The entire walkthrough follows an incident-friendly mindset: structured steps, a decision tree for meeting evaluation, and a focus on time to first clue when debugging.

What Is Paradime?

Paradime is an AI-native platform for data engineering that replaces dbt Cloud™. Teams use Paradime to code, ship, fix, and scale data pipelines for analytics and AI—built for fast-moving teams.

At its core, Paradime provides:

• Code IDE — An AI-native IDE with DinoAI (an integrated AI assistant) that cuts dbt™ and Python development time by 83%+.

• Bolt — A scheduler and orchestrator purpose-built for dbt™ and Python pipelines, featuring cron-based scheduling, CI/CD, AI-powered debugging, and configuration-as-code via YAML.

• Radar — FinOps tooling to reduce Snowflake and BigQuery costs.

• Monitoring & Alerts — Built-in dbt™ schedule monitoring, Slack/email notifications, and run history analytics.

For this project, Bolt is the key component. Bolt lets you schedule Python scripts alongside dbt™ commands using cron expressions, manage environment variables securely, and get AI-powered debugging when runs fail. Think of it as "configure and forget"—once your schedule is set, Bolt handles execution, retries, and alerting.

What Is OpenClaw?

OpenClaw is an open-source, self-hosted AI assistant that runs on your machine (Mac, Windows, or Linux) and connects to LLMs like Anthropic's Claude or OpenAI's GPT. Unlike cloud-only assistants, OpenClaw keeps your data local—your context, skills, and credentials live on your computer.

Key capabilities relevant to this project:

• Cron Jobs — OpenClaw's built-in scheduler persists jobs under ~/.openclaw/cron/ and supports at (one-shot), every (interval), and cron (5-field expressions) schedules.

• Skills & Plugins — Extend OpenClaw with community skills (e.g., google-calendar, gogcli for Gmail) or build your own Python scripts.

• Full System Access — Read/write files, run shell commands, execute Python scripts.

• Persistent Memory — Remembers your preferences and context across sessions.

OpenClaw also has a Python SDK (pip install openclaw) that gives you a programmatic interface to manage agents, trigger tasks, and integrate with application code:

Architecture Overview

Before diving into code, here's how all the pieces fit together:

Figure 1: End-to-end flow — Bolt triggers the Python script every 2 hours, which checks pending calendar invites, evaluates them against your preferences via OpenClaw, and responds accordingly.

Setup: openclaw-sdk + Google Calendar API + Gmail API

Step 1: Install Dependencies

Your project needs three core packages. Since Paradime Bolt uses Poetry for dependency management, set up your pyproject.toml:

Install locally for development:

Step 2: Configure Google Cloud Project

1. Go to Google Cloud Console → Create a new project (e.g., "Meeting Auto-Responder").

2. Enable Google Calendar API: APIs & Services → Library → search "Google Calendar API" → Enable.

3. Enable Gmail API: APIs & Services → Library → search "Gmail API" → Enable.

4. Configure OAuth Consent Screen: APIs & Services → OAuth consent screen → External → App name: "Meeting Auto-Responder" → Add scopes:

5. Create OAuth Credentials: APIs & Services → Credentials → Create Credentials → OAuth client ID → Desktop app → Download JSON.

Save the downloaded file as google-credentials.json. This file becomes your GOOGLE_CREDENTIALS_JSON environment variable value.

Step 3: Set Up OpenClaw

Install the OpenClaw Python SDK:

Set your API key:

Verify installation:

Step 4: Define Meeting Preferences

Create a JSON file (or environment variable) that encodes your meeting rules:

The Script: Check, Evaluate, Respond

Here's the complete Python script that Bolt will execute every 2 hours. It follows the decision tree approach for maximum reproducibility:

Figure 2: Decision tree for meeting evaluation — each invite is checked against a strict priority of rules before accepting or declining.

scripts/meeting_responder.py

Environment Variables: GOOGLE_CREDENTIALS_JSON, OPENCLAW_API_KEY, MEETING_PREFERENCES

This project relies on three environment variables. Here's how to configure them in Paradime:

Setting Environment Variables in Paradime Bolt

1. Navigate to Settings in the Paradime application.

2. Go to Workspaces → Environment Variables.

3. In the Bolt Schedules section, click Add New.

4. Enter the Key (e.g., GOOGLE_CREDENTIALS_JSON) and paste the Value.

5. Click the Save icon.

For per-schedule overrides (e.g., different preferences for different team members):

1. Navigate to Bolt UI → select your schedule → click Edit.

2. Scroll to the Environment Variables Override section.

3. Enter a new value in the Override column.

4. Click Deploy.

Security note: Schedule-level overrides take precedence over global values, and only Admin roles can modify them. Never commit credentials to your Git repository—always use Paradime's environment variable management.

For OpenClaw's own environment, API keys are resolved from the process environment or from ~/.openclaw/.env:

Bolt Schedule: Cron Every 2 Hours

Now wire everything together with a Bolt schedule. You have two options: UI-based or YAML-as-code.

Option A: YAML-as-Code (Recommended)

Add this to your paradime_schedules.yml at the root of your dbt™ project:

Key details:

• poetry install must be the first command—Bolt uses Poetry for dependency management.

• 0 */2 * * * runs at minute 0 of every 2nd hour (00:00, 02:00, 04:00, ...).

• sla_minutes: 10 triggers an SLA alert if the script takes longer than 10 minutes (it shouldn't).

• Schedules are auto-refreshed from paradime_schedules.yml on the default branch every 10 minutes, or manually via Bolt → Parse Schedules.

Option B: UI-Based

1. Navigate to Bolt from the Paradime home screen.

2. Click + New Schedule → + Create New Schedule.

3. Fill in:

4. Configure Slack/email notifications for failed events.

5. Click Save.

Complementary OpenClaw Cron (Optional)

If you also want OpenClaw's native cron as a backup or for ad-hoc checks:

OpenClaw cron jobs persist under ~/.openclaw/cron/jobs.json and survive restarts. Note that OpenClaw applies a deterministic stagger window of up to 5 minutes for top-of-hour expressions—use --exact if you need precise timing.

Figure 3: Primary (Bolt) and optional backup (OpenClaw cron) scheduling paths — both trigger the same Python script.

Monitoring and Debugging

An incident-friendly setup means time to first clue is everything. Here's how to monitor this pipeline across both Paradime and OpenClaw.

Paradime Bolt Monitoring

Step 1: Identify failed runs

• Notifications: Configure Slack or email alerts (already done in the YAML above). You'll get an immediate ping when a run fails or breaches its SLA.

• Bolt UI: Navigate to app.paradime.io/bolt. The Status column shows each run's state. Failed runs are marked with "Error."

Step 2: Access run logs

1. Click on the meeting_auto_responder schedule.

2. Navigate to Run History.

3. Select the failed run.

4. Scroll to Logs and Artifacts.

5. Click on the failed command.

Bolt provides three log types:

Step 3: Debug and resolve

• Summary logs from DinoAI will often pinpoint the issue (e.g., "Google Calendar API returned 401: Token expired").

• Console logs show the full Python traceback.

• Copy any failing API calls and reproduce locally with python scripts/meeting_responder.py.

OpenClaw Monitoring

For OpenClaw cron jobs:

Logs are stored at ~/.openclaw/logs/ in JSON format. Tail them for real-time debugging:

Figure 4: Debugging flowchart — follow the shortest path to root cause using Bolt's tiered log system.

Troubleshooting Common Issues

Issue 1: Google OAuth Token Expired (401 Unauthorized)

Symptom: Script fails with google.auth.exceptions.RefreshError or HttpError 401.

Root cause: OAuth tokens expire after 1 hour; refresh tokens can also expire if the app is in "Testing" mode (tokens expire after 7 days).

Fix:

1. Move your Google Cloud OAuth consent screen from "Testing" to "Published" (or add your email as a test user).

2. Delete the cached token: rm /tmp/token.json.

3. Re-run the script locally to trigger a fresh OAuth flow.

4. For headless environments, use a service account with domain-wide delegation instead of OAuth desktop flow.

Issue 2: Bolt Schedule Shows "Error" but No Useful Logs

Symptom: The run fails immediately with no Python output in Console Logs.

Root cause: Usually a poetry install failure—missing pyproject.toml or incompatible Python version.

Fix:

1. Ensure pyproject.toml is committed to the main branch.

2. Check that Poetry dependencies are compatible with Paradime's Python runtime.

3. Review Debug Logs for system-level errors.

Issue 3: OpenClaw Cron Job Appears but Never Fires

Symptom: openclaw cron list shows the job, but openclaw cron runs returns no history.

Fix (in order):

1. Check cron is enabled: openclaw config get cron.enabled (must be true).

2. Verify OPENCLAW_SKIP_CRON is NOT set: echo $OPENCLAW_SKIP_CRON.

3. Ensure the Gateway is running continuously (cron only fires when the Gateway process is active).

4. Check the job's enabled: true flag: inspect ~/.openclaw/cron/jobs.json.

5. Verify the delivery channel and session target are correct.

Issue 4: Gmail API Rate Limits (429 Too Many Requests)

Symptom: Script declines invites correctly but fails when sending decline emails.

Root cause: Free Gmail accounts allow 500 emails/day; Google Workspace allows 2,000/day.

Fix:

• Add exponential backoff to the send_decline_email function.

• Batch decline emails (accumulate during the run, send at the end).

• For high-volume use, consider Google Workspace or a transactional email service.

Issue 5: MEETING_PREFERENCES JSON Parse Error

Symptom: json.JSONDecodeError in the script's traceback.

Root cause: Environment variable value contains unescaped characters or was truncated.

Fix:

1. Validate your JSON: echo $MEETING_PREFERENCES | python3 -m json.tool.

2. In Paradime's environment variable UI, ensure the value is a single-line JSON string with no trailing whitespace.

3. Consider storing preferences as a file in the repository (preferences.json) and reading from disk instead.

Issue 6: Calendar Events Not Showing needsAction

Symptom: The script reports "0 pending invites" even though you have unresponded invitations.

Root cause: The Google Calendar API only returns attendees with responseStatus when the authenticated user is an attendee. Events that you organize yourself won't have needsAction status.

Fix:

• Verify you're authenticating as the correct Google account.

• Check that the calendarId is set to "primary".

• Ensure the Calendar API scope (calendar.events) is authorized.

Quick Reference: Decision Table

Wrapping Up

You now have a fully automated meeting management pipeline:

1. Paradime Bolt triggers meeting_responder.py every 2 hours via a 0 */2 * * * cron schedule.

2. The script fetches pending calendar invites (those with responseStatus: needsAction) from the Google Calendar API.

3. Each invite passes through a deterministic decision tree: no-meeting days → trusted organizers → decline keywords → blocked times → daily hour cap.

4. Accepted invites get patched via the Calendar API; declined invites also trigger a polite email via Gmail API.

5. Bolt's monitoring (DinoAI summary logs, console logs, Slack/email alerts) gives you sub-30-second time to first clue when something breaks.

6. Optionally, OpenClaw's native cron provides a backup execution path with its own logging and diagnostics.

The entire setup prioritizes reproducibility (same preferences always produce the same decision) and minimal fixes (each troubleshooting step targets exactly one root cause). Your calendar stays clean, your Fridays stay meeting-free, and your pipeline tells you the moment anything goes wrong.

Useful Links

• Paradime — Cursor for Data

• Paradime Bolt Documentation

• Bolt Schedules as Code

• Bolt Environment Variables

• Bolt Python Scripts

• Debugging Failed Runs in Bolt

• OpenClaw — Personal AI Assistant

• OpenClaw Cron Jobs Documentation

• OpenClaw Environment Variables

• Google Calendar API — Events Reference

• Gmail API — Sending Messages