ThinkNimble Research

Matching Agents and To-Do's
Active

Matching Agents and To-Do's

Teaching AI to understand what you actually mean

A system that matches your natural language tasks to the right specialized agents, so you don't have to remember which tool does what.

The Context

Marcy: “I have like 47 things on my to-do list at any given time. Some are vague (“figure out the deployment thing”), some are specific (“update the API endpoint to return user preferences”). And now I have this whole Agency of Agents with specialized agents that could help - a PRD analyzer, a meeting transcriber, a status report generator.

But here’s the annoying part: I have to remember which agent does what and manually assign tasks. Or I just use ChatGPT for everything and lose the benefit of having these specialized agents that know our workflow.”

So we’re building a tool to help us make sure we use the right tools at the right time, and don’t forget any to-do’s. It’s like Motion’s “AI calendar/task system” but instead of just reorganizing our calendars, it suggests which agent should handle each task.

The Idea

A plugin that lays over your to-do list and matches tasks to the right agent from your Agency of Agents. You write down “need to turn this week’s meeting notes into tickets” and it suggests the Meeting → Tickets agent. You write “figure out why the deploy failed” and it knows that’s different from “write a PRD for the new feature.”

The flow:

  1. We dump our to-do list in Google Tasks (or wherever - in the future we can support any task manager you already love)
  2. The system matches each task to agents we’ve already built
  3. It groups similar tasks together - do all your PRDs back to back, batch all your status reports
  4. Agents run on tasks they can handle autonomously, or create to-do’s for things they recognize are missing
  5. We get a morning review session for anything that needs our input

Instead of context-switching between 12 different types of work, we do focused blocks and let the agents handle the translation work.

How It Works

1. Task Analysis

Parse your to-do list and figure out:

2. Agent Matching

Compare each task against your Agency of Agents:

3. Context Assembly

So if you’re running the Meeting → Tickets agent, it doesn’t get access to your entire Google Drive. It gets the specific meeting doc you pointed at, plus maybe the current sprint board for context. Or, asks you for the right data.

4. Execution Coordination

For tasks that can run autonomously:

For tasks that need your input:

For tasks you may have missed:

Current Status

Weekend project territory. We built a vibe coded version with Figma Make and Claude, on our tn-bootstrapper.

The question isn’t whether it’s technically possible - it clearly is. The questions are:

Where We Could Go

The interface we want is proactive notifications that understand our workflows:

Friday at 4pm: “It’s Friday. Bet you didn’t send client roundups. I prepped them and they’re ready for your review here.”

Tuesday morning: “It’s Tuesday and you have all your client check-ins. Here’s the Friday summaries, and here’s what from your task list to monitor this week.”

Monday afternoon: “You don’t have tasks queued in GitHub for Cue for next week. Do you have a PRD? Want to build one?”

It’s not just “which agent should run on this task” - it’s “based on your calendar, your recurring responsibilities, and your current task list, here’s what needs to happen and I already started it for you.”

We’re sure this exists somewhere, but if it could plug into Agency of Agents instead of generic AI, it would actually understand how we work, not just what we’re working on.

What We’re Learning

The Interface Is More Important Than The Matching

Getting a perfect agent match doesn’t matter if we have to manually trigger it every time. The magic is in “it’s Friday, you always do this on Friday, I already did it.”

Trust Comes From Explanations

“I picked the Status Report agent because it’s Friday and you have 3 client check-ins next week” is way more trustworthy than silent automation.

Context Permissions Are The Hard Part

We don’t want to give agents unfettered access to everything. But we also don’t want to manually approve every document reference. The right model is probably: “This agent wants access to the last 5 meeting notes from Project X. Approve once and remember for next time?”

Batching Similar Work Actually Saves Time

If we could do all our PRDs in one focused 2-hour block instead of scattering them across the week, that alone would be worth building this.

Open Questions

  1. What’s the minimum viable version?
    • What actually saves us the most time?
    • What do we remember to use?
  2. How does it learn individual patterns?
    • If we override a suggestion, does it update the model?
    • If we always run Status Reports on Friday at 4pm, does it start suggesting that automatically?
    • How does it avoid learning bad habits?
  3. What’s the context approval UX?
    • “This agent wants access to [these 5 docs]. Approve?”
    • “Remember this approval for similar tasks?”
    • How do we revoke access later, or ensure we don’t have data leaks?
  4. Is this actually better than just using ChatGPT?
    • The whole point is that specialized agents know our workflow
    • But if the overhead of matching/approving/batching is too high…
    • Maybe the real win is just “run these recurring tasks automatically” and forget the smart matching?

Why This Matters

Right now we have a few specialized agents in the Agency of Agents. We can remember what each one does and usually remember to use them. But we often forget because it takes as much time to use it as it does to do it ourselves. The cognitive load of “should we use an agent for this?” kills the momentum. If we have to stop, think about which agent, go find it, set it up, and run it - we’ll just do the task manually.

But if the system just says “Hey, I can do that for you” in a system we’re already using, we just might start to automate ourselves.