AgentKits

Task Capture & Organization Agent

Starter Blueprint
0New

Includes Agent Blueprint + Implementation Guide

An agent that takes the messy way you actually capture tasks — a brain-dump, scattered notes, a thread of messages — and turns it into a clean, organized task list with projects, priorities, due dates, and a clear next action. It is built defensively: it captures only the tasks you actually stated, never invents tasks or deadlines, proposes an organization rather than auto-executing it, flags ambiguous items for clarification, marks inferred priorities as inferred, and never schedules, sends, or completes anything without your confirmation.

productivitytasksorganizationgtdplanningautonomous-agenttodocaptureagentazagent-governancetrust-levelproduction-readiness
StackClaude, LangGraph, OpenAI
DifficultyBeginner
Setup25 min
Version2.0.0 · 2026-06-21

Overview

Turns a brain-dump or scattered notes into an organized task list.

Adds projects, inferred priorities, due dates (where stated), and a clear next action.

Flags ambiguous items for clarification instead of inventing details.

Defensive: captures only what you said, and never schedules or sends anything without confirmation.

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 PatternExtraction (Extract → Verify)
Worst-Case ActionMiscaptures a task or infers a wrong priority, which the user reviews and corrects. It proposes an organization but never executes: it cannot schedule, send, complete, or delete anything without confirmation, and those tools are absent from its registry.
Authority BoundaryCaptures only tasks the user actually stated, organizes them into projects with inferred (labeled) priorities and stated due dates, and flags ambiguous items. It never invents tasks or deadlines and never auto-schedules, sends, completes, or deletes. The user confirms before any action.
Verification TestAsk it to auto-schedule or send → confirm it proposes only and requires confirmation; confirm no schedule/send/complete tool runs autonomously.
Production Readiness6/6 dimensions passing. Tool isolation: schedule/send/complete tools absent. Human gates: the user confirms before action. Confidence escalation: ambiguous items flagged. Cost ceiling: bounded per capture. Audit trail: captured items and inferences logged. Escalation path: vague items flagged for clarification.
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": "task-capture-agent",
  "trust_level": "A2",
  "dna_pattern": "Extraction",
  "worst_case_action": "Miscaptures a task for user correction. Proposes only; never auto-schedules, sends, or completes.",
  "authority_boundary": "Captures only stated tasks and proposes organization; schedule/send/complete tools absent.",
  "tags": [
    "personal-productivity",
    "task-capture",
    "read-only",
    "human-review"
  ],
  "tool_boundary": {
    "allowed_tools": [
      "read_input",
      "extract_stated_tasks",
      "infer_project",
      "suggest_priority",
      "flag_ambiguous"
    ],
    "execution_tools_absent": true
  },
  "output_boundary": {
    "format": "structured_json",
    "never_emits": [
      "schedule",
      "send",
      "complete_task",
      "delete_task"
    ],
    "never_fabricates": true
  },
  "cost_boundary": {
    "max_usd_per_trace_loop": 0.18,
    "alert_threshold_usd": 0.12
  },
  "loop_boundary": {
    "max_reasoning_turns": 6
  },
  "human_handoff": {
    "triggers": [
      "ambiguous_item",
      "inferred_priority"
    ],
    "destination": "user"
  },
  "audit": {
    "append_only": true,
    "logs": [
      "captured_items",
      "inferences"
    ]
  }
}

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 ambiguous item, inferred priority → user
Audit trailAppend-only log (captured items, inferences)
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 input, extract stated tasks, infer project, suggest priority, flag ambiguous — 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 ambiguous item, inferred priority

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.

Captures a task that wasn't actually stated (invented item).

Detection
It captures only stated tasks; inferred items are flagged.
Mitigation
It never invents tasks or deadlines.
Recovery
The user removes the spurious item.

Infers a wrong priority or due date.

Detection
Inferred priorities are labeled as inferred and ambiguous items are flagged.
Mitigation
It proposes an organization; the user confirms before any action.
Recovery
The user corrects the priority or date.

Takes an action such as schedule or send without confirmation.

Detection
Schedule, send, and complete tools are absent from the registry.
Mitigation
It proposes only — the user confirms before any action.
Recovery
Structurally prevented; nothing is acted on autonomously.

Evaluation

Faithful capture with no invented tasks is primary — a captured task that wasn't stated, or a wrong inferred deadline, is the failure.

Capture faithfulnessShare of captured tasks grounded in stated input.
Fabrication rateFrequency of invented tasks or deadlines — should be near zero.
Inference accuracyAgreement of inferred priorities and due dates with the user.
Assumption-flaggingShare of inferred fields labeled as inferred.
LatencyTime to organize a capture.

Recommended approach. Use inputs with labeled tasks, priorities, and dates; measure capture faithfulness and inference accuracy and treat any invented task as a fabrication. It proposes only — schedule, send, and complete tools are absent.

When to use

Use it when

  • You capture tasks messily and want them organized cleanly.
  • You want projects, priorities, and next actions inferred sensibly.
  • You want ambiguous items flagged, not guessed.
  • You want a proposed structure you confirm, not auto-actions.

Avoid it when

  • You want it to schedule, send, or complete tasks automatically — it proposes only.
  • You want it to invent deadlines or tasks you didn't mention.
  • You have nothing to capture from.
  • You want it to modify existing items without confirmation.

System prompt

system-prompt.md
You are a Task Capture & Organization Agent. You turn a person's raw input (brain-dump, notes, messages) into an organized task list and propose structure. You are judged on a faithful, useful organization and on never inventing tasks/deadlines or acting without confirmation.

== CORE PRINCIPLES ==
1. Capture only what's stated. Extract tasks the person actually expressed. Don't manufacture tasks, and don't add work they didn't mention.
2. Don't fabricate details. Assign a due date only if stated; otherwise 'no date'. Mark inferred priorities and projects as inferred, not facts. Keep the task's intent faithful.
3. Propose, don't execute. You organize and suggest. You never schedule, send, complete, or delete anything, and you never modify existing items, without explicit confirmation.

== HARD RULES (NON-NEGOTIABLE) ==
- NO INVENTED TASKS: Only capture tasks actually stated. Don't pad the list with assumed work.
- NO FABRICATED DEADLINES/OWNERS: Due date only if stated; otherwise 'no date'. Don't invent deadlines or assign people.
- INFERRED IS LABELED: Priority and project groupings you infer are marked 'inferred' for the person to confirm.
- NO AUTONOMOUS ACTION: Never auto-schedule to a calendar, send a message, complete, or delete a task without confirmation. Propose; the person approves.
- FLAG AMBIGUITY: Vague items ('the thing for John') are captured as-is and flagged for clarification, not guessed into specifics.

== METHOD ==
- Read the input. Extract stated tasks. Group into inferred projects, suggest inferred priority, capture stated due dates, propose a next action. Flag ambiguous items. Present for confirmation.

== OUTPUT FORMAT (return ONE JSON object) ==
{
  "tasks": [
    { "task": "<as stated>", "project": "<inferred group>", "priority": "<high|med|low (inferred)>", "due": "<date if stated, else 'no date'>", "next_action": "<suggested>", "flag": "ok|needs_clarification" }
  ],
  "needs_clarification": ["<ambiguous items to confirm>"],
  "proposed_actions": ["<e.g. 'add these to your task app on confirmation' — not done yet>"],
  "note": "Captured only stated tasks. Priorities/projects are inferred. Nothing scheduled, sent, or completed without your confirmation."
}
Never invent tasks or deadlines. Label inferences. Don't act without confirmation.
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

Install the agent and connect your task app (optional).

shell
pipx install task-capture-agent
task-capture-agent connect --app todoist
task-capture-agent doctor

Configure guardrails

No invented tasks and no autonomous action are enforced here.

shell
cp .env.example .env
ANTHROPIC_API_KEY=sk-ant-...
NO_INVENTED_TASKS=true
LABEL_INFERRED=true
AUTO_ACTIONS=false   # proposes; never schedules/sends without confirm

Set preferences

Define your projects and priority cues.

shell
# tasks.yml
projects: [work, personal, errands]
priority_cues: { urgent_words: [asap, today, urgent] }

Capture a brain-dump

Organize input and review flags before anything is added.

shell
task-capture-agent run --input ./braindump.txt --explain
# prints organized tasks + needs_clarification + proposed_actions (nothing done yet)

Wire into your app

On confirmation, add the organized tasks to your tool.

shell
# brain-dump -> organized proposal -> you confirm -> tasks added

Architecture

Tools required

get_inputTake the raw brain-dump, notes, or messages.
extract_tasksPull only the tasks actually stated.
infer_projectGroup tasks into inferred projects, labeled as such.
suggest_prioritySuggest an inferred priority for each task.
identify_due_dateCapture a due date only if it was stated.
flag_ambiguousFlag vague items for clarification.
organize_listAssemble the proposed, organized task list.
propose_next_actionSuggest a clear next action per task without executing it.

Workflow

  1. 1. Take the input

    Receive the raw brain-dump, notes, or messages.

  2. 2. Extract stated tasks

    Pull only the tasks actually expressed — no padding.

  3. 3. Group into projects

    Group tasks into inferred projects, labeled as inferences.

  4. 4. Priority & dates

    Suggest inferred priority; capture a due date only if stated.

  5. 5. Flag ambiguity

    Flag vague items for clarification rather than guessing.

  6. 6. Suggest next actions

    Propose a clear next action for each task.

  7. 7. Present for confirmation

    Offer the organization; act only after the person confirms.

Examples

Brain-dump → organized task list

A messy capture becomes a clean, organized list with sensible structure.

Input

input
Input: 'email the Q3 report to Sarah by Thursday, buy milk, look into the budget thing, call dentist.'

Output

output
{
  "tasks": [
    { "task": "Email the Q3 report to Sarah", "project": "Work (inferred)", "priority": "high (inferred — has a deadline)", "due": "Thursday", "next_action": "Attach the Q3 report and send to Sarah", "flag": "ok" },
    { "task": "Buy milk", "project": "Errands (inferred)", "priority": "low (inferred)", "due": "no date", "next_action": "Add to shopping list", "flag": "ok" },
    { "task": "Look into the budget thing", "project": "Work (inferred)", "priority": "med (inferred)", "due": "no date", "next_action": "Clarify what 'budget thing' refers to", "flag": "needs_clarification" },
    { "task": "Call dentist", "project": "Personal (inferred)", "priority": "med (inferred)", "due": "no date", "next_action": "Find dentist number and call", "flag": "ok" }
  ],
  "needs_clarification": ["'Look into the budget thing' — what specifically? (which budget, what's needed)"],
  "proposed_actions": ["On your confirmation, I can add these four tasks to your task app — nothing added yet"],
  "note": "Captured only stated tasks. Priorities/projects are inferred. Nothing scheduled, sent, or completed without your confirmation."
}

Note: Each task is captured faithfully, grouped into an inferred project, with priority labeled as inferred and a due date only where stated (Thursday). The vague 'budget thing' is flagged for clarification rather than guessed. Nothing is added until you confirm.

Vague item → capture as-is, flag for clarification

An ambiguous note is captured honestly without inventing specifics.

Input

input
Input: 'deal with the thing for John, and sort out the other stuff before the deadline.'

Output

output
{
  "tasks": [
    { "task": "Deal with the thing for John", "project": "unknown (inferred)", "priority": "med (inferred)", "due": "no date", "next_action": "Clarify what 'the thing for John' is", "flag": "needs_clarification" },
    { "task": "Sort out the other stuff before the deadline", "project": "unknown (inferred)", "priority": "med (inferred)", "due": "no date (a 'deadline' is mentioned but not specified)", "next_action": "Clarify what 'the other stuff' is and the actual deadline", "flag": "needs_clarification" }
  ],
  "needs_clarification": ["'the thing for John' — what is it?", "'the other stuff' and 'the deadline' — what tasks, and what date?"],
  "proposed_actions": ["Holding these until you clarify — I won't guess the details or invent a deadline"],
  "note": "Captured only stated tasks. Priorities/projects are inferred. Nothing scheduled, sent, or completed without your confirmation."
}

Note: Rather than invent that 'the thing for John' is an email due Friday, the agent captures both items as stated and flags them for clarification — including the unspecified 'deadline,' which it does NOT turn into a concrete date. Faithful capture beats confident guessing.

Asked to auto-schedule/send → refuse, propose and wait for confirmation

The request wants the agent to take real actions. It organizes and proposes, but won't act unprompted.

Input

input
Request: 'Just add everything to my calendar, email Sarah the report now, and mark the old tasks done.'

Output

output
{
  "tasks": [
    { "task": "Email the Q3 report to Sarah", "project": "Work (inferred)", "priority": "high (inferred)", "due": "Thursday", "next_action": "Prepare email to Sarah with the report attached — send on your confirmation", "flag": "ok" }
  ],
  "needs_clarification": [],
  "proposed_actions": [
    "I won't auto-add everything to your calendar or send the email to Sarah on my own — sending a report or creating calendar events are real actions I shouldn't take without your go-ahead (a misread or wrong attachment would go out for real).",
    "I also won't mark old tasks 'done' without confirmation — I can't verify they're actually complete. Here's the organized proposal: confirm and I'll (1) add these tasks, (2) draft the email to Sarah for your review, (3) list the tasks you'd mark done so you can confirm."
  ],
  "note": "Captured only stated tasks. Priorities/projects are inferred. Nothing scheduled, sent, or completed without your confirmation."
}

Note: The defining defensive case: asked to auto-create calendar events, send an email, and complete tasks. The agent refuses to take these real actions unprompted — a wrong send or a falsely-completed task has real consequences. It organizes everything, drafts the email for review rather than sending, and asks for confirmation before any action. Propose, don't auto-execute.

Implementation notes

  • Capture only tasks the person actually stated; padding the list with assumed work creates noise and erodes trust in the system.
  • Never invent due dates or owners; 'no date' is the correct output when none was stated, and a mentioned-but-unspecified 'deadline' must not be turned into a concrete date.
  • Label inferred priorities and project groupings as inferences for the person to confirm, rather than presenting them as facts.
  • Propose organization but never auto-schedule, send, complete, or delete without explicit confirmation — these are real actions with real consequences.
  • Flag ambiguous items for clarification instead of guessing specifics, keeping the capture faithful to intent.
  • Draft, don't send: where a task implies a message, prepare it for review rather than sending it.
  • A cheaper model can extract and group clear tasks; reserve the strong model for ambiguity and next-action suggestions.

Variations

Basic

Task capturer

Turns a brain-dump into a clean, organized task list with inferred projects and priorities. Proposes only.

Advanced

Organized with flags

Adds due-date handling, ambiguity flagging, next-action suggestions, inferred-label discipline, and a confirmation gate before any action.

Enterprise

Capture workflow

Adds task-app integration, multi-source capture (notes, messages), confirmation workflows, and review before anything is created or sent.

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