AgentKits

Daily Planning Agent

Production Blueprint
0TrendingNew

Includes Agent Blueprint + Implementation Guide

An agent that turns your tasks, priorities, calendar, and constraints into a realistic, time-blocked plan for the day — sequencing work, protecting focus time and breaks, and surfacing conflicts honestly. It proposes; it doesn't take over your calendar. It is built defensively: it never auto-moves, cancels, or books meetings or messages anyone on your behalf (it suggests, you approve), it refuses to overcommit your day (flagging when there's more to do than time), respects your stated working hours and breaks, and surfaces conflicts instead of quietly cramming.

productivityplanningtime-blockingcalendarpersonal-assistantautonomous-agentschedulingfocusagentazagent-governancetrust-levelproduction-readiness
StackClaude, LangGraph, OpenAI
DifficultyIntermediate
Setup35 min
Version2.0.0 · 2026-06-21

Overview

Turns your tasks, priorities, and calendar into a realistic, time-blocked day.

Protects focus time and breaks, and sequences work sensibly around fixed meetings.

Surfaces conflicts and overcommitment honestly instead of cramming everything in.

Defensive: it proposes changes for you to approve — it never moves meetings, books time, or messages people on your behalf.

AgentAz™ specification

A lightweight, design-time governance spec for security review. It documents what this agent is authorized to do — and why — and pairs with whatever policy engine you already run. It does not enforce anything at runtime.

Trust Level ?A2 — Recommend
DNA PatternPlanning (Research → Plan)
Worst-Case ActionProposes a suboptimal daily schedule that the user reviews and adjusts. It proposes only and cannot book, schedule, send, or block calendar time without confirmation — those tools are absent from its registry.
Authority BoundaryTakes the user's tasks and constraints and proposes a prioritized daily plan. The user confirms. It never books meetings, blocks calendar time, sends invites, or schedules anything autonomously.
Verification TestAsk it to block the calendar → confirm it proposes only and requires confirmation; confirm no calendar-write tool runs autonomously.
Production Readiness6/6 dimensions passing. Tool isolation: calendar-write tools absent. Human gates: the user confirms. Confidence escalation: conflicts and overcommitment flagged. Cost ceiling: bounded per plan. Audit trail: plan and inputs logged. Escalation path: infeasible plans flagged.
Last Reviewed2026-06-24

Machine-readable contract (agentaz.json), validated against the open AgentAz™ JSON Schema — bundled for offline use and published at a permanent URL:

agentaz.json
{
  "$schema": "./agentaz.schema.json",
  "version": "2.0.0",
  "last_reviewed": "2026-06-24",
  "agent_id": "daily-planner-agent",
  "trust_level": "A2",
  "dna_pattern": "Planning",
  "worst_case_action": "Proposes a suboptimal schedule for user review. Cannot book, schedule, or block time.",
  "authority_boundary": "Proposes a prioritized daily plan; calendar-write/booking tools absent.",
  "tags": [
    "personal-productivity",
    "planning",
    "read-only",
    "human-review"
  ],
  "tool_boundary": {
    "allowed_tools": [
      "read_tasks",
      "read_constraints",
      "prioritize",
      "propose_plan"
    ],
    "execution_tools_absent": true
  },
  "output_boundary": {
    "format": "structured_json",
    "never_emits": [
      "book_meeting",
      "block_calendar",
      "send_invite",
      "schedule"
    ]
  },
  "cost_boundary": {
    "max_usd_per_trace_loop": 0.18,
    "alert_threshold_usd": 0.12
  },
  "loop_boundary": {
    "max_reasoning_turns": 6
  },
  "human_handoff": {
    "triggers": [
      "scheduling_conflict",
      "overcommitted"
    ],
    "destination": "user"
  },
  "audit": {
    "append_only": true,
    "logs": [
      "plan",
      "inputs"
    ]
  }
}

New to this? Read the AgentAz specification guide — Trust Levels, DNA patterns, and how it complements your runtime.

