Every 15 minutes

Get a brief before each Calendly call

Half an hour before each meeting, you get a short summary of who you're meeting and what they want.

Runs: Every 15 minutes
Apps: Calendly
AI: Yes, uses the built-in AI allowance
Access: PAT (read)

Send this to your assistant

Create a ClickRuntime automation: 30 minutes before every Calendly meeting, email me a short brief summarising the invitee's booking answers and what they want from the call.

Paste it into your assistant. It tells you what it will send or change before it runs live.

Add to ChatGPT Add to Claude

First time? Adding ClickRuntime to your assistant takes about two minutes.

Why use it

Why teams use this automation

Salespeople and account managers often walk into a call knowing only a name and a time. The booking form may have asked three useful questions, such as company size, what they are hoping to solve and how they found you, but the answers sit in Calendly and nobody opens them. The call opens with questions the invitee already answered, and the first ten minutes are wasted on basics.

Every 15 minutes, ClickRuntime looks for Calendly events starting in the next 30 to 45 minutes. For each one, it reads the invitee's answers, has its built-in AI turn them into a short brief covering who they are and what they said they want, emails it to you and remembers that it was sent so no brief is duplicated. No external AI account is needed.

It helps anyone who runs discovery calls, interviews or advisory sessions back to back.

What you get out of it

Calls start at the point that matters
Having read the invitee's own words, you can open with their actual problem. That reflects attention and respect, and it usually shortens the awkward warm-up. That small shift tends to make prospects feel heard from the first minute of the call.
Prep takes one minute
A short brief arrives 30 to 45 minutes before the call, in time to read but not so early that it is forgotten. You walk in prepared without a dedicated research session.
Invitee answers are actually used
Booking questions are only useful if somebody reads them. Turning them into a brief ensures the answers shape the conversation instead of sitting unread in Calendly. Context stays tied to the right person even when the calendar is crowded.
Back-to-back days become manageable
When you have six calls in a row, a brief per call stops you from mixing people up. Each conversation gets its own context at the right moment. Memory is stored between runs, so a late or repeated check does not cause a flood of messages.
No duplicate emails
Remembering which events already have a brief means a call appearing in several 15-minute checks produces only one email. Your inbox does not fill with repeats. That discipline keeps the useful email findable.

How it works

What happens, step by step

Every 15 minutes, ClickRuntime checks your Calendly for meetings starting in the next 30 to 45 minutes.
For each one it gathers who is coming and the answers they gave when booking.
AI turns that into a four-line brief: who they are, what they want, and two questions to ask.
The brief is emailed to you before the call. Meetings that already got a brief are skipped, so you never get two.

Before it runs live

Connect Calendly

What you get

RunsEvery 15 minutes

Get a brief before each Calendly calltoday, 9:00Succeeded

Email · Brief: Discovery call at 14:00 UTCSam Lee, ops lead at Northwind (40 staff), wants to replace manual invoice chasing. Ask: current tool? who signs off on budget?

Build your own

Need it to work differently?

This template is a starting point. Copy the prompt and change it, or describe a different automation from scratch, with your own conditions, more apps or an AI step. Your assistant writes it, tests it and runs it on ClickRuntime.

Your own rules
Conditions, thresholds, filters and exceptions, written the way you'd explain them to a colleague.
Any number of apps
One automation can read from one app and update several others. Over 248 apps are ready, and anything with an API works too.
AI where it helps
Summaries, classification, extraction and drafts use ClickRuntime's built-in AI, with no extra key.
On a schedule or on each event
Runs as often as every 5 minutes, or the moment an app sends an event, and keeps track of what it already handled.

Changes you can ask for

Run it at a different time, more or less often, or only on weekdays
Change what the AI looks for, or how it writes the result
Add another app, for example also send it to Slack
Combine it with other Calendly steps into one automation

Under the hood

The code that runs this automation

This is the Python script that runs each time the automation starts. Your AI assistant writes it for you when you send the prompt, and you allow each step in your assistant. To change how the automation works, describe the change to your assistant and it updates the script for you. For every function it can use, see the script reference.

ai_pre_call_brief.pyexample

from datetime import datetime, timedelta, timezone
from clickruntime import on_trigger, credentials, http, state, ai, notify

API = "https://api.calendly.com"

@on_trigger
def run(event):
    h = {"Authorization": f"Bearer {credentials.secret('CALENDLY_TOKEN')}"}
    me = http.get(f"{API}/users/me", headers=h).json()["resource"]["uri"]
    now = datetime.now(timezone.utc)
    events = http.get(f"{API}/scheduled_events", headers=h, params={
        "user": me, "status": "active",
        "min_start_time": (now + timedelta(minutes=30)).isoformat(),
        "max_start_time": (now + timedelta(minutes=45)).isoformat(),
    }).json()["collection"]
    sent = state.get("briefed") or []
    for ev in events:
        if ev["uri"] in sent:
            continue
        uuid = ev["uri"].rsplit("/", 1)[-1]
        invitees = http.get(f"{API}/scheduled_events/{uuid}/invitees", headers=h).json()["collection"]
        notes = "\n".join(f"{i['name']} <{i['email']}>: " + "; ".join(f"{q['question']}: {q['answer']}" for q in i.get("questions_and_answers", [])) for i in invitees)
        brief = ai.generate(f"Meeting: {ev['name']}\n{notes}", system="Write a 4-line pre-call brief: who they are, what they want, two questions to ask.", max_output_tokens=250).text
        notify.email_me(f"Brief: {ev['name']} at {ev['start_time'][11:16]} UTC", brief)
        sent.append(ev["uri"])
    state.set("briefed", sent[-200:])
    return {"briefs": len(events)}

FAQ

Common questions

How far ahead is the brief sent?

It looks for events starting between 30 and 45 minutes from the check, so the brief arrives with roughly half an hour or more to spare. The window can be changed if you prefer more lead time.

What if the invitee did not answer any questions?

The brief then relies on the little Calendly does provide, such as name, event type and time, and says so plainly. For more useful briefs, add a couple of short questions to your Calendly event type.

Does the AI look up information about the invitee online?

No. The brief is built from the details in the Calendly booking, such as the invitee's answers. It does not browse the internet or invent facts. Adding a lookup step would be a separate change that needs your approval.

What permissions does it need?

PAT (read). Nothing else in your accounts is used.

Does it need AI?

Yes. It uses ClickRuntime's built-in AI, so you don't need an OpenAI or Anthropic key. Every plan includes a monthly AI allowance.

How many runs does it use?

One run each time it runs (every 15 minutes). Checks that find nothing to do and stop right away aren't counted.

Can I change how it works?

Yes. Describe the change to your AI assistant, for example a different schedule, channel or filter. It updates the automation, tests it and tells you what changed.

On a schedule