Build a Conference Agenda
Turns accepted sessions, rooms and speaker availability into a conflict-checked multi-track agenda with capacity and transition checks, plus an import-ready CSV.
- Content & speakers
- advanced
- CSV
- Google Sheets
Example prompts
Once the skill is added, start a chat with one of these and attach your file if you have one.
Schedule these 64 sessions into 5 rooms over 2 days. Speakers' availability is in column F.
Check our draft agenda for conflicts and sessions that will be over capacity.
Export the final agenda as a CSV our event app can import.
What this skill does
This skill schedules accepted sessions into rooms and time slots for a multi-track conference or user conference. It places keynotes and contracted sponsor slots first, then fills the rest hardest-first while respecting speaker availability, room capacity and session length, and tries to keep tracks and popular sessions from clashing.
It can also check a draft someone already built. Either way you get an issues table covering double-booked speakers and rooms, over-capacity rooms, plenary clashes, same-track clashes and tight transitions, with options for each, plus an agenda grid and a CSV in your event app's import format.
When to use it
- Scheduling sessions for a multi-track conference
- Checking a draft agenda for speaker and room conflicts
- Finding sessions that will overflow their rooms
- Balancing tracks across days of a user conference
- Preparing an agenda import file for your event app
How it works
- 1Normalize inputsReads sessions, rooms and slots, counts room-slots and stops early if there isn't enough space.
- 2Place fixed itemsPuts keynotes and contracted sponsor sessions where they must go and blocks plenary slots.
- 3Fill the gridPlaces the hardest sessions first using hard rules for capacity, length and availability and soft rules for balance.
- 4Check for conflictsLists every remaining issue with its cause and two options, using an optional Python script for the checks.
- 5ExportBuilds a grid per day, a speaker schedule and a CSV that matches your event app's import template.
What you'll need
- Accepted sessions with length, track, speakers and expected attendance
- Rooms with capacity and zone
- Days and time slots, including plenary slots
- Speaker unavailability and pinned sessions
What you get
A summary of sessions placed and unplaced, an agenda grid per day, an issues table with options, a track balance table, a speaker schedule and an import-ready CSV with dates, 24 hour times, time zone, rooms, tracks and speakers.
Tips
- Give the room capacity for the planned setup, not the fire-code maximum.
- Use pre-registrations, bookmarks or last year's attendance to estimate demand.
- Paste a sample row from your event app's import template so the CSV matches it.
- Confirm the final grid before telling speakers their times.
What's in the download
agenda-builder/SKILL.md7.7 KBagenda-builder/assets/sample-rooms.csv111 Bagenda-builder/assets/sample-sessions.csv2.9 KBagenda-builder/assets/sample-slots.csv338 Bagenda-builder/references/app-import-format.md1.6 KBagenda-builder/references/scheduling-rules.md2.5 KBagenda-builder/scripts/agenda.py13.0 KB
Read the SKILL.md
---
name: agenda-builder
description: Builds and checks multi-track conference and user conference agendas. Places accepted sessions into rooms and time slots using speaker availability, room capacity, track balance, audience level, keynotes and sponsor commitments, flags conflicts such as double-booked speakers, popular sessions clashing, over-capacity rooms and too-short transitions, and outputs a schedule grid plus an import-ready CSV for an event app. Use for agenda building, session scheduling or checking a draft schedule for conflicts.
license: MIT
metadata:
author: eventmarketingsoftware.com
version: "1.0"
category: content-and-speakers
source: https://eventmarketingsoftware.com/skills/agenda-builder
---
# Agenda Builder
Turns a list of accepted sessions, rooms and time slots into a conflict-free agenda, or checks a draft someone already built. It explains every placement problem it can't solve so a human can make the trade-off, and it exports a clean CSV your event app or agenda tool can import.
## Intake
If the user has an `event-context.md` file, read it first and don't ask for anything it already answers.
Ask for whatever is missing in ONE message:
1. Sessions: ID, title, track, format, length, speakers, expected attendance (or a popularity signal like CFP score or pre-registrations), level.
2. Rooms: name, capacity in the expected setup (theater, classroom, rounds), zone or floor if rooms are far apart.
3. Day structure: days, dates, slot start and end times, breaks, lunch, and which slots are plenary (keynotes, closing).
4. Constraints: speaker unavailability, pinned sessions (keynotes, sponsor slots with a promised time or room), sessions that must not overlap (same audience), sessions that should follow each other.
5. Goals: track balance across days, beginner content early, no track twice in one slot, minimum transition time between rooms (default 10 minutes).
6. Build from scratch, or check an existing draft? If checking, the draft with session ID, day, start and room.
7. Target import format, if they have one (paste the column list or a sample row from their event app).
Work with partial data. If expected attendance is missing, ask for any proxy; otherwise treat all sessions as equal and say so.
## Data sources (connectors optional)
- If a Google Sheets connector is available, read the sessions, rooms and slots tabs and offer to write the agenda to a new tab. Never overwrite the source tabs.
- Otherwise, work from uploaded CSV or XLSX files or pasted tables and return a Markdown grid plus a downloadable CSV.
- Never require a paid service. Don't fetch URLs.
Sample files for testing: [assets/sample-sessions.csv](assets/sample-sessions.csv), [assets/sample-rooms.csv](assets/sample-rooms.csv), [assets/sample-slots.csv](assets/sample-slots.csv).
## Method
1. **Normalize inputs.** One row per session, lengths in minutes, speaker names split and trimmed, room capacities as numbers, slots as day, date, start, end. Report counts: sessions, rooms, slots, room-slots available. If sessions exceed room-slots, stop and say how many must be cut or added.
2. **Place fixed items first.** Plenary sessions block every room in their slot. Pinned sponsor or partner sessions go where the contract says.
3. **Place the rest, hardest first.** Order: sessions with the most unavailability, then highest expected attendance, then multi-speaker sessions. For each, pick the slot and room that:
- fits length and capacity (hard rules)
- doesn't double-book any speaker or room (hard rules)
- respects speaker unavailability (hard rule)
- avoids the same track twice in one slot and two popular sessions (top 20% by expected attendance) at once (soft rules)
- uses the smallest room that fits, and spreads tracks across days (soft rules)
Apply the full rule set in [references/scheduling-rules.md](references/scheduling-rules.md).
4. **Run the checks** on the result (or on the user's draft): speaker double-booking, room double-booking, over capacity, too long for slot, unavailable speaker, clash with a plenary, same track clash, popular sessions clash, short breaks, tight speaker transitions between rooms or zones.
5. **Explain what's left.** For each unplaced session or remaining issue, give the cause and two options (e.g. "S-131 expects 700 and the largest room seats 600: move to the plenary slot on Day 2, or cap registration and add an overflow stream").
6. **Export.** Build the import CSV in the user's column format, or the default in [references/app-import-format.md](references/app-import-format.md).
### Script
If code execution is available, `scripts/agenda.py` does steps 2 to 4 deterministically with the Python standard library.
```
python3 scripts/agenda.py build --sessions sessions.csv --rooms rooms.csv --slots slots.csv --out agenda.csv
python3 scripts/agenda.py check --sessions sessions.csv --rooms rooms.csv --slots slots.csv --draft draft.csv
```
Columns: sessions `session_id,title,track,length_min,speakers,expected_attendance` plus optional `level,format,unavailable,pinned,plenary`; rooms `room,capacity` plus optional `zone`; slots `day,date,start,end`. `speakers` and `unavailable` use `;` between values. `unavailable` takes a day ("Day 2") or a day and start ("Day 1 09:00"). `pinned` takes "Day 1 09:00 Main Hall". The script is greedy: it's fast and explainable, not guaranteed optimal. Review its issues list and swap sessions by hand where a better trade-off exists.
Without code execution, follow the same order in-chat and show the issues table.
Domain rules that matter:
- Hard rules are never broken silently. If something can't be placed, it's listed, not squeezed in.
- Capacity uses the room's capacity in the planned setup, not its maximum.
- Put the highest-demand breakouts in the largest rooms, but don't stack them in the same slot.
- Keep at least 10 minutes between back-to-back sessions for speakers who change rooms, more if rooms are in different zones or buildings.
- Sponsor commitments (time, room, no competing session in the same topic) are contract terms; check them explicitly.
## Output templates
**1. Summary:** sessions in, placed, unplaced; room-slots used of available; issues by type.
**2. Agenda grid** (one table per day):
| Time | [Room 1] | [Room 2] | [Room 3] | ... |
|---|---|---|---|---|
Cells: `ID Title (Track, Level)`.
**3. Issues table:**
| Issue | Sessions | Detail | Options |
|---|---|---|---|
**4. Track balance:**
| Track | Day 1 | Day 2 | Slots with two of this track |
|---|---|---|---|
**5. Import CSV** (default columns in the reference).
**6. Speaker schedule** (speaker, sessions, day, start, room) for the speaker team.
## Validation checklist
- [ ] Sessions in equals placed plus unplaced, and every unplaced session has a reason.
- [ ] No speaker or room is double-booked.
- [ ] No session exceeds its room's capacity or its slot's length.
- [ ] No breakout overlaps a plenary.
- [ ] Every pinned session is exactly where it was pinned.
- [ ] Speaker unavailability respected.
- [ ] Remaining soft-rule issues are listed with options.
- [ ] Import CSV has one row per placed session and uses the requested columns and date and time format.
## Approval gates
- Return the agenda as a draft. Never publish to an event app, website or sheet without showing it and getting a clear yes.
- Before telling speakers their times, have the user confirm the final grid; changes after speakers are told are costly.
## Privacy
- Speaker availability notes can be personal (travel, family). Keep them in the planning file only, never in the public agenda or import CSV.
- The public export includes only names and titles speakers agreed to publish.
## Related skills
cfp-review-scorer (choosing sessions), speaker-management (telling speakers their slots), event-run-of-show (running each room on the day).
FAQ
How do I schedule a multi-track conference agenda?
How can I check a draft agenda for conflicts?
Does this skill need code execution?
What format does the agenda export use?
More content & speakers skills
easy
Recruit and Brief Event Speakers
Writes speaker and customer-speaker invites, builds a deliverables tracker with a reminder schedule, drafts the reminders and produces a speaker briefing pack.
intermediate
Score Call-for-Papers Submissions
Pre-scores CFP submissions with an anchored rubric and reasons, flags product pitches and duplicates, builds a track-balanced shortlist and prepares reviewer packets.
easy
Write a Session Abstract That Gets Accepted
Turns a talk idea into a CFP-ready submission: title options, an abstract within the word limit, learning outcomes and a bio, checked against the guidelines and for pitch language.