Never Walk Into a Meeting Cold: Automated Pre-Meeting Briefs

You have a call in ten minutes. You open the calendar invite, recognize one name out of three, and start digging. The CRM has a contact record nobody has touched since March. The last call transcript is somewhere in your meeting recorder. There was an email thread about pricing, but it was on a colleague’s account. The meeting starts. You wing it.

Everyone wings it. Not because the information is missing, but because it is scattered across five tools and nobody has twenty minutes to reassemble it before every meeting.

This is one of the first workflows we install for almost every client, because it pays off on day one and it demonstrates what a shared memory layer is for. Here is exactly how it works, in enough detail to build it.

What a brief actually looks like

Before each meeting, a brief lands where your team already reads, in Slack, Telegram, or email. Here is the shape of one, for an external call. The names are invented; the structure is exactly what the flow produces:

10:00 · Meridian Freight · quarterly review
Who's in the room
  Sarah Okafor, Ops Director. Your champion. Last contact 6 days ago.
  Tomas Rivera, CFO. First time on a call with us.
Where things stand
  Renewal deal in negotiation. Momentum: positive since the
  March pricing decision. Value and timeline as recorded.
What we owe them
  Revised proposal (promised on the Mar 12 call). 4 days overdue.
What they owe us
  Usage data for the Q2 review (Sarah, agreed Mar 12).
Since you last met
  They opened a support ticket about the API limits (resolved).
  We decided internally to include the onboarding package.
What the engine doesn't know
  No record of a security review. If Tomas raises one, it's new.

Read that top to bottom in forty seconds, and you walk in three steps ahead: you open with the overdue proposal before they have to chase it, you know the CFO is new to the relationship, and you are not blindsided by the ticket they will definitely mention.

Notice the last section. Every line above it is grounded in a specific record, a meeting, a thread, a task, a logged decision, in your context layer, and the brief can cite each one so you can drill in. Anything the engine cannot ground goes under “what the engine doesn’t know” instead of being guessed. A brief you cannot trust is worse than no brief; the gaps section is what makes the rest believable. It is also quietly useful in itself: recurring gaps tell you which parts of the relationship are not being captured at all.

Three meetings, three briefs

The flow detects what kind of meeting it is looking at and changes shape accordingly.

External and sales calls get the account-centric brief above: roles in the deal (who is the champion, who is the blocker), stage and momentum, the last few interactions dated one line each, open commitments in both directions, live risks, and a suggested focus derived strictly from the open items. Staleness is flagged, not hidden: “no contact in five weeks” is information.

Manager 1:1s are where teams get surprised, because the brief flips to be about the relationship, and it leads with your side of the ledger:

• What you owe them. The feedback you promised, the decision they are waiting on, the blocker you said you would clear, each with how overdue. This comes first, deliberately.
• Since your last 1:1. What they shipped and worked on; wins worth acknowledging out loud.
• What they are carrying. Their open and overdue load, surfaced as context for support, not as a scorecard.
• Open threads they raised. The questions they asked three weeks ago that never got answers. Nothing erodes trust faster than these; nothing is easier to fix once they are visible.
• Growth. Longer-arc career threads if the engine holds any, with a flag if the record has gone quiet: “no growth conversation logged in 90 days.”

The framing rule is built in: the 1:1 brief is grounded in work artifacts only and frames around the manager’s responsibilities, what you owe and what to attend to, never surveillance of the report.

Team and group meetings get the shared-context version: who is in the room and why, open items and pending decisions across the group, what changed since this group last met, and a suggested agenda assembled from the open items, which regularly turns out to be better than the agenda nobody wrote.

Where the information comes from

The brief is not a product feature you switch on. It is a query against a context layer that your tools have been feeding all along. Under the hood, the assembly pass does five things:

1. Resolves the attendees from the calendar event to people the engine knows, colleagues, clients, leads, and pulls each person’s link graph: the meetings, threads, tasks, and decisions they are connected to.
2. Pulls open commitments in both directions, yours to them and theirs to you, from open tasks linked to the attendees, and flags overdue ones. A commitment in this system is a task whose record links an owner and a counterparty, which is what makes “what do we owe this account?” a precise query rather than a vibe.
3. Collects what changed since you last met, using the last meeting with these attendees as the anchor: threads, meetings, decisions, tickets in between.
4. Surfaces pending decisions and open questions involving the attendees, so the meeting can close them instead of rediscovering them.
5. Assembles and cites, recency-weighted, with the gaps section for everything it could not ground.