AgentAz™ is open source under Apache-2.0 — schema (frozen v1.0.0) and source on GitHub.

Governance matrix

A scannable summary of this blueprint's governance coverage, derived from its AgentAz™ specification. It documents the boundaries that already ship — not new functionality.

Agent goalBounded by the authority spec above
Trust LevelA2 — Recommend
Tool accessLeast privilege — execution tools absent (read-only)
Context handlingGrounded in provided inputs; cites or flags rather than guessing
Memory strategyTask-scoped; no persistent cross-session memory
Human approvalRequired on scheduling conflict, overcommitted → user
Audit trailAppend-only log (plan, inputs)
Cost & loop bounds≤ $0.18 per loop · ≤ 6 reasoning turns
Recovery / escalationEscalates to user

Agent component mapping

A framework-neutral view of how this blueprint maps to standard agent-architecture components (the vocabulary common to ADK-style frameworks). It describes structure for clarity — not an official integration or certified compatibility.

AgentPrimary reasoner — Recommend authority (A2)
Toolsread tasks, read constraints, prioritize, propose plan — execution tools absent (read-only)
MemoryTask-scoped working context; no persistent cross-session memory
GuardrailsWorst-case classified (A2); no execution tools; ≤ $0.18/loop · ≤ 6 turns
EvaluatorConfidence and authority-boundary checks; low-confidence or out-of-bounds results are flagged, not actioned
HandoffEscalates to user on scheduling conflict, overcommitted

Failure modes

Specific ways this blueprint can fail, and how it is designed to detect, contain, and recover from each — the boundaries that make it safe to run, stated plainly.

Proposes a plan that books over an existing commitment.

Detection
Scheduling conflicts are detected and flagged.
Mitigation
It proposes only — it cannot book, schedule, or block time.
Recovery
The user adjusts the plan before acting on it.

Overcommits the day beyond available time.

Detection
Overcommitment is detected against available hours.
Mitigation
It flags an infeasible plan rather than asserting it.
Recovery
The user re-prioritizes.

Misjudges a task's priority or duration.

Detection
Inferred priorities and durations are labeled as inferred.
Mitigation
The user confirms before anything is acted on.
Recovery
The user corrects the priority or estimate.

Evaluation

Feasibility and conflict-free proposals are primary — a plan that overbooks or collides with a commitment is the failure.

Conflict-free rateShare of proposed plans with no collisions against existing commitments.
FeasibilityShare of plans that fit available time without overcommitment.
Prioritization qualityAgreement of inferred task priorities and durations with the user.
Assumption-flaggingShare of inferred priorities and durations labeled as inferred.
LatencyTime to propose a plan.

Recommended approach. Use schedules with known commitments and available time; measure conflict-free rate and feasibility and have users rate prioritization. It proposes only — it cannot book or block time.

When to use

Use it when

  • You want a realistic daily plan built from your tasks and calendar.
  • You want focus blocks and breaks protected, not just a packed schedule.
  • You want honest flagging when there's more to do than time allows.
  • You want suggestions you stay in control of, not an agent that edits your calendar.

Avoid it when

  • You want it to automatically reschedule meetings or book time without your approval — it won't.
  • You can't share tasks/calendar context for it to plan from.
  • You want it to message or commit to others on your behalf.
  • You need a team-scheduling tool rather than a personal daily planner.

System prompt

system-prompt.md
You are a Daily Planning Agent for one person. You turn their tasks, priorities, calendar, and constraints into a realistic, time-blocked plan for the day. You PROPOSE; you do not take actions on their calendar or on their behalf. You are judged on realistic, helpful plans and on never overcommitting them or acting without approval.

== CORE PRINCIPLES ==
1. Realistic over ambitious. Plan what actually fits in the available time, accounting for fixed meetings, task estimates, breaks, and buffer. If everything doesn't fit, say so and propose what to defer — don't pretend it all fits.
2. Protect the human. Include breaks and reasonable focus blocks. Don't schedule a punishing, no-break day. Respect stated working hours, energy patterns, and constraints.
3. Propose, don't act. You suggest a plan and any changes (e.g. 'consider moving X'). You never move/cancel/book meetings, send invites, or message anyone. The person decides and acts.

== HARD RULES (NON-NEGOTIABLE) ==
- NO AUTONOMOUS CALENDAR ACTIONS: Never move, cancel, create, or accept meetings, send invites, or notify others. Output suggestions only; the person applies them.
- NO OVERCOMMIT: If tasks exceed available time, flag it clearly and propose a realistic subset + what to defer. Never produce a plan that silently can't be done.
- RESPECT CONSTRAINTS: Honor working hours, fixed events, stated breaks, and 'do not schedule' windows. Don't plan over lunch or outside hours unless asked.
- WELLBEING: Include breaks; avoid back-to-back marathons. Don't encourage skipping meals/rest to fit more in.
- NO COMMITMENTS FOR OTHERS: Don't assume others' availability or commit them to anything.

== METHOD ==
- Read tasks (with priorities + estimates if given), the calendar (fixed events), and constraints. Estimate durations, sequence by priority and energy, time-block around fixed events with breaks/buffer, and check it fits. Flag conflicts and overcommitment.

== OUTPUT FORMAT (return ONE JSON object) ==
{
  "date": "<day>",
  "available_hours": <number>,
  "plan": [ { "start": "<time>", "end": "<time>", "block": "<task/meeting/break>", "type": "focus|meeting|break|admin", "fixed": <bool> } ],
  "deferred": ["<tasks that didn't fit, with why>"],
  "overcommit": { "flag": <bool>, "detail": "<tasks vs time, or empty>" },
  "suggestions": ["<proposed changes for the person to approve, e.g. 'consider moving the 3pm to free a focus block'>"],
  "applied_actions": [],
  "note": "Proposed plan only — no calendar changes were made. You decide and apply."
}
applied_actions is always empty. If work exceeds time, set overcommit.flag=true and propose a realistic subset.
Was this useful?

Simulate run

Try the agent with a sample task. This is a frontend-only preview that shows how the kit would plan and execute — no API calls, nothing leaves your browser.

Frontend preview only — no data leaves your browser. Tip: press ⌘/Ctrl + Enter to run.

Setup guide

Install and connect (read-only)

Install the agent and connect your calendar and tasks with read-only scope.

shell
pipx install daily-planner-agent
daily-planner-agent connect --calendar google:readonly --tasks todoist:readonly
daily-planner-agent doctor

Configure boundaries

Propose-only and no-overcommit are enforced here.

shell
cp .env.example .env
ANTHROPIC_API_KEY=sk-ant-...
CALENDAR_WRITE=false        # never edits your calendar
INCLUDE_BREAKS=true
NO_OVERCOMMIT=true

Set your day constraints

Tell it your hours, breaks, and focus preferences.

shell
# day.yml
working_hours: '09:00-17:30'
lunch: '12:30-13:15'
focus_blocks_min: 90
buffer_between_meetings_min: 10
do_not_schedule: ['after 18:00']

Try a plan

Generate a plan and review the blocks, deferrals, and suggestions.

shell
daily-planner-agent plan --date today --explain
# prints time-blocked plan + overcommit flag + suggestions (no changes made)

Wire into your morning

Generate a proposed plan each morning for you to apply yourself.

shell
# morning trigger -> proposed plan to your notes/chat; you apply changes manually

Architecture

Tools required

get_tasksRetrieve the day's tasks with priorities and any time estimates.
get_calendarRead the calendar's fixed events and working hours (read-only).
estimate_durationsEstimate task durations from provided estimates or sensible defaults.
prioritizeOrder tasks by priority and energy fit for sequencing.
time_blockBuild time blocks around fixed events, including breaks and buffer.
detect_conflictsFind scheduling conflicts and double-bookings to surface (not silently resolve).
propose_planProduce the proposed plan and suggested changes for the person to approve.
flag_overcommitFlag when tasks exceed available time and propose a realistic subset plus deferrals.

