4,500+ servers built on MCP Fusion
Vinkius

GitScrum Tasks MCP. Manage tasks and track progress without leaving your chat.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

GitScrum Tasks MCP on Cursor AI Code Editor MCP Client GitScrum Tasks MCP on Claude Desktop App MCP Integration GitScrum Tasks MCP on OpenAI Agents SDK MCP Compatible GitScrum Tasks MCP on Visual Studio Code MCP Extension Client GitScrum Tasks MCP on GitHub Copilot AI Agent MCP Integration GitScrum Tasks MCP on Google Gemini AI MCP Integration GitScrum Tasks MCP on Lovable AI Development MCP Client GitScrum Tasks MCP on Mistral AI Agents MCP Compatible GitScrum Tasks MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

GitScrum Tasks is an MCP Server for managing the entire task lifecycle directly through your AI client. You can create, update, delete tasks, and manage associated subtasks without ever leaving your IDE or chat window.

It lets you assign team members using `assign_member`, track progress with checklists (`create_checklist_item`), write comments (`create_comment`), and query project status using advanced filters like `list_tasks`.

Master complex Scrum workflows conversationally.

What your AI agents can do

Assign member

Adds a specified user to a task, assigning ownership or responsibility.

Create checklist item

Adds a specific item to an existing checklist on a task, useful for tracking sub-steps.

Create comment

Writes a new comment to a task and includes rich text formatting for detailed notes.

+ 25 more capabilities included
View and Query Task Data

Retrieve task details by UUID (get_task), search by human-readable code (get_task_by_code), or list filtered tasks across the project using advanced parameters like status, user story, or date ranges (list_tasks).

Modify Task Status and Ownership

Change a task's state (e.g., toggle completion via toggle_task_done), assign or unassign team members (assign_member, unassign_member), or move the ticket between different projects (move_task_to_project).

Build Out Task Details

Add structured details like story points (set_task_estimate), link existing tasks as subtasks (link_subtask), or create detailed checklists with nested items (create_checklist_item).

Communicate and Document Changes

Write, update, or delete comments on a task using rich text content (create_comment, update_comment) to maintain a complete collaboration history.

Manage Task Structure

Create entirely new tasks from scratch (create_task), or replicate existing ones to start fresh work using the duplicate_task tool. You can also define custom task types with colors via create_task_type.

Review Personal Workload

Quickly pull up your pending items (my_tasks) or see exactly what's due today using the my_today_tasks tool without manually checking a calendar.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

GitScrum Tasks: 28 Tools for Task & Workflow Management

Manage every aspect of your project board—from creating tasks to updating comments—by calling these specific, granular tools through your AI agent.

assign019d8441

assign member

Adds a specified user to a task, assigning ownership or responsibility.

create019d8441

create checklist item

Adds a specific item to an existing checklist on a task, useful for tracking sub-steps.

create019d8441

create comment

Writes a new comment to a task and includes rich text formatting for detailed notes.

create019d8441

create task

Generates an entirely new ticket in the system with defined parameters like title and description.

create019d8441

create task type

Defines a custom category or type for tasks (e.g., 'Chore' or 'Tech Debt') within your project scope.

delete019d8441

delete comment

Permanently removes an existing comment from a task's history.

delete019d8441

delete task

Wipes a task record permanently. This action cannot be undone.

duplicate019d8441

duplicate task

Creates an exact copy of an existing ticket, useful when starting similar work.

get019d8441

get task

Retrieves all data for one specific task using its unique UUID identifier.

get019d8441

get task by code

Finds a task record by a human-readable code, like 'WEB-42', instead of requiring the UUID.

link019d8441

link subtask

Connects an existing ticket to another one, making it function as a sub-step or dependency.

list019d8441

list checklists

Retrieves all checklists currently attached to a specific task ID.

list019d8441

list comments

Pulls a history of comments for a task, supporting rich text retrieval.

list019d8441

list effort levels

Shows the defined effort or priority levels available for use on tasks in your project.

list019d8441

list subtasks

Lists all linked subtasks associated with a primary task ID.

list019d8441

list task types

Displays every custom task type defined within the current project, including their assigned hex colors.

list019d8441

list tasks

Runs detailed searches across the entire board using up to 10 filters (status, assignee, date range, etc.).

move019d8441

move task to project

Transfers an existing task ticket from its current project to a completely different project.

my019d8441

my tasks

Gets a list of every single task that has been assigned directly to you.

