Coordinating Human and AI Development Teams with Leantime MCP: A Developer’s Guide to Distributed Task Management

The modern development landscape is rapidly evolving. With AI agents becoming more capable and development teams becoming more distributed, the challenge isn’t just managing code—it’s coordinating work between human developers and AI agents in a way that maximizes productivity without creating chaos.

Enter the Leantime MCP (Model Context Protocol) Server: a game-changing solution that turns your project management into a central coordination hub where both humans and AI agents can seamlessly collaborate on the same tasks, with full transparency and accountability.

Why Leantime Beats Notion for Development Team Coordination

Many development teams have gravitated toward Notion for project management, but when it comes to coordinating hybrid human-AI workflows, Leantime offers several critical advantages:

Structured Task Management: Unlike Notion’s free-form approach, Leantime provides purpose-built project management features with proper task states, assignees, and milestone tracking that both humans and AI can interpret consistently.

API-First Design: Leantime’s robust API integration makes it trivial for AI agents to interact with tasks, while Notion’s API limitations often require complex workarounds.

Built-in Workflow States: Leantime’s native task progression (Todo → In Progress → Done) provides clear states that AI agents can understand and respect, preventing conflicts and ensuring proper coordination.

Milestone-Based Organization: Leantime’s milestone structure allows for logical work grouping that scales from individual features to complex product releases.

Real-time Visibility: Unlike Notion’s database views, Leantime provides real-time task status updates that prevent multiple agents from claiming the same work.

Setting Up Your Coordination Hub

Prerequisites

Before diving into the coordination commands, ensure you have:

• A Leantime instance (cloud or self-hosted)
• Claude Desktop with MCP support
• The Leantime MCP server configured

Configure the MCP Connection

First, add the Leantime MCP server to your Claude Desktop configuration (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "leantime": {
      "command": "node",
      "args": ["/path/to/leantime-mcp-server/dist/index.js"],
      "env": {
        "LEANTIME_URL": "https://your-leantime-instance.com",
        "LEANTIME_API_KEY": "your-api-key"
      }
    }
  }
}

The Coordination Commands: Your .claude Folder Setup

Create these files in your project’s .claude folder to enable seamless human-AI coordination:

.claude/claude.md

# Project Configuration

## Leantime Project Details
- **Project ID**: 123 (Update this with your actual Leantime project ID)
- **Project Name**: Your Development Project
- **Milestone Prefix**: Use consistent naming like "Sprint-2024-Q1"

## Task Coordination Settings
- **AI Agent Label**: "AI-Agent"
- **Default Assignee for AI**: "Claude-Agent"
- **Review Required Label**: "Human-Review"
- **AI Suitable Label**: "AI-Suitable"

Always use the project ID specified above when working with Leantime tasks.

.claude/task_coordinator.md

# Leantime Task Coordination Protocol

You are a development task coordinator working with a Leantime project management system via MCP tools.

## Project Context
- Always work with project ID from claude.md configuration
- Use available Leantime MCP tools to interact with tasks
- Maintain coordination between human and AI team members

## Core Responsibilities

1. **ONLY claim tasks that are in "todo" status and unassigned**
2. **Immediately label claimed tasks with "AI-Agent" to prevent conflicts**
3. **Update task status to "in_progress" when starting work**
4. **Document all changes in task comments**
5. **Mark tasks "done" only when work is complete and tested**

## Task Claiming Workflow

### Step 1: Find Available Tasks
Use the Leantime MCP tools to query for tasks that are:
- In "todo" or "Not Done" status
- Not currently assigned to anyone
- Labeled as "AI-Suitable" (if using this labeling system)

### Step 2: Evaluate Task Suitability
Before claiming any task, verify:
- Task description contains clear acceptance criteria
- The work is within AI capabilities (coding, testing, documentation)
- No blocking dependencies exist

### Step 3: Claim the Task
Use Leantime MCP tools to:
- Assign the task to "Claude-Agent" or appropriate AI identifier
- Update status to "in_progress" or "Doing"
- Add "AI-Agent" label to prevent conflicts
- Add an initial comment indicating work has started