The sources doing most of the feeding are the ones you already run: the calendar (who and when), the CRM (accounts, deals, stages), the meeting recorder (what was actually said: objections, promises, pushback), and mail and chat as connective tissue. Each writes into the same shared memory, where records link together. By the time the brief runs, the hard work is already done. If you want the plain-language version of that layer, start with What is a context layer?

The config, shown

This is the actual starter flow we ship, not pseudocode. It runs every weekday morning and briefs the day’s meetings in one digest:

name: calendar-prep
trigger: schedule
cron: "30 7 * * 1-5"        # weekdays, 07:30
tools: [engine, googlecalendar]
confirm_first: false
prompt: |
  Read today's calendar and post a short prep brief. For each
  meeting: time, title, who's attending, and, pulled from the
  engine, the relevant context: who those people are, recent
  decisions, anything open with them. Keep it scannable. If the
  day is clear, say so.

That is the whole thing: a schedule, two tools, and a prompt a competent assistant could follow. Most teams start here, with the morning digest, and later graduate to the per-meeting variant: same architecture, but triggered an hour before each event, with the deeper retrieval pass described above and a longer brief for the meetings that deserve one.

A natural companion closes the loop at the other end of the day:

name: meeting-follow-up
trigger: schedule
cron: "0 17 * * 1-5"        # weekdays, 17:00
tools: [engine, googlecalendar]
prompt: |
  Look at today's meetings from the calendar. For each
  substantive one, ask me a short prompt: what was decided and
  what follow-ups came out of it. As I answer, capture the
  decisions (with rationale) and the follow-ups (as tasks) into
  the engine, attributed. Don't invent outcomes, only capture
  what I tell you.

Morning: briefed in. Evening: captured out. The evening capture is what makes tomorrow’s briefs better, which is the compounding loop in miniature.

Tuning it

Because the flow is plain configuration and a plain-language prompt, you tune it the way you would brief a new assistant. The knobs that matter, with the defaults we ship:

Knob	Default	Alternatives
”Since last met” anchor	last meeting with these attendees	fixed window
Recency window	60 days	30 or 90
1:1 growth section	on, flags staleness	off
Output	compact agenda	longer dossier
Scope	every meeting	external only, or 1:1s only

Want briefs only for external meetings? Say so in the prompt. Want the dossier version for board meetings and the compact one for everything else? Add a line distinguishing them.

Failure modes, and what they mean

Three ways this underwhelms, each of them diagnostic rather than fatal:

Attendees don’t resolve. The brief says “unknown attendee” because the invite used a personal address or a name the engine has never seen. This is a mapping fix, and a one-time one: once resolved, the person is known forever.

Briefs come back thin. Thin data produces a short brief, by design; the flow does not manufacture a narrative. A consistently thin brief for an account you consider important is telling you that relationship’s activity is not reaching the engine, usually a missing source. Connect the source, not a longer prompt.

The brief contradicts the CRM. Usually the brief is right and the CRM is stale, which is its own workflow: the CRM that updates itself.

What changes

The obvious win is preparation time: twenty minutes of tab-hopping per meeting becomes zero, which for someone with six meetings a day is real time back every week.

The less obvious win is what happens in the room. When you open with “last time you raised the integration timeline, here is where that stands,” the conversation starts three steps ahead. Prospects notice. Clients notice. Your own team notices, because the follow-ups from the last meeting actually get followed up. Managers may notice most of all: walking into a 1:1 already knowing what you owe your report changes the texture of the meeting from status collection to actual management.

Build this yourself

The pieces, in the order we wire them:

1. Calendar sync, so meetings and attendees flow into shared memory. This alone makes the morning digest possible.
2. A transcript source, so calls become searchable history and briefs can cite what was said. See Meeting notes that go somewhere.
3. CRM sync, if your meetings involve deals. Pairs with the CRM that updates itself.
4. The morning flow, pointed at wherever your team reads. Run it for a week, tune the prompt, then graduate to per-meeting briefs.
5. The evening follow-up flow, which feeds the decision log and task capture on the same memory.

Give it two weeks before judging. The first briefs will have gaps, because the engine is young; the gaps section will tell you exactly which sources to connect next, and the briefs sharpen visibly as history accumulates.

This is the kind of workflow we install during a transformation: we map where your meeting context actually lives, wire the sources into an engine you own, and tune the briefs with your team until they trust them. It starts with a $1,500 assessment of your workflows, credited toward the transformation if you continue.