WritingBooksAboutCommunityContactCommunity

Planning in Action: Building an AI Assistant That Schedules Meetings and Summarizes Work

Michael Brenndoerfer•July 23, 2025•10 min read

See how AI agents use planning to handle complex, multi-step tasks. Learn task decomposition, sequential execution, and error handling through a complete example of booking meetings and sending summaries.

Example: Planning with Our Assistant

You've learned how to break down tasks and implement plan-and-execute patterns. Now let's see these concepts in action with a realistic scenario that brings together everything our assistant has learned so far.

A Complex Request

Imagine you send this message to your personal assistant:

Book a meeting next week with Alice to discuss the Q4 marketing campaign. 
Send her a summary of what we accomplished in Q3 before the meeting.

This isn't a simple, single-step task. It requires coordination across multiple systems, retrieving historical information, and executing several actions in the right order. Let's watch our assistant plan and execute this request step by step.

The Planning Phase

When our assistant receives this request, it doesn't immediately start booking meetings or sending emails. Instead, it enters a planning phase where it breaks down the goal into manageable subtasks.

Here's how the assistant might decompose this request:

In[3]:
Code
## Using Claude Sonnet 4.5 for its superior planning capabilities
import os
from anthropic import Anthropic

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

user_request = """
Book a meeting next week with Alice to discuss the Q4 marketing campaign.
Send her a summary of what we accomplished in Q3 before the meeting.
"""

planning_prompt = f"""You are a personal assistant. Break down this request into a numbered list of specific steps:

Request: {user_request}

List each step as a clear action. Consider what information you need and what order makes sense."""

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": planning_prompt}]
)

print(response.content[0].text)
Out[3]:
Console
Here's a breakdown of the steps needed to complete this request:

1. **Check your calendar availability for next week** to identify potential meeting times.

2. **Check Alice's calendar availability for next week** (or contact her to confirm her availability).

3. **Identify a mutually available time slot** that works for both schedules.

4. **Send a meeting invitation to Alice** with:
   - Date and time
   - Subject: "Q4 Marketing Campaign Discussion"
   - Duration (suggest 30-60 minutes)
   - Meeting location or video call link

5. **Gather Q3 marketing campaign data and results**, including:
   - Key metrics and KPIs achieved
   - Completed projects/initiatives
   - Budget spent vs. allocated
   - Successes and challenges

6. **Draft a summary document of Q3 accomplishments** in a clear, organized format.

7. **Review and finalize the Q3 summary** for accuracy and completeness.

8. **Send the Q3 summary to Alice via email** with sufficient time before the meeting (ideally 1-2 days in advance) so she can review it.

9. **Confirm Alice has received both the meeting invitation and Q3 summary** and follow up if needed.

The assistant generates this plan:

To complete this request, I'll need to:

1. Check Alice's calendar availability for next week
2. Check your calendar for the same period
3. Identify overlapping time slots
4. Retrieve your Q3 marketing notes and accomplishments
5. Create a concise summary of Q3 work
6. Send the summary email to Alice
7. Schedule the meeting once a time is confirmed
8. Provide you with confirmation of both actions

I notice there are dependencies here. I should send the summary before 
scheduling the meeting so Alice has context when she receives the invite. 
I also need to find availability before I can schedule anything.

Notice how the assistant has identified dependencies on its own. You can't schedule a meeting before checking availability, and you should send the summary before the meeting gets scheduled so Alice has context when she accepts. This kind of dependency awareness is what makes planning valuable.

Executing the Plan

Now our assistant moves through each step, using the tools and capabilities we've built in previous chapters.

Step 1-3: Finding a Meeting Time

In[4]:
Code
## Example (Claude Sonnet 4.5)
## Simulating calendar tool calls

def check_calendar(person, start_date, end_date):
    """Tool to check calendar availability"""
    # In reality, this would call Google Calendar API or similar
    if person == "Alice":
        return {
            "available_slots": [
                "2025-11-17 14:00-15:00",
                "2025-11-18 10:00-11:00",
                "2025-11-19 15:00-16:00"
            ]
        }
    else:  # User's calendar
        return {
            "available_slots": [
                "2025-11-17 14:00-15:00",
                "2025-11-18 10:00-11:00",
                "2025-11-20 09:00-10:00"
            ]
        }

