Carry Decisions Into Your Next Recurring Meeting

Recurring meetings stall when nothing from last time is surfaced, so the group re-litigates settled topics. The fix is a running thread: capture each session into one folder, pull forward unresolved action items and prior decisions before the next meeting, and start from what is already settled. A decisions log with carry-forward owners turns a series into cumulative progress.

The mechanics are simple once you stop treating each session as a fresh page. Capture every meeting in the series into one shared folder. Before the next session, ask that folder what is still open and what was already decided. Then seed the new note with those unresolved items and a short decisions log, so the group opens on the gap rather than the whole topic.

Reline is built for that continuity, not for planning the calendar side of the meeting. It captures the conversation locally and bot-free, transcribes and indexes it in the cloud, and lets you query the whole series. The carry-forward lives inside your notes, where you can edit it, assign an owner, and confirm it as done or rolled forward at the next meeting.

You know the shape of it. A weekly staff meeting reopens the same budget question three sessions in a row because nobody remembers what was concluded. A recurring one-on-one re-hashes last time's action item because neither person wrote down who owned it. A standup drifts into a status readout that repeats yesterday's blockers verbatim.

The root cause is not laziness. It is that the record of the last meeting is scattered, and nothing surfaces it at the start of the next one. When the previous decision is invisible, the safest social move is to relitigate it. Continuity has to be made cheap, or the group defaults to re-covering ground.

Give every recurring series its own folder: one for the weekly staff meeting, one for each recurring one-on-one, one for the sprint standup. Every session's note lands in that folder. Over a few weeks the folder becomes the running thread for that series, and the sequence of notes is the history you can pull forward from.

Inside each note, real-time collaboration means participants can correct and add during the meeting rather than after, so the record reflects what people actually agreed. Version history keeps the running doc honest: if a decision gets quietly edited later, you can see when it changed and by whom. The thread is not a single ever-growing document but a folder of sessions that share continuity.

This is deliberately narrower than building a searchable knowledge base for your whole organization. A running thread is scoped to one series and optimized for carry-forward, not for cross-team discovery. If you want a broader repository, that is a different pattern; this one is about making the next standup start where the last one ended.

Once a series lives in one folder, folder-scoped RAG lets you ask a single question across every session at once. Ask "what action items are still open?" or "what did we decide about the pricing change?" and the answer is grounded in real transcript lines, with [m:ss] timestamps pointing back to the moment someone said it. You can click through and hear the exact exchange.

The grounding matters because it keeps the summary honest. The chat quotes the transcript rather than paraphrasing from thin air, and it is instructed against fabrication. Be clear-eyed about the limits: it is authorization-bounded and instructed against inventing content, not a guarantee that it never gets anything wrong. Treat the timestamps as the source of truth and verify anything load-bearing against the line it cites.

Access is private-by-default. Folder-scoped answers only draw from sessions the asker is actually permitted to see, because a workspace role alone grants nothing; every viewer needs an explicit, revocable grant. The recall is bounded by the same access model that protects the notes themselves.

Lenses turn a captured session into a specific output format on demand. Two carry the series forward. The Decisions Log Lens pulls the settled calls out of the transcript so the next meeting opens on what is closed. The Action Items Lens extracts the open commitments, each with an owner and a date where the conversation stated one.

The routine is to run both against the previous session, then paste the still-open items and the recent decisions into the top of the next note before the meeting starts. Carry-forward owners and dates make accountability visible: the group sees who owns what and when it is due, and can close it or roll it forward on the spot.

Most teams sit somewhere on a spectrum from no shared record to a single doc to a queryable thread. The difference shows up exactly when you need to know what is still open across a series.

A shared doc is a real improvement over scattered notes, but it still depends on someone typing the decision down in the moment and someone else scrolling back to find it. A running thread with recall closes that gap: the transcript is the record, and you ask across the whole series instead of scrolling one document.

Continuity is a habit, not a feature. A five-minute routine before each recurring meeting keeps the thread alive.

1. Open the series folder and ask what action items are still open, then read the answer against the cited timestamps.
2. Confirm each open item still has a named owner and a date; if the conversation never assigned one, assign it now.
3. For each item, decide with the owner: close it as done, or roll it forward to this session with a fresh date.
4. Run the Decisions Log and Action Items Lenses on the last session to pull the settled calls and open commitments.
5. Seed a skeleton for the new note: recent decisions at the top, carried-forward open items next, then space for today's agenda.

The point of the skeleton is that the meeting opens on the gap, not the whole topic. When the first thing everyone sees is "here is what we decided and here is what is still open," the group spends its time on movement rather than re-establishing where it left off.

Being honest about scope is the point. Reline wins on continuity from captured notes, not on automating the calendar side of the meeting.

• It does not build the calendar invite, generate a pre-meeting agenda, or auto-attach itself to an event. You capture the session; the carry-forward is a workflow inside your notes.
• It does not push carried-forward tasks into Slack, Linear, Notion, Jira, or any external tracker. That kind of task push is on the roadmap and gated off today; owners and dates live inside Reline.
• Speaker labels are energy-based Me versus Other, not named diarization. You tag who is who, and the labels carry into the note.
• Capture is local and bot-free; transcription, AI summaries, and RAG are cloud services under a data-processing agreement. Transcription covers sixty-plus languages with automatic language detection.

Reline runs on the web and as a desktop app on macOS, Windows, and Linux in beta; there is no mobile app. On macOS it can detect a meeting starting and offer to capture. Everything above is about turning captured sessions into a thread you can carry forward, which is where the tool is opinionated and strong.

If your team keeps re-covering the same ground every week, the fix is not a better agenda template. It is a running thread that surfaces what is still open and what was already decided, grounded in the words people actually said, so every recurring meeting starts from progress instead of from scratch.