### Step 4: Document Progress
Throughout the work:
- Add comments explaining what you're implementing
- Note any decisions made or issues encountered
- Update the task with relevant file paths or commit references

### Step 5: Complete and Close
When finished:
- Add a comprehensive completion comment detailing what was accomplished
- Update task status to "done" or "Done"
- Include testing information and any follow-up suggestions

## Communication Protocol

Use the project description field (via Leantime MCP tools) to maintain:
- Current sprint status
- Active blockers and dependencies
- Context for both human and AI team members
- Important architectural decisions

## Escalation Guidelines

Flag tasks for human review when:
- Requirements are ambiguous or contradictory
- Significant architectural decisions are needed
- Security implications require expert review
- Integration complexity exceeds AI capabilities

Remember: The goal is transparent collaboration where both humans and AI agents can see what's being worked on and by whom.

.claude/project_setup.md

# Project Planning and Milestone Creation

When setting up a new development cycle, use this process to create a coordinated task structure using Leantime MCP tools.

## Project Configuration
- Reference the project ID from claude.md for all operations
- Use consistent milestone naming conventions
- Ensure proper task labeling for AI/human coordination

## Milestone and Task Creation Strategy

### 1. Create Development Milestones
Use Leantime MCP tools to create milestones that:
- Break large features into logical chunks (2-3 weeks of work)
- Have clear, descriptive names: "User Authentication System", "Payment Integration"
- Include realistic deadlines with buffer time
- Contain 5-15 related tasks each

### 2. Task Decomposition Principles
When creating tasks via MCP tools:
- Each task should be completable in 1-3 days
- Include detailed acceptance criteria in the description
- Specify clear inputs and expected outputs
- Add appropriate labels for coordination

### 3. Labeling System for Coordination
Implement consistent labels:
- `AI-Suitable`: Tasks that can be handled by AI agents
- `Human-Review`: Requires human oversight or decision-making
- `Blocked`: Waiting on dependencies or external resources
- `AI-Agent`: Currently being worked on by an AI agent

## Example Task Structure

Milestone: User Authentication System
├── Set up JWT authentication middleware [AI-Suitable]
│   Acceptance criteria: JWT validation, error handling, unit tests >80% coverage
├── Create user registration endpoint [AI-Suitable] 
│   Acceptance criteria: Email validation, password hashing, error responses
├── Design login UI components [Human-Review]
│   Requires UX review and accessibility compliance
├── Implement password reset flow [AI-Suitable]
│   Acceptance criteria: Email sending, token validation, secure reset process
└── Security audit and review [Human-Review]
    Final review before deployment

## Best Practices for Task Creation

1. **Clear Acceptance Criteria**: Every task should have specific, testable criteria
2. **Appropriate Sizing**: Tasks should be small enough to complete and verify quickly
3. **Dependency Mapping**: Use task descriptions to note dependencies on other work
4. **Quality Gates**: Include human review tasks at critical points
5. **Documentation Requirements**: Specify what documentation should be updated

This structure allows both humans and AI agents to pick up appropriate work while maintaining quality and coordination.

.claude/task_worker.md

# AI Task Execution Workflow

When working on claimed tasks, follow this systematic approach using Leantime MCP tools.

## Pre-Work Assessment

### 1. Understand the Context
- Use MCP tools to read the full task description and acceptance criteria
- Review the project description for current context and constraints
- Check for any dependencies or blocking issues

### 2. Verify Readiness
- Ensure all prerequisite tasks are completed
- Confirm you have access to necessary resources
- Validate that the task is appropriate for AI execution

## Work Execution Process

### 1. Claim the Task Properly
Use Leantime MCP tools to:
- Assign the task to your AI agent identifier
- Update status to indicate work in progress
- Add "AI-Agent" label for visibility
- Post initial comment: "🤖 AI Agent starting work on this task"

### 2. Implementation Guidelines
- Follow established coding standards and conventions
- Write clear, maintainable code with appropriate comments
- Include comprehensive error handling
- Consider edge cases and validation

### 3. Testing and Validation
- Write unit tests for new functionality
- Run existing test suites to prevent regressions
- Test edge cases and error conditions
- Validate against acceptance criteria

## Completion and Documentation

### 1. Comprehensive Documentation
Use MCP tools to add detailed comments including:

✅ Task completed by AI Agent

**Implemented functionality:**
- [Specific features or components added]

**Files modified/created:**
- src/auth/middleware.js: JWT validation middleware
- tests/auth/middleware.test.js: Unit tests for middleware
- docs/api/auth.md: Updated API documentation

**Testing summary:**
- 12 unit tests added
- All existing tests pass
- Code coverage: 89%

**Technical decisions:**
- Used bcrypt for password hashing (industry standard)
- JWT expiry set to 24 hours (configurable via env)
- Added rate limiting to prevent brute force attacks

**Follow-up recommendations:**
- Consider adding refresh token mechanism
- May need integration tests for full auth flow
- Security audit recommended before production

### 2. Final Status Update
- Mark task as complete using MCP tools
- Ensure all acceptance criteria are documented as met
- Add any suggestions for related future work

## Quality Assurance Checklist

Before marking any task complete:
- [ ] All acceptance criteria are met
- [ ] Code follows project conventions
- [ ] Appropriate tests are written and passing
- [ ] Documentation is updated
- [ ] No obvious security vulnerabilities
- [ ] Error handling is comprehensive

## Escalation Protocol

Use MCP tools to add escalation comments when:
- Task scope is unclear or requirements conflict
- Architectural decisions exceed AI authority
- Security implications need expert review
- External integrations require human coordination

Example escalation:
🚨 ESCALATION NEEDED

This task requires decision on database schema changes that could affect other components. 
The current requirement conflicts with existing user table structure.

Recommended action: Human architect review before proceeding.
Blocking issue: Table migration strategy needs approval.

@human-lead please advise on approach.

Remember: The goal is to produce high-quality work while maintaining clear communication about what was done and why.

Practical Implementation Guide

Getting Started Workflow

1. Initial Setup

   • Configure your Leantime MCP connection
   • Update the project ID in .claude/claude.md
   • Create your first milestone with mixed task types

2. First Sprint Planning

   • Human product owner creates milestone goals
   • Use MCP tools to break down work into appropriate tasks
   • Label tasks clearly for AI/human distribution
   • Set up initial project description with context

3. Daily Operations

   • AI agents query for available “AI-Suitable” tasks
   • Claim and execute work following the established protocol
   • Update progress and status in real-time
   • Human team members handle “Human-Review” items

Advanced Coordination Patterns

Dependency Management: Use task descriptions to clearly note dependencies. AI agents should check dependent task status before starting work.

Quality Gates: Create mandatory human review tasks at critical points like security audits, architectural decisions, and deployment preparation.

Progress Tracking: Use the project description as a living dashboard updated by both humans and AI agents with current status, blockers, and recent completions.

Escalation Handling: Establish clear protocols for when AI agents should pause work and request human guidance.

Benefits of This Approach

1. Continuous Progress: Work continues 24/7 as AI agents can pick up tasks anytime
2. Clear Accountability: Every action is documented with proper attribution
3. Quality Maintenance: Human oversight at critical decision points
4. Scalable Coordination: Multiple AI agents can work simultaneously without conflicts
5. Transparent Communication: All team members see real-time status and progress

Best Practices for Success

1. Start Small: Begin with simple, well-defined tasks to build confidence
2. Clear Boundaries: Be explicit about what tasks are suitable for AI vs human work
3. Regular Reviews: Schedule periodic reviews of AI-completed work
4. Iterative Improvement: Refine task descriptions and processes based on experience
5. Maintain Communication: Keep project context updated for all team members

The future of development is about seamless human-AI collaboration. With Leantime MCP and proper coordination protocols, you can create a development team that leverages the best of both human creativity and AI efficiency, delivering higher quality results faster than traditional approaches.

Ready to get started? Sign Up for Leantime here or download our open source version, configure your project ID, and create your first coordinated milestone. The hybrid development team of the future is ready to work.