## Agent executes steps 1-3
alice_availability = check_calendar("Alice", "2025-11-17", "2025-11-23")
user_availability = check_calendar("User", "2025-11-17", "2025-11-23")

## Find overlapping slots
alice_slots = set(alice_availability["available_slots"])
user_slots = set(user_availability["available_slots"])
common_slots = alice_slots.intersection(user_slots)

print(f"Available times for both: {list(common_slots)}")
## Output: ['2025-11-17 14:00-15:00', '2025-11-18 10:00-11:00']
Out[4]:
Console
Available times for both: ['2025-11-17 14:00-15:00', '2025-11-18 10:00-11:00']

The assistant has now completed the first three steps of its plan. It found two possible meeting times.

Step 4-5: Retrieving and Summarizing Q3 Work

Next, the assistant needs to gather information about Q3 marketing activities. This is where memory and retrieval come in.

In[5]:
Code
## Example (Claude Sonnet 4.5)
## Using the memory system from Chapter 6

def retrieve_project_notes(project_name, time_period):
    """Retrieve notes from long-term memory"""
    # This would query a vector database or document store
    return {
        "notes": [
            "Launched new social media campaign in July - 50K impressions",
            "Redesigned email templates - open rate increased 15%",
            "Partnered with 3 influencers for product reviews",
            "A/B tested landing pages - version B performed 22% better",
            "Ran webinar series - 500 attendees total"
        ],
        "documents": ["Q3_campaign_metrics.pdf", "social_media_report.xlsx"]
    }

## Agent executes step 4
q3_data = retrieve_project_notes("marketing", "Q3 2025")

## Agent executes step 5: summarize the findings
summary_prompt = f"""Summarize these Q3 marketing accomplishments in a brief, professional email format:

{q3_data['notes']}

Keep it concise but highlight key metrics."""

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=512,
    messages=[{"role": "user", "content": summary_prompt}]
)

summary = response.content[0].text
print(summary)
Out[5]:
Console
Subject: Q3 Marketing Summary

Hi Team,

I wanted to share our key marketing accomplishments from Q3:

**Social Media & Partnerships**
- Launched new social media campaign generating 50K impressions
- Secured partnerships with 3 influencers for product reviews

**Email & Web Optimization**
- Redesigned email templates, improving open rates by 15%
- A/B tested landing pages with Version B outperforming by 22%

**Events**
- Successfully executed webinar series with 500 total attendees

Strong quarter overall with measurable improvements across multiple channels.

Best regards

The assistant generates a summary:

Hi Alice,

Here's a quick overview of our Q3 marketing accomplishments:

- Social Media: Launched new campaign reaching 50K impressions
- Email Marketing: Redesigned templates with 15% improvement in open rates  
- Influencer Partnerships: Collaborated with 3 influencers for product reviews
- Website Optimization: A/B testing showed 22% better performance on new landing page
- Webinar Series: Hosted events with 500 total attendees

Looking forward to discussing Q4 plans!

Step 6: Sending the Summary

In[6]:
Code
## Example (Claude Sonnet 4.5)
def send_email(to, subject, body):
    """Tool to send email"""
    # Would use SendGrid, Gmail API, or similar
    print(f"Sending email to {to}")
    print(f"Subject: {subject}")
    print(f"Body: {body}")
    return {"status": "sent", "message_id": "msg_12345"}

## Agent executes step 6
email_result = send_email(
    to="alice@company.com",
    subject="Q3 Marketing Summary - Ahead of Our Q4 Planning Meeting",
    body=summary
)

print(f"Email status: {email_result['status']}")
Out[6]:
Console
Sending email to alice@company.com
Subject: Q3 Marketing Summary - Ahead of Our Q4 Planning Meeting
Body: Subject: Q3 Marketing Summary

Hi Team,

I wanted to share our key marketing accomplishments from Q3:

**Social Media & Partnerships**
- Launched new social media campaign generating 50K impressions
- Secured partnerships with 3 influencers for product reviews

**Email & Web Optimization**
- Redesigned email templates, improving open rates by 15%
- A/B tested landing pages with Version B outperforming by 22%

**Events**
- Successfully executed webinar series with 500 total attendees

Strong quarter overall with measurable improvements across multiple channels.

Best regards
Email status: sent

Step 7-8: Scheduling and Confirming

In[7]:
Code
## Example (Claude Sonnet 4.5)
def schedule_meeting(attendees, time_slot, subject, description):
    """Tool to create calendar event"""
    # Would use Google Calendar API or similar
    return {
        "event_id": "evt_67890",
        "status": "scheduled",
        "time": time_slot,
        "attendees": attendees
    }

## Agent executes step 7
## Choose the first available slot
chosen_time = list(common_slots)[0]

meeting_result = schedule_meeting(
    attendees=["alice@company.com", "user@company.com"],
    time_slot=chosen_time,
    subject="Q4 Marketing Campaign Planning",
    description="Discuss Q4 marketing strategy and campaign plans"
)

## Agent executes step 8: Confirm with user
confirmation_message = f"""
Task completed! Here's what I did:

✓ Found available time: {chosen_time}
✓ Retrieved and summarized Q3 marketing accomplishments
✓ Sent summary to Alice at alice@company.com
✓ Scheduled meeting: "Q4 Marketing Campaign Planning"

The meeting is confirmed for {chosen_time}. Alice has received the Q3 summary in advance.
"""

print(confirmation_message)
Out[7]:
Console

Task completed! Here's what I did:

✓ Found available time: 2025-11-17 14:00-15:00
✓ Retrieved and summarized Q3 marketing accomplishments
✓ Sent summary to Alice at alice@company.com
✓ Scheduled meeting: "Q4 Marketing Campaign Planning"

The meeting is confirmed for 2025-11-17 14:00-15:00. Alice has received the Q3 summary in advance.

What Made This Work

Let's unpack what just happened. Our assistant successfully handled a complex, multi-step request by combining several capabilities:

Planning: The assistant didn't just react to the request. It thought ahead, identified dependencies, and created a logical sequence of actions.

Tool Use: Multiple tools came into play - calendar APIs for checking availability, a memory system for retrieving past work, and email services for communication. The assistant knew which tool to use at each step.

Memory and Retrieval: The assistant pulled relevant information from its long-term memory about Q3 marketing activities. Without this capability, it couldn't have generated an accurate summary.

Reasoning: When finding a meeting time, the assistant had to reason about overlapping availability. It understood that both parties need to be free at the same time.

State Management: Throughout execution, the assistant maintained state about what it had accomplished, what remained to be done, and what information it had gathered. This prevented it from repeating steps or losing track of progress.

Handling Complications

Real-world scenarios rarely go perfectly. Let's see how our assistant handles a complication.

Suppose when the assistant tries to retrieve Q3 notes, the memory system returns incomplete information:

In[8]:
Code
## Example (Claude Sonnet 4.5)
## Simulating incomplete data retrieval

q3_data_incomplete = retrieve_project_notes("marketing", "Q3 2025")

if len(q3_data_incomplete["notes"]) < 3:
    # Assistant recognizes insufficient information
    replanning_prompt = """
    I was asked to summarize Q3 marketing work, but I only found limited notes.
    What should I do?
    
    Options:
    A) Send what I have
    B) Ask the user for more information
    C) Search additional sources
    D) Indicate in the summary that information is incomplete
    
    Consider: The summary will be sent to Alice before a meeting.
    """
    
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=256,
        messages=[{"role": "user", "content": replanning_prompt}]
    )
    
    print(response.content[0].text)

A well-designed assistant might respond:

I should ask the user for more information (Option B). Sending incomplete 
information to Alice could make us look unprepared for the meeting. I'll 
pause execution and request additional details from the user.

This demonstrates adaptive planning. When the original plan hits an obstacle, the assistant can recognize the problem and adjust its approach.

Bringing It All Together