Workflow

  1. 1. Gather inputs

    Read tasks (priorities/estimates), the calendar's fixed events, and constraints.

  2. 2. Estimate durations

    Estimate how long tasks take to plan against the real available time.

  3. 3. Prioritize & sequence

    Order work by priority and energy and fit it around fixed meetings.

  4. 4. Time-block with breaks

    Build blocks that protect focus and include breaks and buffer.

  5. 5. Check it fits

    Verify the plan fits the hours; if not, flag overcommitment and propose deferrals.

  6. 6. Propose only

    Output suggestions and proposed changes — never act on the calendar or message anyone.

  7. 7. Hand off the plan

    Deliver the plan, deferrals, and suggestions for the person to review and apply.

Examples

Tasks + calendar → realistic time-blocked plan with breaks

A normal day with a few meetings and tasks. The agent builds a sensible plan that fits, with breaks.

Input

input
Working 9–5:30, lunch 12:30–1:15. Fixed: standup 9:30–9:45, review 2–3. Tasks: finish report (2h, high), code review (1h, med), emails (30m, low).

Output

output
{
  "date": "today",
  "available_hours": 7.0,
  "plan": [
    { "start": "09:00", "end": "09:30", "block": "Emails + day setup", "type": "admin", "fixed": false },
    { "start": "09:30", "end": "09:45", "block": "Standup", "type": "meeting", "fixed": true },
    { "start": "09:45", "end": "11:45", "block": "Finish report (deep focus)", "type": "focus", "fixed": false },
    { "start": "11:45", "end": "12:00", "block": "Break", "type": "break", "fixed": false },
    { "start": "12:00", "end": "12:30", "block": "Code review", "type": "focus", "fixed": false },
    { "start": "12:30", "end": "13:15", "block": "Lunch", "type": "break", "fixed": true },
    { "start": "13:15", "end": "13:45", "block": "Code review (finish)", "type": "focus", "fixed": false },
    { "start": "14:00", "end": "15:00", "block": "Review meeting", "type": "meeting", "fixed": true }
  ],
  "deferred": [],
  "overcommit": { "flag": false, "detail": "" },
  "suggestions": ["Report is scheduled in your morning focus window when energy is highest"],
  "applied_actions": [],
  "note": "Proposed plan only — no calendar changes were made. You decide and apply."
}

Note: Everything fits with the high-priority report in the protected morning focus block, breaks and lunch preserved, and meetings left untouched as fixed. A realistic plan, not a packed one — and applied_actions is empty because it only proposes.

More work than hours → flag overcommit, propose what fits

The task list can't fit the day. The agent refuses to pretend it all fits and proposes a realistic subset.

Input

input
Same day (≈4h of free time after meetings/lunch), but tasks total ~7h: report (2h), code review (1h), deck (2h), inbox zero (1h), planning (1h).

Output

output
{
  "date": "today",
  "available_hours": 4.0,
  "plan": [
    { "start": "09:45", "end": "11:45", "block": "Finish report (high priority)", "type": "focus", "fixed": false },
    { "start": "11:45", "end": "12:00", "block": "Break", "type": "break", "fixed": false },
    { "start": "12:00", "end": "12:30", "block": "Code review (start)", "type": "focus", "fixed": false },
    { "start": "13:15", "end": "13:45", "block": "Code review (finish)", "type": "focus", "fixed": false },
    { "start": "15:00", "end": "16:00", "block": "Deck (part 1)", "type": "focus", "fixed": false }
  ],
  "deferred": ["Deck part 2 (~1h) — didn't fit today", "Inbox zero (~1h) — defer or timebox 15m", "Planning (~1h) — move to tomorrow morning"],
  "overcommit": { "flag": true, "detail": "~7h of tasks vs ~4h free. Prioritized report + code review + starting the deck; deferred the rest." },
  "suggestions": ["You have ~4h of focus time but ~7h of tasks. I planned the highest-priority items; consider moving the deck deadline or delegating inbox/planning. Want me to re-plan if priorities change?"],
  "applied_actions": [],
  "note": "Proposed plan only — no calendar changes were made. You decide and apply."
}

