AI Agent Planning: Meeting Scheduling and Summaries

Michael BrenndoerferJuly 23, 202510 min read

Part of AI Agent Handbook

See how AI agents use planning to handle complex, multi-step tasks. Topics include task decomposition, sequential execution.

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]:
TypeError: "Could not resolve authentication method. Expected either api_key or auth_token to be set. Or for one of the `X-Api-Key` or `Authorization` headers to be explicitly omitted"
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[3], line 18
      7 user_request = """
      8 Book a meeting next week with Alice to discuss the Q4 marketing campaign.
      9 Send her a summary of what we accomplished in Q3 before the meeting.
     10 """
     12 planning_prompt = f"""You are a personal assistant. Break down this request into a numbered list of specific steps:
     13 
     14 Request: {user_request}
     15 
     16 List each step as a clear action. Consider what information you need and what order makes sense."""
---> 18 response = client.messages.create(
     19     model="claude-sonnet-4-5",
     20     max_tokens=1024,
     21     messages=[{"role": "user", "content": planning_prompt}],
     22 )
     24 print(response.content[0].text)

File /private/tmp/mb-ai-style-scanner/.venv/lib/python3.11/site-packages/anthropic/_utils/_utils.py:282, in required_args.<locals>.inner.<locals>.wrapper(*args, **kwargs)
    280             msg = f"Missing required argument: {quote(missing[0])}"
    281     raise TypeError(msg)
--> 282 return func(*args, **kwargs)

File /private/tmp/mb-ai-style-scanner/.venv/lib/python3.11/site-packages/anthropic/resources/messages/messages.py:996, in Messages.create(self, max_tokens, messages, model, cache_control, container, inference_geo, metadata, output_config, service_tier, stop_sequences, stream, system, temperature, thinking, tool_choice, tools, top_k, top_p, extra_headers, extra_query, extra_body, timeout)
    989 if model in MODELS_TO_WARN_WITH_THINKING_ENABLED and thinking and thinking["type"] == "enabled":
    990     warnings.warn(
    991         f"Using Claude with {model} and 'thinking.type=enabled' is deprecated. Use 'thinking.type=adaptive' instead which results in better model performance in our testing: https://platform.claude.com/docs/en/build-with-claude/adaptive-thinking",
    992         UserWarning,
    993         stacklevel=3,
    994     )
--> 996 return self._post(
    997     "/v1/messages",
    998     body=maybe_transform(
    999         {
   1000             "max_tokens": max_tokens,
   1001             "messages": messages,
   1002             "model": model,
   1003             "cache_control": cache_control,
   1004             "container": container,
   1005             "inference_geo": inference_geo,
   1006             "metadata": metadata,
   1007             "output_config": output_config,
   1008             "service_tier": service_tier,
   1009             "stop_sequences": stop_sequences,
   1010             "stream": stream,
   1011             "system": system,
   1012             "temperature": temperature,
   1013             "thinking": thinking,
   1014             "tool_choice": tool_choice,
   1015             "tools": tools,
   1016             "top_k": top_k,
   1017             "top_p": top_p,
   1018         },
   1019         message_create_params.MessageCreateParamsStreaming
   1020         if stream
   1021         else message_create_params.MessageCreateParamsNonStreaming,
   1022     ),
   1023     options=make_request_options(
   1024         extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
   1025     ),
   1026     cast_to=Message,
   1027     stream=stream or False,
   1028     stream_cls=Stream[RawMessageStreamEvent],
   1029 )

File /private/tmp/mb-ai-style-scanner/.venv/lib/python3.11/site-packages/anthropic/_base_client.py:1364, in SyncAPIClient.post(self, path, cast_to, body, content, options, files, stream, stream_cls)
   1355     warnings.warn(
   1356         "Passing raw bytes as `body` is deprecated and will be removed in a future version. "
   1357         "Please pass raw bytes via the `content` parameter instead.",
   1358         DeprecationWarning,
   1359         stacklevel=2,
   1360     )
   1361 opts = FinalRequestOptions.construct(
   1362     method="post", url=path, json_data=body, content=content, files=to_httpx_files(files), **options
   1363 )
-> 1364 return cast(ResponseT, self.request(cast_to, opts, stream=stream, stream_cls=stream_cls))