my019d8441

my today tasks

Pulls only the tasks that are scheduled or due for completion on the current day.

related019d8441

related tasks

Finds and lists other tickets that share a dependency or connection with the task you're currently viewing.

set019d8441

set task estimate

Applies story points or an effort estimate to a task, providing necessary planning data.

toggle019d8441

toggle checklist item

Marks one specific item within a checklist as done or undone.

toggle019d8441

toggle task done

Changes the overall status of the main task—marking it complete or reopening it.

unassign019d8441

unassign member

Removes an assigned user from a task, freeing up ownership.

unlink019d8441

unlink subtask

Breaks the link between a primary task and one of its subtasks.

update019d8441

update comment

Edits the text content of an existing comment without deleting it entirely.

update019d8441

update task

Modifies general details on a task, like changing the title or description, while keeping its ID intact.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

  • Import from OpenAPI, Swagger, or YAML specs
  • Create Agent Skills with progressive disclosure
  • Deploy to edge with MCPFusion framework
  • Built in DLP, auth, and compliance on every call
  • Real time usage dashboard and cost metering
  • Publish to catalog or keep private
Start building

Make Your AI Do More

Start with GitScrum Tasks, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ others, all in one place
  • Add new capabilities to your AI anytime you want
  • Every connection is secured and compliant automatically
  • Track usage and costs across all your servers
  • Works with Claude, ChatGPT, Cursor, and more
  • New servers added to the catalog every week

What you can do with this MCP connector

Listen up. GitScrum Tasks isn't just another API endpoint you gotta juggle; it’s your whole task management system talking directly through your AI client. You manage the entire lifecycle of a ticket—from idea to done—without ever leaving your chat window or IDE. Forget context-switching between Jira and Slack; you handle everything right here.

Finding What You Need

You don't have time clicking through endless Kanban boards. If you gotta find something, this thing handles it fast. You can pull up all the details for a specific ticket using its unique ID with get_task, or if your team uses human-readable codes—like 'WEB-42'—you just use get_task_by_code. Need to see what's happening across the board? Use list_tasks; you can filter results instantly by status, assignee, date range, and more.

For a personal view, you've got my_tasks to pull up everything assigned directly to you, or if you just wanna know what’s due today, my_today_tasks shows it right up.

It also keeps tabs on dependencies. If you open a ticket, the system finds all related tickets using related_tasks. You can check out every subtask linked to a main task with list_subtasks, and if you need to see what other checklist items are attached, use list_checklists.

Moving Tickets Through Workflow

When it comes time to move things along, you've got plenty of options. You change the overall status of a task—marking it complete or reopening it—using toggle_task_done. If someone else owns the ticket, you can assign ownership with assign_member or free them up using unassign_member. Need to shift a project entirely? Use move_task_to_project to transfer an existing task ticket between different projects.

You can also make sure tickets are structured right by connecting one ticket to another as a sub-step via link_subtask, or break that connection using unlink_subtask. To start fresh work, you've got duplicate_task, which makes an exact copy of any existing ticket.

Building Out the Details and Talking Shop

You need to add depth? You can apply story points or effort estimates with set_task_estimate so the team knows how big this thing is. For detailed tracking, you build out checklists using create_checklist_item, and if something gets checked off, you toggle it done or undone with toggle_checklist_item. All communication stays right on the ticket.

You can write a brand new comment using create_comment—and yeah, you get rich text formatting for detailed notes. If you mess up your thoughts, don't sweat it; use update_comment to edit an existing note without deleting the history. You can even wipe out old comments entirely with delete_comment.

Structuring and Maintaining Projects

This server lets you build the project structure itself. If the team needs a new task category, you define it using create_task_type, which also assigns custom colors to those types. You can create a brand-new ticket from scratch with create_task, or if that’s not enough, you can modify general details on any task—changing the title or description while keeping its ID intact—with update_task.

If a ticket needs more help tracking progress, you can link existing tickets to it as subtasks using link_subtask. You're always in control: if you need a complete history of notes, use list_comments and list_subtasks; if you gotta see what effort levels the team uses, pull that list with list_effort_levels.

Finally, it helps you manage your workload by listing all tasks assigned to you (my_tasks) or pulling up only those due today using my_today_tasks. You can also check out every custom task type defined in the project with list_task_types, which shows you their hex colors for visual reference. If a ticket has checklist details, you pull them all with list_checklists.