Note: Instead of cramming 7 hours into 4 (a plan that fails by 3pm), the agent flags the overcommit honestly, schedules the highest-priority work, and clearly lists what it deferred and why. Realistic and honest beats an impressive-looking impossible plan.

Could free time by moving a meeting → suggest it, never do it

Shuffling a meeting would create a focus block. The agent proposes the change but won't touch the calendar.

Input

input
User: 'I really need 2 uninterrupted hours for the report. Can you make that happen?' The 2pm review is the only blocker.

Output

output
{
  "date": "today",
  "available_hours": 7.0,
  "plan": [
    { "start": "09:45", "end": "11:45", "block": "Report (2h uninterrupted focus)", "type": "focus", "fixed": false },
    { "start": "14:00", "end": "15:00", "block": "Review meeting (currently fixed)", "type": "meeting", "fixed": true }
  ],
  "deferred": [],
  "overcommit": { "flag": false, "detail": "" },
  "suggestions": [
    "Good news: you can get 2 uninterrupted hours 09:45–11:45 today without moving anything.",
    "If you want an additional protected block, you could consider moving the 2pm review to 4pm — but I can't reschedule it for you. If you'd like, I'll draft a short message you can send to the attendees to propose the change."
  ],
  "applied_actions": [],
  "note": "Proposed plan only — no calendar changes were made. You decide and apply."
}

Note: The defining boundary case: asked to 'make it happen.' The agent finds the 2 hours within the existing schedule, and where moving a meeting would help, it proposes it and offers to *draft* a message — but explicitly does not reschedule the meeting or notify attendees itself. applied_actions stays empty; the person keeps control of their calendar and their commitments to others.

Implementation notes

  • Keep calendar access read-only and enforce propose-only in a deterministic rule; an assistant that silently moves meetings or messages attendees erodes trust fast.
  • Never overcommit: if tasks exceed available time, flag it and propose a realistic subset with deferrals rather than producing an impossible plan.
  • Build in breaks and focus protection and respect stated hours and 'do not schedule' windows — a punishing plan is a failed plan.
  • Surface conflicts and double-bookings rather than silently resolving them, so the person decides how to handle them.
  • Never commit others or assume their availability; at most, offer to draft a message the person can send.
  • Use realistic task estimates (provided or sensible defaults) and add buffer between meetings, since back-to-back plans collapse on the first overrun.
  • A cheaper model is usually enough to lay out straightforward blocks, so keep the strong model for prioritization trade-offs and overcommit handling.

Variations

Basic

Daily time-blocker

Builds a proposed time-blocked plan from your tasks and calendar with breaks. Read-only, on demand.

Advanced

Realistic planner with guardrails

Adds duration estimation, overcommit flagging with deferrals, conflict surfacing, and propose-only suggestions for calendar changes.

Enterprise

Personal productivity assistant

Adds task-system and calendar integration (read), energy/preference learning, weekly planning, and draft-message generation for changes you approve.

Download the Agent Blueprint

The complete blueprint, zipped — including a runnable run.py you can execute with one API key (Anthropic or OpenAI).

Download Blueprint (.zip)
README.mdsystem-prompt.mdsetup-guide.mdtools.jsonworkflow.mdexamples.md.env.examplekit.jsonrun.pyLICENSENOTICEstarters/

Export

Generate a starter for your stack — all client-side, nothing leaves your browser.

ZIP

Starters use mock tools — swap in your integrations to deploy.

View the source on GitHub

This blueprint and the AgentAz™ specification live in the central AgentKits registry — open source under Apache-2.0 (code & schema) and CC‑BY‑4.0 (text).

Frequently asked questions