Use Cases and Examples

Practical examples of using TR-1 with AI agents via MCP, automation scripts, and team workflows.

Section: Use Cases and Examples

Processing external systems into actions

One of the most powerful patterns with TR-1 is having agents read from other systems and turn what they find into tasks. The agent connects to a data source, applies judgement about what matters, and files actionable items into your GTD system.

Email triage

An agent with access to your email (via Gmail MCP or similar) can scan your inbox and extract actions.

You: "Check my email and pull out anything I need to act on"
Agent: [reads recent emails]
Agent: [calls capture — "Reply to Lisa re: contract renewal by Friday"]
Agent: [calls capture — "Review attached budget spreadsheet from CFO"]
Agent: [calls capture — "Book travel for NYC conference (April 15-17)"]
Agent: "Found 3 actionable items. I've put them in your inbox for processing."

The agent doesn’t just forward emails — it reads them, identifies the action, and writes a clear task title. You process the inbox as normal.

Slack catch-up

After a day off or a long meeting, have an agent scan Slack for things that need your attention.

You: "Scan the last 24 hours in #engineering and #product, anything I need to do?"
Agent: [reads Slack channels]
Agent: [calls create_task — "Review RFC: new caching layer (posted by Dan in #engineering)"]
Agent: [calls create_task — "Weigh in on pricing tier discussion in #product"]
Agent: [calls create_task — "Unblock Maria — she needs API access to staging"]
Agent: "3 items created in Next Actions for the relevant projects."

GitHub / PR review queue

An agent can check your GitHub notifications or assigned PRs and create review tasks.

You: "What PRs need my review?"
Agent: [checks GitHub for PRs requesting your review]
Agent: [calls create_task — "Review PR #187: Refactor auth middleware" with link in notes]
Agent: [calls create_task — "Review PR #192: Add export feature" with link in notes]
Agent: "2 PRs need your review. Added to Next Actions."

Meeting notes to actions

After a meeting, feed the notes (or a recording transcript) to an agent and let it extract commitments.

You: "Here are the notes from the design review. Pull out action items for me."
Agent: [reads notes]
Agent: [calls create_task — "Share updated mockups with client by Thursday"]
Agent: [calls create_task — "Set up user testing sessions for next sprint"]
Agent: [calls create_task — "Follow up with Dave on icon licensing" — status: waiting]
Agent: "3 action items created. The follow-up with Dave is in Waiting For."

Calendar review

An agent with calendar access can scan upcoming events and create preparation tasks.

You: "Look at my calendar for next week, anything I need to prep for?"
Agent: [reads calendar events]
Agent: [calls create_task — "Prep Q2 roadmap slides for Monday board meeting" — dueDate: Friday]
Agent: [calls create_task — "Review candidate resume before Wednesday interview"]
Agent: [calls create_task — "Send agenda for Thursday retro"]

Voice notes and recordings

If you use a voice recorder (like SR-7), an agent can process transcripts into structured tasks.

You: "Process my voice notes from today"
Agent: [reads transcripts]
Agent: [calls capture — "Call the electrician about the kitchen outlet"]
Agent: [calls capture — "Write blog post about MCP patterns"]
Agent: [calls capture — "Look into that restaurant Sarah mentioned — Italian place in downtown"]
Agent: "3 items captured to inbox from today's recordings."

The pattern is always the same: the agent reads unstructured input from another system, applies judgement to identify what’s actionable, and creates well-titled tasks in TR-1. You stay in your GTD flow — everything is captured, nothing falls through the cracks.

Working with AI Agents via MCP

TR-1’s MCP server gives AI agents the same capabilities you have in the app. Here are common patterns.

Capture tasks during a coding session

When you’re working with an AI coding agent (Claude Code, Cursor, etc.), it can capture tasks as they come up naturally — no context switching.

You: "We should also add rate limiting to this endpoint"
Agent: [calls capture with title "Add rate limiting to /api/v1/tasks"]
You: "Put it in the TR-1 project"
Agent: [calls move_task to assign it to the project]

The task lands in your system without you leaving your editor. The agent can also set status, energy, and priority if you tell it to.

Morning briefing

Ask your agent to run a daily review at the start of the day.

You: "What's on my plate today?"
Agent: [calls daily_review]

The agent checks your Today list, flags overdue tasks, surfaces tasks that became active (deferred until today), and gives you a summary. It can also pull in your calendar context if connected to other tools.

Triage inbox items