This example shows how planning transforms our assistant from a simple question-answering tool into something that can handle real work. The key elements that made this possible:

Task Decomposition: Breaking "book a meeting and send a summary" into eight concrete steps made the complex request manageable. Without decomposition, the assistant might have tried to do everything at once or missed important steps.

Sequential Execution: Following the plan in order, with each step building on the previous ones, ensured nothing was forgotten or done out of sequence. The assistant knew to check calendars before scheduling and to send the summary before creating the meeting invite.

Tool Orchestration: The assistant coordinated multiple tools (calendar, memory, email) to accomplish different parts of the task. Each tool served a specific purpose, and the assistant knew when to invoke each one.

Contextual Awareness: Throughout execution, the assistant maintained awareness of the overall goal and how each step contributed to it. This prevented it from getting lost in the details or forgetting why it was performing certain actions.

Graceful Handling: When problems arise, the assistant can recognize them and adapt rather than blindly continuing. This makes the difference between a brittle system that breaks easily and a robust one that handles real-world messiness.

Design Considerations

As you build planning capabilities into your own agents, consider these trade-offs:

Plan Detail vs. Flexibility: Highly detailed plans are easier to execute but harder to adapt when things change. More abstract plans are flexible but require more reasoning at each step. For our assistant, we chose medium-detail plans that specify what to do but allow some flexibility in how.

Upfront Planning vs. Incremental Planning: Should the agent plan everything before starting, or plan a few steps and then replan? Upfront planning works well for predictable tasks. Incremental planning handles uncertainty better but adds overhead. Our example used upfront planning because meeting scheduling is fairly predictable.

Error Recovery Strategies: When a step fails, should the agent retry, skip it, ask for help, or abort entirely? The right choice depends on the consequences of failure. For our assistant, we chose to ask for help when critical information is missing, since sending incomplete information could damage professional relationships.

You now have an assistant that doesn't just respond to requests but actively works to accomplish goals. In the next chapter, we'll explore how multiple agents can work together, enabling even more sophisticated capabilities through collaboration and specialization.

Glossary

Task Decomposition: The process of breaking down a complex goal into smaller, manageable subtasks that can be executed sequentially or in parallel.

Tool Orchestration: Coordinating multiple different tools or APIs to accomplish various parts of a larger task, ensuring they work together effectively.

Sequential Execution: Performing planned steps in a specific order, where each step may depend on the results of previous steps.

Adaptive Planning: The ability to recognize when a plan isn't working and adjust the approach, either by replanning or by asking for additional information.

State Management: Maintaining awareness of what has been accomplished, what remains to be done, and what information has been gathered during task execution.

Quiz

Ready to test your understanding? Take this quick quiz to reinforce what you've learned about planning in AI agents.

Loading component...

Reference

BIBTEXAcademic
@misc{planninginactionbuildinganaiassistantthatschedulesmeetingsandsummarizeswork, author = {Michael Brenndoerfer}, title = {Planning in Action: Building an AI Assistant That Schedules Meetings and Summarizes Work}, year = {2025}, url = {https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler}, organization = {mbrenndoerfer.com}, note = {Accessed: 2025-12-25} }
APAAcademic
Michael Brenndoerfer (2025). Planning in Action: Building an AI Assistant That Schedules Meetings and Summarizes Work. Retrieved from https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler
MLAAcademic
Michael Brenndoerfer. "Planning in Action: Building an AI Assistant That Schedules Meetings and Summarizes Work." 2025. Web. 12/25/2025. <https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler>.
CHICAGOAcademic
Michael Brenndoerfer. "Planning in Action: Building an AI Assistant That Schedules Meetings and Summarizes Work." Accessed 12/25/2025. https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler.
HARVARDAcademic
Michael Brenndoerfer (2025) 'Planning in Action: Building an AI Assistant That Schedules Meetings and Summarizes Work'. Available at: https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler (Accessed: 12/25/2025).
SimpleBasic
Michael Brenndoerfer (2025). Planning in Action: Building an AI Assistant That Schedules Meetings and Summarizes Work. https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler
Direct link:
https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler