AI Agent for Things 3: Automate Task Management, Project Planning, and Productivity Tracking

Things 3 is the best personal task manager ever made. It's also, from an automation standpoint, a beautiful walled garden with no front door.

Cultured Code built something gorgeous — the kind of app that makes you want to organize your life. But they've been crystal clear: there's no public REST API, no webhooks, no real-time sync endpoint. You get a URL scheme that's essentially write-only, Apple Shortcuts that work until they don't, and a local SQLite database that the community has reverse-engineered out of necessity.

For years, that's been fine. Things 3 is a personal tool. You capture, you organize, you do the work. But if you're a freelancer managing fifteen client projects, a consultant juggling deliverables across three engagements, or a solopreneur trying to run an entire business out of your task manager — you've already felt the ceiling.

You can't pull structured data out easily. You can't trigger actions when tasks change state. You can't connect it to your CRM, your email, your invoicing tool, or your calendar in any meaningful bidirectional way. And you definitely can't get intelligent recommendations about what to work on next based on your actual patterns.

That's the problem an AI agent solves. Not Things 3's problem — Things 3 is doing exactly what it wants to do. Your problem. The gap between a beautiful task list and an intelligent productivity system.

Here's how to build one with OpenClaw.

Why Things 3 Needs an External Brain

Let me be specific about what's missing, because "AI agent" means nothing without concrete use cases.

Things 3 can't read its own data programmatically in a useful way. The URL scheme lets you add tasks all day long. Creating a task with things:///add?title=Follow%20up%20with%20Acme&when=next-thursday&tags=client-acme works great. But asking "what are all my tasks tagged @waiting that are more than 5 days old?" — that requires cracking open the SQLite database at ~/Library/Group Containers/JLMPQHK86H.com.culturedcode.ThingsMac/Things Database.thingsdatabase/main.sqlite and running queries against a schema that Cultured Code doesn't officially document.

There's no event system. When you complete a task, nothing happens outside of Things 3. No webhook fires. No automation triggers. If completing a client deliverable should update your CRM, send a Slack message, and create an invoice line item — you're doing that manually.

There's no intelligence layer. Things 3 shows you your Today list. It doesn't know that you always do deep creative work on Tuesday mornings, that you've been pushing the same three tasks forward for two weeks, or that your "Someday" list has 47 items you'll never touch.

An AI agent built on OpenClaw fills every one of these gaps without requiring Cultured Code to change a single thing about their product.

The Architecture: How This Actually Works

The most reliable approach combines three integration surfaces that Things 3 already exposes, orchestrated by an OpenClaw agent that adds the intelligence layer.

Reading: Direct SQLite Access

The Things 3 database is a local SQLite file. The community has maintained documentation of the schema for years, and it's remarkably stable. Your key tables:

• TMTask — every task, project, and heading
• TMArea — your areas of responsibility
• TMTag — tags and their relationships
• TMTaskTag — junction table linking tasks to tags

Here's a basic query to find all open tasks tagged @waiting that haven't been modified in over 5 days:

SELECT 
    t.title,
    t.notes,
    datetime(t.creationDate, 'unixepoch', '+31 years') as created,
    datetime(t.userModificationDate, 'unixepoch', '+31 years') as modified
FROM TMTask t
JOIN TMTaskTag tt ON t.uuid = tt.tasks
JOIN TMTag tag ON tt.tags = tag.uuid
WHERE tag.title = '@waiting'
    AND t.status = 0
    AND t.trashed = 0
    AND (julianday('now') - julianday(datetime(t.userModificationDate, 'unixepoch', '+31 years'))) > 5
ORDER BY t.userModificationDate ASC;

(The +31 years offset is a Things 3 quirk — they use a modified epoch starting from 2001-01-01 instead of 1970-01-01.)

An OpenClaw agent can run queries like this on a schedule, building a real-time understanding of your task landscape without Things 3 needing to "support" it.

Writing: URL Scheme

For creating and modifying tasks, the things:/// URL scheme is genuinely capable:

things:///add?title=Review%20Q3%20proposal%20for%20Acme&when=tomorrow&deadline=2026-01-20&tags=client-acme,high-energy&list=Active%20Clients&heading=Acme%20Corp&checklist-items=Read%20through%20proposal%0ACheck%20pricing%0AFlag%20concerns%0ADraft%20response

That single URL creates a task with a title, start date, deadline, multiple tags, places it in a specific project under a specific heading, and adds four checklist items. The URL scheme also supports things:///add-project for creating entire project structures in one shot.

Orchestration: OpenClaw as the Intelligence Layer

This is where it gets interesting. OpenClaw sits between the read layer (SQLite) and the write layer (URL scheme) and adds everything Things 3 doesn't have: pattern recognition, natural language processing, cross-system integration, conditional logic, and proactive behavior.

Your OpenClaw agent becomes the middleware that transforms Things 3 from a static list into a dynamic system.

Five Workflows Worth Building

Let's get concrete. These are the workflows that actually move the needle for people using Things 3 professionally.

1. Intelligent Inbox Triage

The problem: You dump everything into the Things 3 Inbox throughout the day — quick captures from your phone, thoughts during meetings, items forwarded from email. By Friday, there are 40 items sitting there, and your weekly review takes an hour just sorting them.

The OpenClaw agent workflow:

The agent reads new Inbox items from the SQLite database, analyzes each one using context from your existing projects, areas, and tag taxonomy, then generates a triage recommendation:

• Suggested project placement based on keyword matching against existing projects
• Recommended tags based on your historical tagging patterns
• Proposed deadline based on similar past tasks
• Energy level tag based on task complexity analysis
• A "discard" flag for items that look like duplicates or brain dumps you've already handled

The agent surfaces these recommendations — and for items where confidence is high, it can auto-file them using the URL scheme. Items where confidence is lower get presented to you with one-tap approve/modify options.

Result: Your 60-minute weekly triage becomes 10 minutes of reviewing the agent's work and correcting the 15% it wasn't sure about.

2. Automatic Project Decomposition

The problem: You add a project called "Redesign client onboarding flow" and it sits there as a single line item for three weeks because breaking it down into actionable steps requires thinking you keep deferring.

The OpenClaw agent workflow:

When the agent detects a new project in the database with no tasks or headings, it analyzes the project title and notes, cross-references against similar past projects you've completed (the SQLite database keeps completed items), and generates a full project structure.

For "Redesign client onboarding flow," the agent might generate:

things:///add-project?title=Redesign%20Client%20Onboarding%20Flow&area=Clients&tags=high-energy&headings=Research%0ADesign%0ABuild%0AReview&items=[
  {"title":"Audit current onboarding emails","heading":"Research","tags":["low-energy"]},
  {"title":"Interview 3 recent clients about onboarding experience","heading":"Research","tags":["high-energy"]},
  {"title":"Map current vs. ideal customer journey","heading":"Research","tags":["high-energy"]},
  {"title":"Sketch new onboarding flow wireframes","heading":"Design","tags":["high-energy","deep-work"]},
  {"title":"Write copy for new welcome sequence","heading":"Build","tags":["high-energy"]},
  {"title":"Build email templates in platform","heading":"Build","tags":["low-energy"]},
  {"title":"Internal review with team","heading":"Review","tags":["low-energy"]},
  {"title":"Pilot with next 5 signups","heading":"Review"}
]

(Simplified — the actual JSON-encoded URL scheme for project creation is more verbose, but OpenClaw handles the encoding.)

You review the generated structure, tweak what needs tweaking, and now you have an actionable project instead of a guilt-inducing placeholder.

3. The Weekly Review Co-Pilot

The problem: The weekly review is the most important productivity habit and the first one people drop. It's cognitively demanding — you need to review what you completed, assess what's stalled, reprioritize, and plan ahead.

The OpenClaw agent workflow:

Every Friday at 2pm (or whenever you schedule it), the agent runs a comprehensive analysis:

Completed this week: Queries the database for tasks completed in the last 7 days, grouped by area and project. Generates a "shipped" summary you can paste into a team update, client report, or personal journal.

Stalled items: Identifies tasks that have been on the Today list for 3+ consecutive days without completion (the agent tracks this over time via its own state). Recommends: break it down, delegate it, defer it, or delete it.

Overdue follow-ups: Surfaces all @waiting items past their deadline with suggested follow-up actions.

Next week priorities: Based on upcoming deadlines, project momentum, and your stated goals, suggests a "Top 5" for the coming week.

Pattern insights: "You completed 23 tasks this week, up from 17 last week. 60% were tagged @low-energy. You haven't touched the 'Business Development' area in 14 days."

This transforms the weekly review from a blank-page exercise into a structured conversation with an agent that's already done the analysis.

4. Cross-System Task Generation

The problem: Tasks come from everywhere — email, Slack, calendar meetings, CRM updates, client portals — but they only count if they make it into Things 3. And they usually don't.

The OpenClaw agent workflow:

The agent monitors your connected systems and auto-generates Things 3 tasks for actionable items:

• Email: Scans for emails where you're in the To field with action-oriented language ("Can you review," "Please send," "We need"). Creates a task with the email subject, sender as a tag, and a link back to the message in notes.
• Calendar: After each meeting, creates a follow-up task with attendee names and a prompt to add action items from your notes.
• CRM: When a deal moves to a new stage, creates the corresponding tasks in your sales pipeline area.
• Slack: When you react to a message with a specific emoji (say, ✅), the agent captures it as a Things 3 task.

Each generated task includes its source system in the notes, so you maintain traceability without Things 3 needing native integrations with any of these tools.

5. Predictive Daily Planning

The problem: You start each day looking at a Today list that's either overwhelming (30 items) or empty (because you forgot to plan last night). Neither state is useful.

The OpenClaw agent workflow:

Each morning (or the night before), the agent builds an optimized daily plan:

1. Checks your calendar for meetings and committed time blocks
2. Identifies tasks with today's deadline (non-negotiable)
3. Reviews your available time slots and matches them against task energy levels and estimated durations
4. Pulls from your prioritized project list to fill remaining capacity
5. Writes the curated Today list back to Things 3 using the URL scheme, with tasks ordered by suggested execution time

The agent learns your patterns over time. If you consistently don't complete more than 7 tasks in a day, it stops suggesting 12. If you never do deep work after 3pm, it front-loads high-energy tasks.

Implementation: Getting Started with OpenClaw

Here's the practical path to building this:

Step 1: Set up database read access. Write a lightweight script that queries the Things 3 SQLite database and exposes the data to your OpenClaw agent. This runs locally on your Mac. The key tables you need are TMTask, TMArea, TMTag, and TMTaskTag. Start with read-only access — don't write to the database directly. Ever.

Step 2: Configure URL scheme writes. Build a library of URL scheme templates for your most common write operations: add task, add project, show list. OpenClaw will populate these templates dynamically based on agent decisions.

Step 3: Define your agent's behavior in OpenClaw. Start with a single workflow — I'd recommend Inbox triage or the weekly review co-pilot, since they deliver the most immediate value. Define the trigger (schedule, manual, or event-based), the data the agent needs to read, the analysis it should perform, and the actions it can take.

Step 4: Layer in cross-system integrations. Once your core Things 3 agent is working, start connecting the input sources — email, calendar, Slack, CRM. Each one becomes a new trigger that can feed into your existing triage and task creation logic.

Step 5: Build the feedback loop. The agent should track which of its suggestions you accept, modify, or reject. Over time, this makes every recommendation more accurate. OpenClaw handles the state management and learning layer so you're not building a custom ML pipeline.

What This Looks Like in Practice

After a few weeks of running an OpenClaw agent on top of Things 3, your experience changes fundamentally:

You still open Things 3 every morning to a clean, focused Today view. But now that view was intelligently curated overnight based on your deadlines, energy patterns, and calendar. Your Inbox has three items in it instead of thirty because the agent already filed the obvious ones. Your weekly review takes fifteen minutes because the analysis is already done. And tasks from email, Slack, and your CRM appear in the right projects with the right tags without you lifting a finger.

Things 3 stays exactly what it is — a beautiful, fast, focused task manager. OpenClaw adds the intelligence, automation, and cross-system awareness that turns it into something greater than the sum of its parts.

You're not replacing Things 3. You're giving it a brain.

---

Build This With Us

If this is the kind of system you want but you don't have the time or technical depth to build it yourself, that's exactly what Clawsourcing is for.

We'll design, build, and deploy a custom OpenClaw agent tailored to your Things 3 setup — your tag taxonomy, your project structure, your connected systems, your workflows. You describe how you work; we build the agent that makes it smarter.

No templates. No generic chatbot. A real AI agent that understands your specific system and runs autonomously on top of it.

Get started with Clawsourcing →