Task Management for AI Agents

AI agents are moving from demos to production, and managing them is becoming a discipline of its own. You're deploying autonomous agents that research, write, code, analyze, and take actions - but they need oversight, guardrails, and coordination. Tracking what your agents are doing, what they've produced, and where humans need to step in requires project management designed for mixed human-AI workflows.

t0ggles is a task tracker built for mixed human and AI agent teams: track autonomous workflows, put human-in-the-loop checkpoints on the board, and coordinate between agents and human operators. With native MCP server support, your agents manage their own tasks on the board - reading assignments, updating progress, and creating follow-up work. Every action is attributed to a named agent, so you always know who did what. Start on the free plan, and when you outgrow it every feature is $5/user/month.

#The Challenge: Why Managing AI Agents Is Hard

AI agents are a new category of "worker" - they're not humans, but they're not simple automations either. Managing them creates unique problems:

Agents generate unpredictable outputs. Unlike traditional automation with fixed inputs and outputs, AI agents make decisions. Sometimes those decisions are brilliant. Sometimes they hallucinate. You need a system to track outputs and flag items that need human review before they go further.

Human-in-the-loop is the bottleneck. Most agent workflows require human approval at certain stages - reviewing generated content, approving code changes, validating research findings. If these checkpoints aren't visible and structured, humans become the bottleneck that negates the speed advantage of using agents.

Multi-agent coordination is complex. Production systems increasingly use multiple agents working together - a research agent feeds a writing agent, which feeds a review agent. Tracking the handoffs, dependencies, and state across agent chains requires more than a kanban board.

Accountability is unclear. When something goes wrong in an agent workflow, you need an audit trail. Which agent did what? When was the human review? What was the input, and what was the output? Without structured tracking, debugging agent failures means digging through logs instead of looking at a clear timeline.

#How t0ggles Helps AI Agent Teams

#MCP Server: Agents That Manage Themselves

The MCP server is what makes t0ggles uniquely suited for AI agent management. Your agents don't just do work - they participate in the project management process:

Agent self-reporting: When an agent completes a task, it can update its own status on the board. When it encounters a problem, it can create a new task flagged for human review. The agent becomes a self-managing worker that keeps the board current.

Task assignment for agents: Create tasks and assign them to specific agents or agent pipelines. The agent checks its assignments through MCP, processes them, and reports back with results.

Human-agent handoff: Set up workflows where agents do initial work (research, drafting, analysis) and then move the task to a "Human Review" status. The human reviewer sees the agent's output, approves or requests changes, and the agent picks up the revised task.

The workflow looks like this:

Research Agent: checks t0ggles via MCP "I have 3 assigned research tasks."

Research Agent: processes tasks, adds findings as comments "Research complete. Moving to Human Review."

Human Reviewer: reviews findings on the board "AGENT-14 looks good, approved. AGENT-15 needs more depth on competitive analysis."

Research Agent: picks up revised task "Expanding competitive analysis for AGENT-15."

This isn't theoretical - it's how teams are actually using t0ggles to coordinate AI agent workflows today.

#AI Agent Task Board via MCP: A Walkthrough

Here is the minimum setup to give one agent a task board. It works with Claude Code, Cursor, OpenAI Codex, VS Code, Claude Desktop, and OpenCode - the MCP docs have the exact steps for each.

1. Connect the agent to t0ggles. For Claude Code it is one command; other clients take the same URL in their MCP config. Authentication is OAuth: the first connection opens a browser window to sign in, no tokens to paste.

claude mcp add --transport http t0ggles https://t0ggles.com/mcp

{
  "mcpServers": {
    "t0ggles": {
      "url": "https://t0ggles.com/mcp"
    }
  }
}

2. Create an agent user. In Board Settings > Services, add an agent user such as "Claude Developer". It gets a bot user ID like BOT_CLAUDE_DEVELOPER and shows up as an assignee like any team member.

3. Assign tasks to the agent. Drag tasks to the agent the same way you would to a person. The task description is the agent's brief, so write it the way you would for a new hire: goal, constraints, definition of done.

4. Let the agent run its queue. A typical run uses a handful of the 46 MCP tools:

• list-tasks with the agent's assignedUserId returns its queue
• get-task reads the full description, properties, and comments count
• update-task moves the task to In Progress and, when finished, to Human Review
• create-comment posts the result, with @Your Name to notify the reviewer, and botUserId so the comment is attributed to the agent
• create-task files any follow-up work it found along the way

In plain language, the prompt that drives that loop is something like: "List the tasks assigned to BOT_CLAUDE_DEVELOPER on the Backend board, take the highest-priority one, do the work, move it to Human Review, and leave a comment mentioning @Jane Doe with a summary."

5. Review and close. You get the mention notification, read the agent's comment, and either move the task to Done or reassign it back to the agent with feedback. The whole exchange stays on the task.

That is a complete human-in-the-loop loop with no custom dashboard. The step-by-step version, with the exact tool calls and an instructions-file snippet for Claude Code, Cursor, and Codex, is in How to Give Your AI Agents a Task Board. To run it unattended - agents polling for new tasks, chaining into each other, and running on a schedule - use t0ggles Crew.

#t0ggles Crew: AI Agents Working Autonomously

The MCP server lets agents interact with your board. t0ggles Crew takes this further - it's a free desktop companion app that orchestrates AI agents to autonomously pick up tasks, execute work, and manage the full lifecycle without human intervention.

Crew turns your t0ggles board into a dispatch system for AI coding agents. You create tasks, and Crew's pipelines handle the rest:

• Auto scheduling detects new tasks assigned to an agent's bot user and triggers a run automatically
• Pipeline chaining connects agents in sequence - a planner writes the plan, a developer implements it, a reviewer checks the code
• Phased development breaks large tasks into numbered phases with a review between each one
• Bot user identities give each agent its own identity on the board, so you can see exactly who did what

The workflow looks like this:

1. You create a task and assign it to "Claude Planner"
2. The planner researches the codebase and writes an implementation plan
3. A reviewer checks and improves the plan, then assigns to you
4. You approve and reassign to "Claude Developer"
5. The developer implements the code and opens a PR
6. The reviewer checks the PR and assigns to you for final merge

Human checkpoints at steps 3 and 6 keep you in control while automating everything in between. This is human-in-the-loop development as a pipeline setting, not a policy document: the agent cannot proceed past a review step until a person reassigns the task. The full conversation - agent work, human feedback, final implementation - lives on the task for audit and accountability.

Crew supports Claude Code, OpenAI Codex, and OpenCode as CLI providers. Download it free from the t0ggles Crew page.

#Task Dependencies: Model Your Agent Chains

Most production agent systems involve chains - Agent A's output becomes Agent B's input. Task dependencies in t0ggles model these chains explicitly:

1. Data Collection Agent completes research (no dependencies)
2. Analysis Agent processes collected data (depends on #1)
3. Human Review validates analysis (depends on #2)
4. Writing Agent creates report from validated analysis (depends on #3)
5. Final Human Review approves report (depends on #4)

Dependencies with lag days add buffer time for human review stages. The Gantt view shows the full agent pipeline as a timeline, making the critical path visible.

When an agent chain fails at step 2, the dependency graph immediately shows what downstream work is blocked. You don't discover the problem when the final output is missing - you see it in real time.

#Custom Properties: Track Agent Metadata

Custom properties let you track agent-specific data on every task:

• Agent ID (text): Which agent instance handled the task
• Model (select): Claude, GPT, Gemini, Llama, custom fine-tune
• Confidence Score (number): Agent's self-reported confidence in its output
• Token Usage (number): Track cost per task
• Review Status (select): Pending, Approved, Needs Revision, Rejected
• Output Type (select): Research, Draft, Analysis, Code, Decision

Filter tasks by confidence score to find items that need closer human review. Sort by token usage to identify expensive operations. The metadata makes agent management data-driven instead of guesswork.

#Multi-Project Boards: Organize by Agent or Workflow

Different organizational approaches work for different teams. t0ggles multi-project boards support any structure:

• By agent: Research Agent project, Writing Agent project, Code Agent project
• By workflow: Content Pipeline project, Analysis Pipeline project, Customer Support project
• By client: Client A project, Client B project - each with its own agent workflows

Focus Mode lets you zoom into one agent or pipeline when you need detail, then pull back to see the full picture across all active workflows.

#How Do You Track Which AI Agent Did What?

Two features together answer this. Agent users give each agent a named identity on the board with its own robot avatar. Change history records every change to every task under the identity that made it. Put them together and the question "which agent did what?" has a per-task answer:

• When the agent received the task, and from whom
• Every status move, with the previous and new status
• Title, description, priority, tag, assignee, and custom property changes, each with the old and new value
• Comments the agent posted, attributed to its bot user
• What human reviewers changed afterwards, in the same timeline

Because agent actions and human actions share one history, you can see the exact sequence: agent moved to Human Review at 14:02, reviewer changed priority and reassigned at 14:20, agent moved to Done at 14:41. Agent activity also appears in the board's notification feed, so reviewers see agent work as it happens rather than on a report later.

For compliance-sensitive industries using AI agents, this audit trail is essential. You can demonstrate exactly what the agent did, when humans reviewed it, and what approvals were granted.

#Agent Workflow Tracing and Monitoring

Tracing an agent workflow means following one piece of work across several agents and humans, and monitoring means watching the whole system for stalls. t0ggles covers both at the task level rather than the log level:

• Trace one task end to end. The task's change history and comments are the trace: which agent picked it up, what it produced, who reviewed it, and what happened next. No log correlation needed.
• Trace across agents. Task dependencies link the research task to the analysis task to the report task, so the Gantt view shows the chain and where it is blocked.
• Monitor the board. The kanban board is the live view: a column that keeps filling up means an agent is producing faster than reviewers approve, and a task sitting In Progress for hours means an agent has stalled. Reports show throughput and workload per assignee, including agent users.
• Pull it into your assistant. The get-activity-log MCP tool returns recent task events for a board, so an assistant can answer "what did the agents do overnight?" directly. get-blocked-tasks and list-overdue-tasks surface the stalls.
• Run-level logs. When agents run through t0ggles Crew, every run keeps its full terminal output, duration, and result in run history alongside the task-level trace on the board.

#Board Automations: Streamline the Review Loop

Board automations reduce the manual overhead of managing agent-human handoffs:

• When an agent moves a task to "Review Needed", automatically notify the assigned reviewer
• When a human approves a task, automatically move it to the next agent's queue
• When a task has been in "Review Needed" for more than 24 hours, escalate with a notification
• Auto-tag tasks based on the agent that processed them

The automation keeps the agent-human review loop running smoothly without constant manual intervention.

#Board Forms: Structured Intake Your Agents Can Triage

An agent pipeline is only as good as the requests feeding it. Board forms give you a public intake form per board - a bug report form, a research request form, an internal "ask the agent team" queue - shared by link and landing on the board as properly routed tasks.

Choice options in a form are real board entities, so the request type picker sets the project, urgency sets priority, and the submission arrives in the right agent's queue already tagged. File upload catches the screenshots and log files the agent needs for context. Anything the form doesn't map to a field lands in a structured block in the task description - exactly the shape an agent can read through MCP.

Turn on the approval queue and submissions wait for review before they become tasks. That's a human gate at the front of the pipeline, or an AI one: your assistant reads the pending queue through MCP, spots duplicates, and recommends what to approve. The two-way email thread on each submission lets you go back to the submitter for detail and tell them when the agent shipped the fix.

#AI Agent Workflows In t0ggles

#Content Generation Pipeline

A content team uses AI agents to generate blog posts, social media content, and email campaigns. The workflow:

1. Content Strategist creates tasks with topics and briefs
2. Research Agent gathers relevant information and adds findings as comments
3. Task moves to "Research Review" - human validates sources and direction
4. Writing Agent creates the draft based on approved research
5. Task moves to "Edit Review" - human editor refines the output
6. Publishing Agent formats and schedules the approved content

Each stage is a task with dependencies. Custom properties track word count, target audience, SEO keywords, and publication date. The board shows the entire content pipeline - from idea to published - with clear visibility into where each piece stands.

#Customer Support Triage

AI agents handle first-line customer support triage, categorizing tickets and drafting responses:

1. Intake Agent reads incoming tickets and creates tasks on the board
2. Each task gets custom properties: Category, Urgency, Suggested Response
3. Tasks with high urgency go directly to human agents
4. Tasks with high confidence get an "Auto-Response" status for quick human approval
5. Human agents review, approve or modify, and send

When the tickets arrive through a board form on your public site, the category and urgency pickers have already set the project and priority before the intake agent looks at them. The board becomes a real-time dashboard of support volume, agent performance, and human review load. Reports show how many tickets the AI handles autonomously versus how many need human intervention.

#Code Review and Refactoring

A development team uses AI agents to assist with code review and suggest refactoring:

1. Developer creates a task describing a codebase area that needs attention
2. Analysis Agent reviews the code and creates subtasks for each suggested improvement
3. Each subtask includes the proposed change, rationale, and risk assessment
4. Human developer reviews suggestions, approves the good ones, rejects the rest
5. Coding Agent implements approved changes and creates pull requests

Dependencies ensure the agent doesn't start coding until the human has approved the suggestions. The full conversation - agent analysis, human feedback, final implementation - lives on the task for future reference.

#What AI Agent Teams Need vs What t0ggles Delivers

#Why Choose t0ggles for AI Agent Management

vs custom dashboards: Building a custom agent management dashboard takes engineering time away from building the agents themselves. t0ggles gives you a ready-made coordination layer with the flexibility to adapt to any agent workflow.

vs Jira: Jira's heavyweight workflows add friction to the fast iteration cycles that agent development requires. t0ggles is setup in minutes, not days.

vs spreadsheets: Agent workflows are dynamic - tasks are created, dependencies shift, statuses change in real time. Spreadsheets can't handle the concurrency or provide the real-time visibility that agent management demands.

vs observability tools: Tracing platforms show you spans and tokens. They don't show you which task the run was for, who asked for it, or whether a human approved the result. t0ggles is the work-level system of record for agents; keep your tracing tool for the model-level view.

The MCP advantage: t0ggles is the only project management tool where your AI agents can be first-class participants. They're not just tracked on the board - they actively interact with it through MCP. This closes the loop between agent execution and project management.

#Simple, Affordable Pricing

Start on the free plan - no card, no trial clock. It is enough to wire up your first agent through MCP and watch it manage its own tasks on the board. See what's included.

When you outgrow it, one plan unlocks everything.

$5 per user per month (billed annually) includes:

• Unlimited boards, projects, tasks, notes, and files
• MCP server for agent self-management
• t0ggles Crew for autonomous agent orchestration (free)
• Task dependencies with Gantt view
• Custom properties for agent metadata
• Board automations for review loop management
• Board forms for intake, with an approval queue before work reaches an agent
• Full change history and audit trail
• Reports with CSV/PDF export
• All integrations (GitHub, Zapier, Google Calendar)

One paid plan. No per-seat surprises.

Free forever plan - no card required. Want the paid features first? Every first subscription starts with a 14-day free trial.

#Frequently Asked Questions

#Get Started Today

AI agents are transforming how work gets done, but they still need management - just a different kind. t0ggles gives you the structure, visibility, and AI integration to run agent workflows with confidence.

Start for free and bring order to your AI agent operations. Read the MCP server docs to connect your first agent, or download t0ggles Crew to run agents autonomously.