How to Build a Meeting Prep Agent From Your Inbox

Meeting prep is the 20 minutes before a call where you try to remember who you’re meeting with, what you’ve already discussed, and what you committed to. Most people do it the same way. Open LinkedIn, scan the headline. Search Gmail, skim the top three results. Check the CRM, hope someone left notes. Walk in.

It mostly works until it doesn’t. The customer says, “as we discussed in October,” and you don’t remember what you said in October. The prospect references a concern they raised on a previous call, and you can’t place which call. The investor follows up on a commitment you made, and you have to improvise around it. Each of those is a small loss of credibility, and they compound across a quarter.

The reason your prep isn’t better is not laziness. It’s that the information is buried in long threads, forwarded chains, CC’d replies, and PDF attachments, and no human can read all of it in 20 minutes before a call. CRM notes are written by reps who half-document. Gmail search returns 50 results, and you scan three. LinkedIn tells you what the world knows about the person, not what they said to you.

So the question is whether the prep gets done well, or whether it gets done the way most people do it now, which is fast and wrong in small ways that cost real deals.

The answer is an AI agent. One prompt to your inbox, you get the brief: relationship history, last interaction, open commitments, what they care about, what to watch out for. Five seconds before each call. This post is how to build it. One afternoon, your own inbox, optionally layered with public web research via Tavily.

What good prep returns

Here is what a single briefing looks like coming out of the build:

Last spoke 12 days ago about Q1 budget timing. Open commitment: you promised the Northwind case study by Friday, but never sent. Their CTO raised security concerns twice in October, never resolved. They’ve asked about MCP support across three separate threads, that’s the real deal driver. Watch out: don’t bring up the November pricing pushback unless they raise it first. Public web: company announced Series B last Tuesday, two new VPs hired this month.

That is the brief you actually need at 8:55 on Tuesday morning.

Why build it yourself

There are SaaS prep tools that do this for $100 per seat per month. They scrape public profiles, surface recent news, and tell you the headcount and funding stage. They do the public layer well.

The part they cannot do is read your inbox. Your real relationship with the contact, every commitment, every concern, every pattern across months of threads, lives in your email and nowhere else. A third-party tool cannot get to it without OAuth into your inbox, full thread reconstruction, attachment parsing, and per-user scoping. That is a real engineering layer, and it’s the layer iGPT is.

The build is wiring iGPT to a prompt that returns the briefing format your team actually uses. That part is an afternoon. The hard work runs underneath.

The fastest way to see this work: the playground

Before any code, try it in a browser. Go to igpt.ai/hub/playground. Sign in with the inbox you want to ask about. Outlook or Gmail, OAuth, the standard “allow access” flow. Paste this prompt with a real contact and company you have a meeting with this week:

Prep me for a call with [contact name] at [company]. Cover relationship history, last interaction, open commitments from either side, concerns or objections raised historically, what they care about most, and what to prioritize or watch out for in this meeting.

Hit run. A few seconds later, the briefing comes back. No install, no setup. This is the moment most people decide whether the rest is worth their time. The playground usually surfaces at least one thing you’d forgotten, which is the point.

If it gave you something useful, the rest of this post is how to put it on a schedule, run it across your whole calendar, and optionally layer in public research.

Putting it in code

If you are not going to wire this into a system, the playground is enough. Skip to What you can do with this.

For the rest of you, the build runs end-to-end in well under an hour.

What you need

An iGPT API key. Get one at igpt.ai/hub, then click your profile, then API keys.

Python 3.8 or newer on your computer.

A code editor. Cursor, Claude Code, VS Code, anything you already use.

Optional, for Step 5: a Tavily API key from tavily.com.

Step 1: Install the SDK

Open your terminal. On a Mac, press Cmd+Space, type “terminal”, then press Enter. On Windows, Start menu: “Command Prompt”. Then:

pip install igptai

When the prompt comes back, you’re done.

Step 2: Make a new file and connect

In your code editor, create meeting_prep.py. Paste this:

from igptai import IGPT

igpt = IGPT(
    api_key="YOUR_API_KEY_HERE",
    user="me",
)

Replace YOUR_API_KEY_HERE with your real key. The user field is a label, call it whatever you want, it just tells iGPT which inbox the script is asking about.

Step 3: Connect the inbox (first time only)

Add this:

sources = igpt.datasources.list()

if not sources:
    auth_url = igpt.connectors.authorize()
    print(f"Connect your inbox here: {auth_url}")

Save the file. Back in the terminal, run:

python meeting_prep.py

A URL prints. Open it in your browser, sign in with Gmail or Outlook, and allow access. Indexing runs in the background. Recent threads are queryable within about a minute. You only do this once per inbox.

Step 4: Ask for the briefing

Now the actual prep call:

