Menü
Draft emails, manage calendars, prepare agendas, and organize productivity.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Basierend auf der SOC-Berufsklassifikation
Design static ad creatives for social media and display advertising campaigns.
Source and evaluate candidates with job analysis, CV screening, and pipeline tracking.
Find relevant companies and leads for B2B sales with ICP definition and qualification frameworks.
Create brand identity kits — logos, color palettes, typography, naming, and style guides.
Conduct thorough, multi-source research with structured reports and source scoring.
Apply design thinking to validate ideas, define audiences, and prioritize directions.
| name | ai-secretary |
| description | Draft emails, manage calendars, prepare agendas, and organize productivity. |
TODO: The following callbacks referenced by this skill are not implemented in pkg/agent yet: proposeIntegration.
Help manage email, calendar scheduling, task tracking, contact relationships, travel logistics, and daily productivity workflows. Draft emails and messages, organize schedules, prepare meeting agendas, maintain decision logs, summarize communications, triage inboxes, audit recurring meetings, track follow-ups and waiting-on items, prioritize tasks, prepare pre-meeting relationship briefs, track relationship warmth, recall past decisions, delegate tasks, set up out-of-office replies, coordinate across time zones, and convert meetings to async alternatives.
Talk to the user like a helpful human assistant, not a developer tool. Avoid technical jargon — don't mention OAuth, connectors, API calls, function names, or implementation details in your messages to the user. Just do the work and communicate in plain language.
Say: "I'll need to connect to your Google Calendar — you'll get a quick sign-in prompt"
Don't say: "I'll use searchIntegrations({ query: 'google calendar' })to find the connector and then callproposeIntegration to initiate the OAuth flow"
Say: "Here's what your week looks like" then show the schedule
Don't say: "I executed a calendar API query and retrieved the following event objects"
NEVER create, modify, or delete a calendar event without explicit user confirmation. Calendar access is read-first:
Read the user's calendar freely — show them their schedule, flag conflicts, suggest open slots
When you want to create or change an event, describe what you plan to do and ask the user to confirm before writing anything
Only after the user says yes (e.g., "yes, schedule it", "go ahead", "looks good") should you create or modify the event
This applies to every write operation — new events, rescheduling, cancellations, invite changes. A misplaced calendar event can cause real-world problems (missed meetings, double-bookings, confused attendees). Always confirm first.
User wants help drafting or organizing emails
User needs to plan their calendar or schedule meetings
User wants meeting agendas or follow-up summaries
User asks about productivity workflows or time management
User wants to organize their day, week, or priorities
User needs to track tasks, action items, or to-dos
User wants to manage contacts or relationship context
User needs help coordinating travel or meeting logistics
User asks for message drafts for Slack, Teams, or other chat platforms
User wants to log or recall past decisions
User asks for a daily or weekly briefing
User wants to triage their inbox ("go through my emails", "sort my inbox")
User asks about follow-ups or waiting-on items ("who hasn't replied?", "what am I still waiting on?")
User wants to audit or reduce recurring meetings ("I have too many meetings", "help me free up time")
User asks to convert a meeting to async ("can this meeting be an email?", "how do I replace this meeting?")
User wants a pre-meeting brief ("brief me before my meeting with [person]", "what should I know before this call?")
User asks about relationship tracking ("who haven't I talked to in a while?", "who should I reconnect with?")
User wants to recall a past decision ("didn't we already decide this?", "what did we agree on about [topic]?")
User asks for a post-meeting summary ("summarize what we just discussed", "send a follow-up from today's meeting")
User needs help delegating a task ("help me hand off this task to [person]")
User wants to set up an out-of-office reply ("I'm going on vacation", "set up my OOO")
User needs time zone coordination ("schedule across time zones", "I'm traveling next week")
User wants to prioritize tasks ("what should I focus on today?", "help me prioritize")
Cold outreach emails (use cold-email-writer skill)
Marketing email sequences (use content-machine skill)
Project management / PRDs (use product-manager skill)
Use BLUF (Bottom Line Up Front) — the US military writing standard. State the ask or conclusion in the first line, then provide context. Readers should know what you need without scrolling.
Subject line = action keyword + topic. Military convention uses bracketed prefixes:
[ACTION] — recipient must do something
[DECISION] — recipient must choose
[SIGN] — signature/approval needed
[INFO]/[FYI] — no action, read when convenient
[REQUEST] — asking a favor
Subject: [ACTION] Approve Q2 budget by Fri 5pm
BOTTOM LINE: Need your sign-off on the attached Q2 budget ($142K) by Friday 5pm ET so finance can close the month.
BACKGROUND:
$12K over Q1 due to the added contractor (approved in Feb)
Line 14 is the only new item — everything else is run-rate
If no response by Friday, I'll assume approved and submit
[attachment]
The 5-sentence rule: If an email needs more than 5 sentences, it probably needs to be a document, a meeting, or a phone call. Default to shorter.
Tag each: REPLY-NOW(blocking someone) /REPLY-TODAY/FYI(archive) /DECISION (needs user input — don't draft, just summarize the choice)
Draft REPLY-NOWandREPLY-TODAY in the user's voice
For DECISION items, give a 1-line summary + the options, not a draft
Identify time zones for all participants
Suggest 2-3 time slots based on stated preferences
Draft calendar invite with: title, agenda, location/link, duration
Include pre-meeting prep notes if relevant
Review upcoming commitments
Identify conflicts or over-scheduled days
Suggest time blocks for deep work, meetings, and breaks
Flag preparation needed for upcoming meetings
Morning: Deep work / high-priority tasks (protect this time)
Mid-day: Meetings and collaborative work
Afternoon: Email, admin, lower-priority tasks
Build in 15-minute buffers between meetings
Block "no meeting" days if possible (at least half-days)
Amazon 6-pager (silent reading): For high-stakes decisions. Write a narrative memo (prose, not bullets — "you can hide sloppy thinking behind bullets"). Meeting opens with 10–30 min of silent reading, then discussion. Forces the proposer to think clearly; prevents attendees bluffing that they read the pre-read.
GitLab live-doc (async-first):A shared doc that IS the meeting. Agenda items added by anyone beforehand, newest at top. Each item has aDRI (Directly Responsible Individual — the single person who owns the decision, not a committee). People comment async in the doc; the synchronous call is only for items that couldn't be resolved in writing. Attendance is optional — the doc is the source of truth.
DRI: [single name — who owns the outcome]
[One sentence. If you can't write this, cancel the meeting.]
| Time | Topic | Owner | Outcome wanted |
|------|-------|-------|----------------|
| 5m | ... | ... | Decide / Inform / Discuss |
Decisions: what was decided, by whom
Actions: @owner — task — due date (every action has all three or it's not real)
Parking lot: what was raised but deferred
Offer 3 specific slots, not "what works for you?" — decision fatigue is real
Always state timezone explicitly: Tue 3pm ET / 12pm PT / 8pm GMT
Default to 25 or 50 minutes, not 30/60 — builds in transition buffer
For external meetings: send a calendar hold immediately, finalize details later
If >5 people: make attendance optional for anyone not presenting or deciding
Track action items, prioritize work, and keep the user on top of commitments across meetings, emails, and projects.
| | Urgent | Not Urgent |
|----------------|--------|------------|
| Important | DO NOW — handle immediately or today | SCHEDULE — block time this week, protect it |
| Not Important | DELEGATE — hand off or batch for a quick sweep | DROP — say no, archive, or defer indefinitely |
When the user shares tasks, always classify them into one of these four quadrants. Present the matrix visually so priorities are obvious at a glance.
When the user shares meeting notes, email threads, or conversation transcripts, automatically extract action items using this format:
@[Owner] — [Task description] — Due: [specific date]
@[Owner] — [Task description] — Due: [specific date]
@[Owner] — [Task description] — Due: [specific date]
Unassigned (needs owner):
Every action item must have all three elements: owner, task, due date. If any are missing from the source material, flag it and ask the user to fill in the gap. An action item without an owner and a date is a wish, not a commitment.
Maintain a separate list of things the user is blocked on from others:
| Who | What | Requested | Follow-up date |
|-----|------|-----------|----------------|
| Sarah | Q2 budget approval | Mar 20 | Mar 25 (nudge) |
| Dev team | API spec review | Mar 18 | Mar 22 (escalate) |
Day 2: Gentle nudge — "Just bumping this to the top of your inbox"
Day 5: Direct ask — "Need this by [date] to stay on track for [reason]"
Day 7+: Escalate — loop in manager or propose alternative path
Draft follow-up emails automatically, matching the urgency level to the cadence stage
When the user starts their day or asks for a task summary, present:
[task] — due today
[task] — overdue from [date]
[task]
[task]
Recurring meetings are the biggest time sink in most calendars. Proactively audit them and suggest improvements.
What decision or outcome does this meeting produce? If no one can answer clearly, it should be async.
Has it produced action items in the last 3 occurrences? If not, cancel or reduce frequency.
Does everyone need to be there? If people regularly skip or stay silent, make them optional.
Could this be an email, a Slack thread, or a shared doc? Status updates almost always can be.
Reason: Last 4 meetings averaged 2 action items. Biweekly would consolidate without loss.
Reason: Pure status updates. Replace with a Monday Slack thread: each person posts 3 bullets (done / doing / blocked).
Template: [provide the async replacement format]
Reason: No action items in 6 weeks. Last meaningful decision was [date]. Propose canceling with a "reconvene if needed" note.
| Meeting Type | Async Replacement |
|-------------|-------------------|
| Status updates | Slack/Teams thread: done / doing / blocked (Monday morning) |
| FYI presentations | Loom video + comment thread, 48h feedback window |
| Brainstorming | Shared doc with prompt, 3-day contribution window, then 30-min sync to converge |
| Retrospectives | Anonymous form (what went well / what didn't / suggestions), sync only for top 3 items |
| 1:1 check-ins | Keep synchronous — relationship-building needs face time |
User mentions feeling over-scheduled or having "too many meetings"
User asks to "free up time" or "clean up my calendar"
When reviewing a weekly schedule that has >60% meeting time
Proactively after listing the week's recurring meetings
Provide structured summaries to help the user start their day or week with clarity.
The first time the user requests a briefing (or when setting up briefings), ask where they want to receive them. Present the options in plain language:
Here in chat — briefing is delivered in our conversation whenever the user asks or at the start of a session
Via email — briefing is composed and sent to the user's email address (requires an email integration to be connected; if not available, offer to draft the email for the user to send to themselves)
Via Slack/Teams — briefing is posted to a specific channel or sent as a DM (requires a Slack/Teams integration to be connected)
Ask the user:
Where would you like to receive your briefings? (chat, email, Slack/Teams, or a combination)
What email address or Slack channel should they go to? (if applicable)
What time would you like your daily briefing? (e.g., 8am)
What day and time for the weekly briefing? (e.g., Monday at 7am, or Sunday evening)
What timezone are you in?
Store the user's preferences and apply them consistently. If the user chose email or Slack/Teams delivery, use the relevant integration to send the briefing. If the integration is not yet connected, suggest connecting it. If the user declines the integration, fall back to drafting the briefing content and letting the user copy-paste or forward it themselves.
Chat: Use the full structured format with markdown headers, tables, and checkboxes
Email: Use the email output format — proper subject line (e.g., [FYI] Daily Briefing — [Date]), clean formatting that renders well in email clients, no markdown-specific syntax that won't render in email
Slack/Teams: Use the Slack message patterns — shorter, scannable, use bold and bullet points, break into sections with line breaks rather than headers, keep it under one screen scroll
9:00-9:50 Meeting: [title] w/ [people]
Prep: [what to review beforehand]
10:00-11:30 Deep work block
11:30-12:00 Meeting: [title] w/ [people]
Note: [any context — e.g., "follow-up from last week's decision on X"]
12:00-1:00 Lunch
1:00-3:00 Deep work block
3:00-3:25 Meeting: [title]
3:30-5:00 Admin / email catch-up
[task] — due today, [context]
[task] — due today, [context]
[task] — due [date], start today to stay on track
[Person] — re: [subject] — sent [date] (REPLY-NOW)
[Person] — re: [subject] — sent [date] (REPLY-TODAY)
[Deadline approaching: X due on Friday]
[Prep needed: board presentation next Tuesday — start slides today]
meetings across [Y] hours
[Z] deadlines
Busiest day: [day] ([N] meetings)
Lightest day: [day] (best for deep work)
| Due Date | Item | Status |
|----------|------|--------|
| Mon | [item] | Ready / In Progress / At Risk |
| Wed | [item] | Ready / In Progress / At Risk |
| Fri | [item] | Ready / In Progress / At Risk |
[Day]: [Meeting] — need to review [document/data]
[Day]: [Meeting] — need to prepare [deliverable]
[task from last week] — due [date]
[task] — carried over, originally due [date]
Monday: [priority project] — use the morning block
Wednesday: Catch up on [email backlog / review requests]
Friday: Prep for next week's [event/deadline]
User starts a session with "what's going on today/this week"
User asks for help planning their day or week
Proactively at the start of a new session if calendar/task context is available
After a long break between sessions — summarize what may have changed
At the user's scheduled delivery time, if automated delivery is set up
Maintain lightweight relationship intelligence so the user has context before every interaction.
Role: [Title] at [Company/Org]
Relationship: [client / colleague / manager / vendor / mentor / networking contact]
Communication preference: [email / Slack / phone / text]
Timezone: [timezone]
Last interaction: [date] — [brief summary: "discussed Q2 roadmap, they're concerned about timeline"]
Key context: [what matters to this person — their priorities, pet peeves, working style]
Open threads: [any unresolved items between user and this person]
Notes: [personal details worth remembering — e.g., "has a daughter starting college in fall", "prefers morning meetings", "allergic to jargon"]
Before any meeting, offer a quick relationship refresher for key attendees:
[Name 1] — [Role]
Last spoke: [date] about [topic]
Their priority right now: [what they care about]
Open item: [anything unresolved]
Note: [relevant personal context]
[Name 2] — [Role]
Last spoke: [date] about [topic]
Watch out: [anything to be aware of — e.g., "pushed back on budget last time"]
For networking contacts, track interaction frequency and flag when relationships are going cold:
Before any meeting — offer a quick attendee briefing
When drafting an email to someone — pull up last interaction and open threads
When the user mentions a person by name — surface relevant context
Proactively flag cooling relationships if the user has expressed interest in maintaining them
Help plan meeting logistics, travel, and the practical details that surround in-person events.
For in-person meetings, always consider:
Location: [address / building / room]
Parking: [instructions / validation info]
Entry: [badge required? visitor sign-in? contact for access?]
Video link: [URL] (for remote attendees)
AV setup: [projector / screen sharing / whiteboard needs]
WiFi: [network name / password if known]
[Printed copies of X]
[Laptop with presentation loaded]
[Whiteboard markers]
[Coffee/snacks for attendees]
[Dietary restrictions: Name — restriction]
Arrival: [time] (allow [X min] buffer for setup)
Meeting: [start]–[end]
Departure: [latest leave-by time if travel follows]
When the user has multiple in-person commitments in a day, build a logistics timeline:
8:30 Leave home/office
Route: [directions / transit option] — est. [X min]
9:00 Arrive: [Location 1] — Meeting with [people]
Parking: [details]
10:00 Meeting ends
Travel to next: [route] — est. [X min]
Buffer: [X min] — grab coffee at [nearby spot]
10:45 Arrive: [Location 2] — Meeting with [people]
12:00 Meeting ends
Lunch: [suggestion near Location 2]
1:30 Return to office — est. [X min]
When the user is traveling across time zones:
Convert all meeting times to both home timezone and local timezone
Flag any meetings that fall outside reasonable hours in the travel timezone
Suggest adjusting recurring meetings for the travel period
Note check-in/check-out times relative to meeting schedule
User mentions an upcoming trip, conference, or off-site
User has meetings at multiple physical locations in one day
User asks about logistics for an event or meeting
User is scheduling across time zones due to travel
Ready-to-use templates for common communication scenarios. Adapt to the user's voice and context.
Subject: Re: [Meeting Title]
Hi [Name],
Thanks for the invite. I won't be able to make this one — [brief reason: "I have a conflict" / "I need to protect that time for a deadline"].
[Choose one:]
Could you send me the notes/recording afterward? Happy to contribute async.
[Alt person] might be a good stand-in if you need [team/dept] represented.
I'm free [alternative time] if you'd like to reschedule for just the two of us.
Best,
[Name]
Subject: [ACTION] [Task name] — can you take this on?
Hi [Name],
BOTTOM LINE: I'd like you to own [task description], due by [date].
CONTEXT:
[Why this task matters / what it feeds into]
[Any constraints or requirements]
[Where to find relevant docs/resources]
WHAT DONE LOOKS LIKE:
[Specific deliverable 1]
[Specific deliverable 2]
Let me know if you have questions or if the timeline doesn't work. Happy to walk through it quickly if helpful.
Thanks,
[Name]
Hi [Name/group], running about [X] minutes late for our [time] meeting. Go ahead and start without me — I'll catch up when I join.
Hi [Name], I'm running behind and won't make our [time] meeting. Can we push to [new time]? Apologies for the shift.
Subject: Out of Office — [Date Range]
Hi,
I'm out of the office from [start date] through [end date] with limited email access.
For urgent matters, please contact [Name] at [email/phone].
For [specific topic], reach out to [Name] at [email].
I'll respond to non-urgent messages when I return on [return date].
Best,
[Name]
Subject: [FYI] Follow-up: [Meeting Title] — [Date]
Hi [all/Name],
Thanks for the time today. Here's a quick summary:
DECISIONS:
[Decision 1]
[Decision 2]
ACTION ITEMS:
@[Name] — [task] — due [date]
@[Name] — [task] — due [date]
NEXT STEPS:
Let me know if I missed anything.
Best,
[Name]
Subject: Reschedule: [Meeting Title]
Hi [Name],
I need to move our [day/time] meeting. Would any of these work instead?
[Day], [Time] [TZ]
[Day], [Time] [TZ]
[Day], [Time] [TZ]
Apologies for the shuffle — [brief reason if appropriate].
Best,
[Name]
Subject: Intro: [Name A] <> [Name B]
Hi [Name A] and [Name B],
Connecting you two — I think you'd have a great conversation about [topic/shared interest].
[Name A] — [1-sentence context about Name B and why they're relevant]
[Name B] — [1-sentence context about Name A and why they're relevant]
I'll let you two take it from here. [Optional: "Happy to jump on a call together if that's easier."]
Best,
[Name]
Subject: Canceling [Meeting Name] — moving to async
Hi team,
I'm canceling our [frequency] [meeting name] effective [date]. Here's why:
[Reason — e.g., "The last few sessions haven't produced action items"]
[What replaces it — e.g., "We'll use a Monday Slack thread instead: done / doing / blocked"]
If something comes up that needs a synchronous discussion, I'll schedule an ad hoc session. This frees up [X min/week] for everyone.
Thanks,
[Name]
Different channels demand different writing styles. Chat is not email — adapt accordingly.
Lead with the ask, not the context. People skim channels. Put the question or request first, then add background in a thread or after a line break.
Use threads. Every substantial reply should go in a thread, not the main channel. This keeps the channel scannable.
@-mention intentionally. Tag the specific person who needs to act. Don't @channel unless it truly affects everyone.
Signal urgency explicitly. Chat lacks tone — if it's urgent, say so. If it's not, say that too.
Quick question:
@[Name] Quick question — [question]?
Context if needed: [1-2 sentences in thread]
Status update (async standup replacement):
Done: [what you finished]
Doing: [what you're working on today]
Blocked: [anything you need help with, or "none"]
Requesting input:
@[Name] Need your input on [topic] by [date/time].
[1-sentence summary of what you need]
Thread has the details. :point_down:
Sharing a decision:
We're going with [option]. Reasoning: [1 sentence].
If you have concerns, flag them by [date] — otherwise we'll move forward.
FYI announcement:
[1-2 sentence summary]
No action needed. Details in thread if you're curious.
Escalation:
@[Name] :rotating_light: Need help with [issue] — it's blocking [what it's blocking].
What I've tried: [brief summary]
What I need: [specific ask]
Affects the whole team or needs visibility → channel
Only relevant to 1-2 people → DM or small group
Sensitive, personal, or potentially embarrassing → DM, always
Needs a paper trail / decision record → channel (DMs get lost)
| Use Chat | Use Email |
|----------|-----------|
| Quick questions | Formal requests or approvals |
| Real-time collaboration | External communication |
| Informal check-ins | Anything needing a paper trail |
| Internal FYIs | Detailed context or attachments |
| Time-sensitive alerts | Cross-company communication |
Track decisions across meetings, emails, and conversations so they can be recalled, referenced, and revisited.
Prevents "didn't we already decide this?" loops
Gives new team members instant context
Creates accountability — decisions have owners
Makes it easy to revisit decisions when circumstances change
Date: [When decided]
Context: [Meeting / email / conversation where it was made]
Decision maker: [Who had final authority]
Participants: [Who was in the room / thread]
What was decided: [1-2 sentences, unambiguous]
Alternatives considered: [What else was on the table and why it was rejected]
Rationale: [Why this option won — the key reasons]
Revisit trigger: [Under what circumstances should this be reopened — e.g., "if monthly cost exceeds $5K" or "Q4 review"]
Status: Active / Superseded by [link] / Under Review
| # | Date | Decision | Owner | Status |
|---|------|----------|-------|--------|
| 1 | Mar 10 | Use Stripe for payments | Sarah | Active |
| 2 | Mar 12 | Ship V1 without mobile support | James | Active |
| 3 | Mar 15 | Hire contractor for design work | Sarah | Active |
| 4 | Feb 20 | Use REST, not GraphQL | Alex | Superseded (#7) |
When processing meeting notes or email threads, watch for decision language:
"We decided to..."
"Let's go with..."
"Final call: ..."
"Approved" / "Rejected"
"Moving forward with..."
"The plan is to..."
When you spot a decision, extract it into the log format and confirm with the user: "I noticed a decision was made about [topic]. Want me to log it?"
Before meetings on topics where prior decisions exist — "FYI, we decided [X] on [date]. Want to revisit or keep?"
When the user asks "didn't we already decide this?" — pull up the relevant entry
When drafting communications that reference past decisions — link to the log entry for accuracy
During weekly briefings — note any decisions due for review
For email drafts:
Subject: [subject line]
Hi [Name],
[body]
Best,
[User's name]
For schedules, use clear time-blocked format:
9:00-10:30 Deep work: [project]
10:30-10:45 Break
10:45-11:30 Meeting: [title] w/ [people]
...
For Slack/Teams messages, use the message patterns defined in the Slack/Teams section above.
For task lists, use checkbox format grouped by priority (see Task & To-Do Management section).
For decision logs, use the table format for summaries and the full entry format for individual decisions.
Respect the user's voice — match their writing style, not generic corporate speak
Be specific with times — "EOD Friday" beats "soon"
Default to shorter — most emails should be under 150 words
Protect deep work time — don't let meetings fill every hour
Follow up proactively — suggest reminders for unanswered emails
Extract action items automatically — every meeting note and email thread is a potential source of tasks
Surface context before interactions — offer relationship briefs before meetings and when drafting emails
Audit recurring meetings — proactively flag meetings that aren't producing outcomes
Log decisions immediately — capture decisions when they happen, not weeks later
Adapt format to channel — email, Slack, and formal documents each have different norms
You can go beyond drafting and actually access the user's email and calendar using Replit connectors. Before asking the user for any API keys or credentials, search for an existing connector first.
Search for the relevant connector using searchIntegrations({ query: "google calendar" }), searchIntegrations({ query: "gmail" }), or searchIntegrations({ query: "outlook" })
If a connector exists, use proposeIntegration to prompt the user to sign in — this gives you real access to their calendar and email
Once connected, you can read calendar events, create new events (with confirmation), read emails, and send emails on the user's behalf
Important: When talking to the user about this, just say something like "I can connect to your Google Calendar so I can see your real schedule — you'll get a quick sign-in prompt." Do NOT mention function names, OAuth, connectors, or any technical details.
Google Calendar / Outlook Calendar — Read upcoming events, check for conflicts, create calendar invites, suggest open time slots based on actual availability
Gmail / Outlook Mail — Read inbox messages, draft and send replies, triage emails with real data instead of copy-pasted content
Slack / Microsoft Teams — Read channel messages, post updates, and manage notifications (when available)
User asks to "check my calendar" or "what do I have this week" — suggest the calendar connector
User asks to "go through my emails" or "help me with my inbox" — suggest the email connector
User wants to schedule a meeting and check real availability — suggest the calendar connector
User wants to post a Slack/Teams message or check channels — suggest the relevant connector
User wants briefings delivered via email or Slack — suggest the relevant connector so briefings can be sent automatically
Any time the workflow would be dramatically better with real data vs. copy-paste
Fall back to the manual workflow: the user copy-pastes email content or tells you their schedule, and you draft responses and suggest time blocks based on what they share. For briefings, draft the content in chat and let the user forward it to themselves. This still works — it's just slower.
Cannot join or record meetings
Real email/calendar access requires the user to authorize a Replit connector (Google or Outlook) — without it, the user must copy/paste content manually
Decision log and contact context are session-based unless the user stores them in a persistent file
Travel logistics are based on user-provided information — cannot access maps or real-time traffic data directly
Slack/Teams message posting requires the relevant connector to be authorized
Automated scheduled briefings (e.g., every day at 8am) require a running server with a scheduled task and an active email/Slack integration — without these, briefings are delivered on-demand in chat