File /private/tmp/mb-ai-style-scanner/.venv/lib/python3.11/site-packages/anthropic/_base_client.py:1058, in SyncAPIClient.request(self, cast_to, options, stream, stream_cls)
   1055 options = self._prepare_options(options)
   1057 remaining_retries = max_retries - retries_taken
-> 1058 request = self._build_request(options, retries_taken=retries_taken)
   1059 self._prepare_request(request)
   1061 kwargs: HttpxSendArgs = {}

File /private/tmp/mb-ai-style-scanner/.venv/lib/python3.11/site-packages/anthropic/_base_client.py:521, in BaseClient._build_request(self, options, retries_taken)
    518     else:
    519         raise RuntimeError(f"Unexpected JSON data type, {type(json_data)}, cannot merge with `extra_body`")
--> 521 headers = self._build_headers(options, retries_taken=retries_taken)
    522 params = _merge_mappings(self.default_query, options.params)
    523 content_type = headers.get("Content-Type")

File /private/tmp/mb-ai-style-scanner/.venv/lib/python3.11/site-packages/anthropic/_base_client.py:451, in BaseClient._build_headers(self, options, retries_taken)
    441 custom_headers = options.headers or {}
    442 headers_dict = _merge_mappings(
    443     {
    444         "x-stainless-timeout": str(options.timeout.read)
   (...)    449     custom_headers,
    450 )
--> 451 self._validate_headers(headers_dict, custom_headers)
    453 # headers are case-insensitive while dictionaries are not.
    454 headers = httpx.Headers(headers_dict)

File /private/tmp/mb-ai-style-scanner/.venv/lib/python3.11/site-packages/anthropic/_client.py:196, in Anthropic._validate_headers(self, headers, custom_headers)
    193 if headers.get("Authorization") or isinstance(custom_headers.get("Authorization"), Omit):
    194     return
--> 196 raise TypeError(
    197     '"Could not resolve authentication method. Expected either api_key or auth_token to be set. Or for one of the `X-Api-Key` or `Authorization` headers to be explicitly omitted"'
    198 )

TypeError: "Could not resolve authentication method. Expected either api_key or auth_token to be set. Or for one of the `X-Api-Key` or `Authorization` headers to be explicitly omitted"

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[6]:
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']

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[8]:
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)

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[10]:
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']}")

Step 7-8: Scheduling and Confirming

In[12]:
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)

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[14]:
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 lets our assistant handle real work instead of only answering questions. 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 tools or APIs so each one handles the right part of a larger task.

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.

Planning with AI Agents

Question 1 of 50 of 5 completed
In the meeting scheduling example, why does the assistant send the Q3 summary before scheduling the meeting?

Comments

No comments yet. Be the first to share your thoughts!

Reference

Citation details

Cite or share this article.

BIBTEXAcademic
@misc{brenndoerfer2025aiagent, author = {Michael Brenndoerfer}, title = {AI Agent Planning: Meeting Scheduling and Summaries}, year = {2025}, url = {https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler}, organization = {mbrenndoerfer.com}, note = {Accessed: 2026-09-30} }
APAAcademic
Michael Brenndoerfer (2025). AI Agent Planning: Meeting Scheduling and Summaries. Retrieved from https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler
MLAAcademic
Michael Brenndoerfer. "AI Agent Planning: Meeting Scheduling and Summaries." 2026. Web. September 30, 2026. <https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler>.
CHICAGOAcademic
Michael Brenndoerfer. "AI Agent Planning: Meeting Scheduling and Summaries." Accessed September 30, 2026. https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler.
HARVARDAcademic
Michael Brenndoerfer (2025) 'AI Agent Planning: Meeting Scheduling and Summaries'. Available at: https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler (Accessed: September 30, 2026).
SimpleBasic
Michael Brenndoerfer (2025). AI Agent Planning: Meeting Scheduling and Summaries. https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler
DIRECT LINKURL
https://mbrenndoerfer.com/writing/ai-agent-planning-example-meeting-scheduler

About the author

Continue with the full handbook

This chapter is part of AI Agent Handbook. Use the handbook page to browse the complete table of contents and continue reading in sequence.

Explore AI Agent Handbook

Related content

Newsletter

Stay up to date

Get articles, book updates, and news delivered to your inbox.

No spam, unsubscribe anytime.

or

Join the community

Sign in to remove popups, track your reading progress, and join the discussion.