BRIEF_SCHEMA = {
    # The full schema is in the skills repo, linked at the bottom of this post.
    # Paste it here in your file. It is about 40 lines and covers relationship
    # summary, last interaction, open commitments, known concerns, what they
    # care about, meeting priorities, and things to watch out for.
}

contact = "Sarah Chen"
company = "Acme"

response = igpt.recall.ask(
    input=(
        f"Prepare a pre-meeting brief for a call with {contact} at {company}. "
        f"Draw on email history from the last 12 months. Cover: relationship "
        f"history and tone, last interaction, open commitments from either "
        f"side, concerns or objections raised historically, what they care "
        f"about most, and what to prioritize or watch out for in this meeting."
    ),
    quality="cef-1-high",
    output_format={"schema": BRIEF_SCHEMA},
)

print(response)

Two notes worth flagging.

quality="cef-1-high" is the higher tier, and it matters here. The agent is tracing commitments across thread replies, picking up tone shifts across months, and identifying questions that never got answered. The default tier handles narrow questions; meeting prep needs the deeper read.

The prompt is doing more than it looks. “What they care about most” forces the agent to find patterns across threads rather than just summarize the last one. “What to watch out for” surfaces the things you’d otherwise step on, like the unresolved pricing pushback or the topic the contact got terse about in September. These are the moments that make a brief useful instead of just informative.

Run it. The briefing prints to your terminal. Read it once, make sure the contact and company are right, then move on.

Step 5 (optional): Add the public web with Tavily

iGPT covers the inbox side. The public web side, recent news, funding announcements, leadership changes, and company updates, is where Tavily comes in.

pip install tavily-python

from tavily import TavilyClient

tavily = TavilyClient(api_key="YOUR_TAVILY_KEY")

public = tavily.search(
    query=f"{company} recent news funding leadership changes",
    max_results=5,
)

public_summary = "\n".join(
    f"- {result['title']}: {result['content'][:200]}"
    for result in public["results"]
)

Then pass that into the iGPT prompt as additional context:

response = igpt.recall.ask(
    input=(
        f"Prepare a pre-meeting brief for {contact} at {company}.\n\n"
        f"Public web context (recent news, leadership, funding):\n"
        f"{public_summary}\n\n"
        f"Now combine that with email history from the last 12 months. "
        f"Cover relationship history, last interaction, open commitments, "
        f"concerns, what they care about, and meeting priorities. "
        f"Flag where anything in the public news intersects with what's "
        f"happening in the email history."
    ),
    quality="cef-1-high",
    output_format={"schema": BRIEF_SCHEMA},
)

The last line is where the magic shows up. The brief now flags moments where what you know from the inbox meets what just happened in the public world. The customer who raised pricing concerns last month, whose company just announced a Series B. The prospect who said the budget was tight in Q3, whose CFO just left. The investor who passed in March whose fund just closed a new vehicle. These intersections are where meeting prep stops being information retrieval and starts being intelligence.

What you can do with this

This is where the hour earns itself.

The morning calendar sweep. Loop over today’s Google Calendar events. For each one, pull the contact and company, generate a brief, and email yourself the digest at 7am. By the time you sit down with coffee, every brief is waiting. The 9am call, where you used to scramble for context, is the one you walk into already three steps ahead.

The Slack command. Wire it to a /brief command in your team’s Slack. Type /brief Sarah Chen at Acme in any channel, and the briefing posts back to you in a DM. The whole team gets the same on-demand prep, and nobody has to rebuild the workflow.

The 30-minute warning. Trigger the brief on a calendar event 30 minutes before it starts. The brief auto-arrives in Slack or email. No clicking, no asking, just there when you need it.

The renewal call upgrade for CS. Same code, different prompt. “Brief me on the relationship with this account, focused on renewal risk, recent friction, and unresolved questions.” Five seconds before each call, your CSM walks in knowing exactly which thread to reference and which topic to avoid.

Founder prep before investor meetings. Same code again. “Brief me on every email exchange we’ve had with this investor across all of our accounts and threads.” The investor mentions a question they asked at a dinner six months ago. The founder remembers because the brief surfaced.

Each of these is a different wrapper around the same call. iGPT pulls the relationship out of your inbox. Tavily adds the public layer if you want it. Your code wraps the result in whatever your team actually uses. The hard part, the part that makes the brief usable, already happened upstream.

Try it

Run the prep prompt on your own inbox at igpt.ai/hub/playground. Pick a contact you have a meeting with this week. Write the prompt. Read what comes back. If it surfaces a commitment you’d forgotten or a concern you would have walked past, the build is worth an hour of your time.

The full meeting-prep skill, schema, and prompt template are in the skills repo at github.com/igptai/skills. Fork it, edit the prompt to match whatever your team actually needs, and ship it.

The relationship has been in your inbox the whole time. The reason meeting prep wasn’t easy on Tuesday morning was that nobody had wired it together. Now it’s a prompt, an afternoon, and a different morning routine.