How GitScrum Tasks MCP Works

  1. 1 First, subscribe to GitScrum Tasks and enter your API token and company slug into Vinkius. This connects your AI client to the task data.
  2. 2 Next, issue a conversational command—like asking your agent, "Show me all unassigned bug tickets with high effort." Your agent executes multiple tools in sequence.
  3. 3 Finally, you get an actionable summary delivered directly to your chat window, allowing you to immediately assign members (assign_member) or start creating comments (create_comment) without leaving your AI interface.

The bottom line is that the server abstracts away all API calls and complex data structures, letting you manage project flow using simple natural language prompts.

Who Is GitScrum Tasks MCP For?

Anyone who spends their day jumping between Jira, Slack, GitHub, and email to move a single task from 'To Do' to 'Done'. This server is for the Product Manager drowning in status updates, the Developer tired of context switching from code to ticket editor, or the Scrum Master needing real-time sprint data without manual report generation.

Scrum Master

Using list_tasks and set_task_estimate, you manage the entire sprint backlog. You assign tasks (assign_member) and ensure story points are correctly logged before a review meeting.

Product Manager

You use advanced filtering (e.g., by label or effort level) with list_tasks to quickly validate product progress across multiple dimensions, validating scope creep instantly.

Developer

When you finish a code block, you tell your agent to mark the task complete (toggle_task_done), add specific technical notes via create_comment, and check off investigation steps using create_checklist_item—all without opening the web UI.

What Changes When You Connect

  • Eliminate context switching. You manage the whole task lifecycle (create, assign, update) using natural language prompts—no need to open a browser tab or switch applications.
  • Get deep visibility into team workload. Use my_tasks and list_tasks to pull up all tasks assigned to you or filter the entire board by specific criteria (e.g., 'unassigned' or 'blocker flag').
  • Track progress granularly. Don't just rely on a simple status change. Add detailed checklists with create_checklist_item and mark items complete using toggle_checklist_item for precise reporting.
  • Maintain perfect history. Every comment, assignment, or state change is logged instantly via create_comment, giving every teammate full context without manual documentation.
  • Accelerate planning. Use set_task_estimate to apply story points and quickly gauge the complexity of a feature directly within your workflow chat.

Real-World Use Cases

01

The Daily Status Report

A Scrum Master needs an update before standup. Instead of manually opening the board, they ask their agent to 'Show me all tasks in progress that are assigned and have high effort.' The server runs list_tasks, pulls the filtered data, and gives a bulleted summary with status details, solving the need for real-time reporting.

02

Mid-Sprint Detailing

A developer receives a vague ticket ('Fix login bug'). Instead of guessing what's needed, they use their agent to 'Add investigation steps checklist items to WEB-51.' The server runs create_checklist_item, providing an immediate, actionable plan for the fix.

03

Revising a Requirement

A Product Manager realizes that two existing tasks are actually parts of the same feature. They run 'Link WEB-30 to WEB-55 as subtask.' The server executes link_subtask, structurally linking the tickets and keeping them together in the project view.

04

Handing Off Ownership

A developer finishes their part of a task but needs QA to take over. They prompt: 'Unassign me from WEB-42 and assign it to Jane Doe.' The agent runs unassign_member followed by assign_member, seamlessly transferring the ticket ownership without any manual clicks.

The Tradeoffs

Status Check via Dashboard

A user opens the GitScrum UI, filters by 'To Do,' then scrolls through 50 cards looking for one specific unassigned bug. This is slow and error-prone.

Don't browse. Ask your agent: 'List all tasks with status To Do that are labeled Bug.' The server runs list_tasks instantly, providing a filtered list in seconds.

Adding Notes via Email

The team decides to discuss task WEB-42's scope changes on Slack. This note is separated from the ticket and might get lost or outdated.

Keep context centralized. Use create_comment directly through your agent. The comment gets added instantly to the task record, keeping all conversation tied to the source of truth.

Starting Over with a Clone

A developer has to manually copy data and re-enter details for a new ticket based on an old one, risking typos.

Use duplicate_task. This tool makes an exact, functional copy of the entire ticket, including history and subtasks. You just change the title and start writing.

When It Fits, When It Doesn't

Use this server if your primary bottleneck is moving information between tools—for example, transferring task status from a chat conversation into a board update. This tool shines when you need to perform multi-step actions (e.g., list_tasks -> find ID -> assign_member) without leaving the AI interface.

