AI Executive Assistant — Digital Personal Assistant
AI Executive Assistant automates CEO's time and communication management: incoming message prioritization, meeting preparation, email composition and sending, document summarization, team coordination. Integrates with corporate tools: Google Workspace, Microsoft 365, Slack, Notion, Zoom.
Email Management Agent
from openai import AsyncOpenAI
from pydantic import BaseModel
from typing import Literal, Optional
client = AsyncOpenAI()
class EmailClassification(BaseModel):
priority: Literal["urgent", "important", "normal", "low", "spam"]
category: Literal["action_required", "info_only", "approval_needed", "follow_up", "newsletter"]
estimated_response_time_minutes: int
summary: str
suggested_action: Optional[str]
can_delegate_to: Optional[str] # Who to delegate to
requires_ceo_attention: bool
async def process_inbox(emails: list[dict], ceo_context: str) -> list[dict]:
"""Classifies and prioritizes incoming emails"""
processed = []
for email in emails:
classification = await client.beta.chat.completions.parse(
model="gpt-4o",
messages=[{
"role": "system",
"content": f"""You are the CEO's assistant. Assess importance of incoming email.
Context: {ceo_context}
Delegate what you can to the team. CEO should only see what requires his decision."""
}, {
"role": "user",
"content": f"From: {email['from']}\nSubject: {email['subject']}\nBody: {email['body'][:500]}"
}],
response_format=EmailClassification,
temperature=0,
)
processed.append({
**email,
"classification": classification.choices[0].message.parsed.model_dump(),
})
# Sort by priority
priority_order = {"urgent": 0, "important": 1, "normal": 2, "low": 3, "spam": 4}
return sorted(processed, key=lambda x: priority_order[x["classification"]["priority"]])
Meeting Preparation
class MeetingPreparationAgent:
async def prepare_briefing(
self,
meeting: dict,
participants: list[dict],
relevant_docs: list[str] = None,
) -> str:
"""Creates briefing for CEO before meeting"""
# Gather context
participant_profiles = await asyncio.gather(*[
self.get_participant_context(p) for p in participants
])
docs_summary = ""
if relevant_docs:
docs_summary = await self.summarize_documents(relevant_docs)
briefing = await client.chat.completions.create(
model="gpt-4o",
messages=[{
"role": "system",
"content": "Create brief briefing for CEO before meeting. Format: meeting goal, key participants (briefly), agenda, what needs to be decided, open issues."
}, {
"role": "user",
"content": f"""Meeting: {meeting['title']}
Date/time: {meeting['datetime']}
Participants: {json.dumps(participant_profiles, ensure_ascii=False, indent=2)}
Document context: {docs_summary}
Interaction history: {await self.get_interaction_history(participants)}"""
}],
)
return briefing.choices[0].message.content
async def get_participant_context(self, participant: dict) -> dict:
"""Context on participant: role, recent interactions, open questions"""
crm_data = await crm.get_contact(participant["email"])
recent_emails = await gmail.get_thread_with(participant["email"], limit=5)
return {
"name": participant["name"],
"title": crm_data.get("title", participant.get("title", "")),
"last_interaction": recent_emails[0]["date"] if recent_emails else "no data",
"open_items": crm_data.get("open_tasks", []),
}
Email Draft Generator
class EmailDraftGenerator:
async def draft_reply(
self,
original_email: dict,
tone: Literal["formal", "professional", "friendly"],
action: str, # "approve", "decline", "request_more_info", "delegate", "custom"
custom_points: list[str] = None,
) -> str:
response = await client.chat.completions.create(
model="gpt-4o",
messages=[{
"role": "system",
"content": f"""Write on behalf of CEO.
Tone: {tone}. Concise — executive values his time.
Signature: [Name], [Title], [Company]"""
}, {
"role": "user",
"content": f"""Email to respond to:
{original_email['body'][:1000]}
Action: {action}
Additional points: {custom_points}"""
}],
temperature=0.4,
)
return response.choices[0].message.content
Daily Briefing
async def generate_daily_briefing(
calendar_events: list[dict],
unread_emails: list[dict],
news_topics: list[str],
team_updates: list[dict],
) -> str:
response = await client.chat.completions.create(
model="gpt-4o",
messages=[{
"role": "system",
"content": "Create morning briefing for CEO. Format: day schedule, requires decision today, important industry news, team updates. Max 1 page."
}, {
"role": "user",
"content": f"""Meetings today: {json.dumps(calendar_events, ensure_ascii=False)}
Emails requiring response: {len([e for e in unread_emails if e['classification']['priority'] in ['urgent', 'important']])}
News: {news_topics}
Team updates: {json.dumps(team_updates, ensure_ascii=False)}"""
}],
)
return response.choices[0].message.content
Practical Case Study: Series B Startup CEO
Situation: CEO received 150+ emails/day, spent 3 hours on email management, often missed important messages under information noise.
AI Executive Assistant:
- Classification and prioritization of incoming (Gmail API)
- Morning 5-minute briefing (schedule + top-5 emails requiring attention)
- Draft replies for 80% of routine emails (CEO edits and sends)
- Briefing preparation before each meeting
- Summary of incoming documents for reading
Results:
- Time on email management: 3 hours → 45 minutes
- Missed important emails: -91%
- CEO rating: 4.4/5.0 ("found time to think about strategy")
Timeline
- Email classification and prioritization: 1–2 weeks
- Meeting preparation agent: 1–2 weeks
- Draft generator + Gmail/Outlook integration: 1–2 weeks
- Daily briefing automation: 1 week
- Total: 4–7 weeks