Process your inbox with the agent’s help. The agent reads each item, asks you what to do with it, and processes it.

You: "Let's clear the inbox"
Agent: [calls get_inbox — returns 12 items]
Agent: "First item: 'Look into new CI provider'. What do you want to do with it?"
You: "Next actions, low energy, put it in the DevOps project"
Agent: [calls process_inbox_item with status: next, energy: low, projectId: ...]
Agent: "Done. Next: 'Reply to Sarah about Q2 budget'..."

Weekly review

The weekly review is the cornerstone of GTD. An agent can walk you through it.

You: "Let's do the weekly review"
Agent: [calls start_weekly_review]
Agent: [calls review_projects — identifies 2 projects with no next actions]
Agent: "Project 'Website redesign' has no next action. What's the next step?"
You: "Create wireframes for the new landing page"
Agent: [calls create_task with title and projectId]

The agent can check each project, flag stale items in Waiting For, scan Someday/Maybe for anything that should become active, and verify your inbox is at zero.

Agent picks up work autonomously

Agents can browse your task list and pick up work on their own.

Agent: [calls get_next_actions with projectId for "TR-1"]
Agent: "I see 'Add rate limiting to /api/v1/tasks' in Next Actions. I'll start on that."
Agent: [calls update_task — sets inProgress: true, today: true]
Agent: [does the work]
Agent: [calls complete_task]
Agent: [calls create_task — "Add rate limit tests" as follow-up]

The real-time sync means you see the agent’s progress in the app instantly. A toast notification appears when the agent makes changes.

Context-aware task suggestions

Agents can filter tasks by energy level and context to suggest what to work on.

You: "I have 30 minutes and I'm low energy, what can I knock out?"
Agent: [calls get_next_actions]
Agent: [filters for energy: low]
Agent: "Here are 4 quick tasks you could do:
  1. Reply to Sarah about Q2 budget
  2. Update README with new API endpoints  
  3. Review PR #42
  4. Cancel unused Heroku addon"

Multi-agent workflows

TR-1 supports multiple agents working from the same task list. Each agent authenticates independently and their actions are tracked in the activity log.

Specialist agents

Set up different agents for different types of work:

  • Coding agent (Claude Code) — picks up implementation tasks, marks them in progress, completes them, creates follow-ups
  • Research agent — takes research tasks, adds findings to task notes
  • Review agent — runs daily/weekly reviews, flags issues, suggests priorities

All agents see the same task list. They coordinate through task status — if one agent marks a task as in progress, others won’t pick it up.

Human-in-the-loop

You stay in control. Agents can create, update, and complete tasks, but you decide what’s important through the Today flag and priority. The activity log shows exactly what each agent did, and undo_action lets you reverse any agent action.

Automation with the REST API

Daily digest script

Send yourself a summary of today’s tasks every morning:

#!/bin/bash
TASKS=$(curl -s -H "Authorization: Bearer $TR1_KEY" \
  https://tr1.fieldbw.com/api/v1/today)

COUNT=$(echo "$TASKS" | jq length)
TITLES=$(echo "$TASKS" | jq -r '.[].title' | sed 's/^/- /')

echo "You have $COUNT tasks today:"
echo "$TITLES"

Create tasks from other tools

Pipe tasks in from anywhere — GitHub issues, Slack messages, email:

# From a GitHub webhook
curl -X POST https://tr1.fieldbw.com/api/v1/tasks \
  -H "Authorization: Bearer $TR1_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Review: PR #42 — Add search filters",
    "status": "next",
    "projectId": "your-project-id",
    "notes": "https://github.com/org/repo/pull/42"
  }'

Bulk operations with batch_tasks (MCP)

Reorder or update multiple tasks in one call:

{
  "operations": [
    { "action": "update", "id": "task-1", "data": { "sortOrder": 1 } },
    { "action": "update", "id": "task-2", "data": { "sortOrder": 2 } },
    { "action": "complete", "id": "task-3" }
  ]
}

Tips

  • Keep the inbox at zero. Process it daily, either manually or with an agent. Items should move to Next Actions, a project, Someday/Maybe, or the trash.
  • One next action per project. If a project has no next action, it’s stuck. Weekly reviews catch these.
  • Use energy tags. When you’re low energy, filter for low-energy tasks. When you’re sharp, tackle the high-energy ones.
  • Defer liberally. If something isn’t relevant until next week, schedule it. It’ll reappear when it’s time.
  • Let agents capture. Don’t interrupt your flow to add tasks. Tell your agent and keep working.