Don't use this if your only goal is viewing raw, unfiltered data that doesn't fit into a structured task model; in those cases, a direct API query or specialized reporting tool might be better. Also, don't rely on it for complex CI/CD pipeline management—it manages tickets, not code commits.

The key is understanding the difference between Task State Management (which this server provides) and Code Repository Operations (which requires a separate Git integration).

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by GitScrum. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

How we secure it →

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This server provides 28 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

assign_member create_checklist_item create_comment create_task create_task_type delete_comment delete_task duplicate_task get_task get_task_by_code link_subtask list_checklists list_comments list_effort_levels list_subtasks list_task_types list_tasks move_task_to_project my_tasks my_today_tasks related_tasks set_task_estimate toggle_checklist_item toggle_task_done unassign_member unlink_subtask update_comment update_task

Manually updating task status across different platforms shouldn't take half an hour.

Right now, if your team needs to update the progress on ten tickets—say, marking them from 'In Progress' to 'Ready for Review' and making sure they are all assigned to QA—you have to open the board. You click ticket one, change status; repeat for two... you copy the IDs into a spreadsheet just to confirm who owns it next.

With this MCP server, you simply tell your agent: "Change WEB-42 through WEB-51 to 'Ready for Review' and assign them all to QA.". The agent runs multiple `update_task` and `assign_member` calls in seconds. You get a confirmation message, and the entire board state is updated without you touching the UI.

GitScrum Tasks MCP Server: Complete Task & Checklist Management

You used to have to create tickets, then open them in a second tab to add subtasks. Then you had to go back and write a comment detailing who needed what—a process that required at least three different tabs and significant copy-pasting.

Now, it's all one conversation. You tell your agent to 'Create a new task for the auth flow, link WEB-51 as subtask, and add a checklist for testing.' The server handles `create_task`, `link_subtask`, and `create_checklist_item` in sequence. It just works.

Common Questions About GitScrum Tasks MCP

How do I get all tasks assigned to me using the GitScrum Tasks MCP Server? +

Use the my_tasks tool. This immediately retrieves a list of every task that has been assigned directly to your user ID, giving you an instant overview of your current workload.

Can I use the GitScrum Tasks MCP Server to find a task if I don't have its UUID? +

Yes. Use get_task_by_code. Instead of needing the long UUID string, you just provide the human-readable code, like 'WEB-42', and the server finds the details for you.

What is the best way to track subtasks using the GitScrum Tasks MCP Server? +

You use list_subtasks first to see what's linked. Then, if needed, you can run create_checklist_item on the main task to add granular steps for tracking progress.

Can I write a comment and change the status in one go using GitScrum Tasks MCP Server? +

Yes. Your agent handles this sequence. You tell it, 'Mark WEB-42 done and leave a note that QA signed off.' The agent executes toggle_task_done then create_comment.

How do I authenticate the GitScrum Tasks MCP Server after initial setup? +

You connect using your unique API token and company slug. These credentials grant your AI client permission to read and write data directly within your specified GitScrum instance.

What are the safety precautions when using the delete_task tool in GitScrum Tasks? +

Be careful, because calling the delete_task tool permanently removes a task. This action cannot be undone by the server or your AI client, so always confirm before running it.

How can I use list_tasks to filter tasks across multiple dimensions in GitScrum Tasks? +

You combine filters like status, sprint, and user story labels into a single request. For example, you can find all 'In Progress' tasks assigned to a specific label within the last week.

What data is required when using the set_task_estimate tool in GitScrum Tasks? +

The set_task_estimate tool requires a target task UUID and an integer value representing story points or effort. It updates the numerical estimate directly on the specified record.

Can my AI agent find a specific task by its human-readable code like WEB-42? +

Yes! Use the get_task_by_code tool with the task code (e.g., WEB-42). Your agent will return the full task details including description, assignees, workflow status, labels, sprint association, time estimates, and checklist progress — in seconds.

I want to quickly see what I need to work on today. Can the agent help? +

Absolutely. Use my_today_tasks to see everything due today, or my_tasks for your full assignment list across all workspaces. The agent returns task titles, project context, due dates, and current workflow status — your daily standup briefing in one command.

Can the agent manage task assignments and checklists too? +

Yes. Use assign_member and unassign_member to manage task assignments by username. For checklists, use create_checklist_item to add items (including nested sub-items via parent_id), and toggle_checklist_item to mark them done. The complete task lifecycle is covered — from creation to completion.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 28 tools

We've already built the connector for GitScrum Tasks. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 28 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.